2019 এসেছে এবং সম্ভবত সকলেই এই সংখ্যার অদ্ভুততা লক্ষ্য করেছেন: এটি আসলে দুটি উপ-সংখ্যা (20 এবং 19) দ্বারা রচিত যা ক্রমাগত অবতীর্ণ সংখ্যার ক্রম উপস্থাপন করে।

চ্যালেঞ্জ

একটি নম্বর দেওয়া হয়েছে x, ধারাবাহিকের সর্বোচ্চ ক্রমের দৈর্ঘ্য, অবতীর্ণ সংখ্যাগুলি উপ-সংখ্যা গ্রহণ করে গঠন করা যায় তা ফিরিয়ে দিন x।

মন্তব্য :

উপ-সংখ্যাগুলিতে নেতৃস্থানীয় জিরো থাকতে পারে না (যেমন 1009বিভক্ত করা যায় না 10, 09)
ধারাবাহিক এবং উতরাই মানে ক্রমানুসারে একটি সংখ্যা অবশ্যই পূর্ববর্তী সংখ্যা -1 এর সমান হতে হবে, বা (যেমন বিভক্ত হতে পারে না কারণ এবং পরপর নয় ), $n_{i+1} = n_{i}-1$ 525,2522 ≠ 5 - 1
ক্রম পূর্ণ সংখ্যা যেমন ব্যবহার দ্বারা প্রাপ্ত করা আবশ্যক 7321আপনি বাতিল করতে পারবে না 7এবং ক্রম পেতে 3, 2,1
শুধুমাত্র এক ক্রম নম্বর থেকে প্রাপ্ত করা যাবে, যেমন 3211098বিভক্ত দুই সিকোয়েন্স মধ্যে হতে পারে না 3, 2, 1এবং 10, 9,8

ইনপুট

একটি পূর্ণসংখ্যা নম্বর ( >= 0): একটি সংখ্যা, বা স্ট্রিং বা অঙ্কের তালিকা হতে পারে

আউটপুট

একটি একক পূর্ণসংখ্যা হ্রাসমান সাব-সংখ্যার সর্বাধিক সংখ্যাকে দেওয়া হয়েছে (দ্রষ্টব্য যে এই সংখ্যার নিম্ন-সীমানা 1, অর্থাত একটি সংখ্যা একটি দৈর্ঘ্যের ক্রমবর্ধমান ক্রমতে নিজেই রচিত)

উদাহরণ:

2019         --> 20,19           --> output : 2
201200199198 --> 201,200,199,198 --> output : 4
3246         --> 3246            --> output : 1
87654        --> 8,7,6,5,4       --> output : 5
123456       --> 123456          --> output : 1
1009998      --> 100,99,98       --> output : 3
100908       --> 100908          --> output : 1
1110987      --> 11,10,9,8,7     --> output : 5
210          --> 2,1,0           --> output : 3
1            --> 1               --> output : 1
0            --> 0               --> output : 1
312          --> 312             --> output : 1
191          --> 191             --> output : 1

সাধারণ নিয়ম:

এটি কোড-গল্ফ , তাই বাইট জেতে সংক্ষিপ্ত উত্তর।
কোড-গল্ফ ভাষাগুলি আপনাকে নন-কোডগলফিং ভাষার সাথে উত্তর পোস্ট করতে নিরুৎসাহিত করবেন না। 'যে কোনও' প্রোগ্রামিং ভাষার পক্ষে যতটা সম্ভব সংক্ষিপ্ত উত্তর নিয়ে আসার চেষ্টা করুন।
আপনার উত্তরটির জন্য ডিফল্ট আই / ও বিধিগুলির সাথে মানক বিধিগুলি প্রযোজ্য , সুতরাং আপনাকে সঠিক পরামিতি এবং ফিরতি-টাইপ, সম্পূর্ণ প্রোগ্রাম সহ STDIN / STDOUT, ফাংশন / পদ্ধতি ব্যবহারের অনুমতি দেওয়া হবে। আপনার কল
ডিফল্ট লুফোলগুলি নিষিদ্ধ।
যদি সম্ভব হয় তবে আপনার কোডের (যেমন টিআইও ) একটি পরীক্ষার সাথে একটি লিঙ্ক যুক্ত করুন ।
এছাড়াও, আপনার উত্তরের জন্য একটি ব্যাখ্যা যুক্ত করা অত্যন্ত প্রস্তাবিত।

code-golf

— digEmAll
সূত্র

1

স্যান্ডবক্স থেকে স্থানান্তরিত

— সেকশনস

1

পরীক্ষার কেসটি কি 210 -> 2,1,0ভুল (একই সাথে 0 -> 0)? কার্যগুলি বলে যে " উপ-সংখ্যাগুলিতে নেতৃস্থানীয় জিরো থাকতে পারে না ", শূন্য কি একটি বিশেষ ক্ষেত্রে?

— ბიმო

2

@ বিএমও: ভাল, এখানে বিষয়টি দয়ালু ফিলোসোফিক্যাল ...: আমার কাছে ডি 0, কোনও সংখ্যা (অকেজো) শূন্যের একটি সংখ্যা, তাই হ্যাঁ শূন্য একটি বিশেষ ক্ষেত্রে

— ডিইজিএল সব

2

এইসব কল করবে ... ক্ষমশীল নম্বর? এক্সডি দুঃখিত যে এটি

— মজারও

দুঃখিত, আমার মন্তব্য মুছে ফেলা হয়েছে যার বিষয়ে আমি জিজ্ঞাসা করেছি 212019। দেখে মনে হচ্ছে আমি সমস্ত নিয়ম পড়িনি।

— চক্রবিজ্ঞানী

6

জেলি , 15 9 বাইট

বাগফিক্স ধন্যবাদ ডেনিসকে

ŻṚẆDfŒṖẈṀ

এটি অনলাইন চেষ্টা করুন! (321কোডটি কমপক্ষে $O(N^2)$ হ'লএমনকিআধ মিনিট সময় নেয়)

কিভাবে?

ŻṚẆDfŒṖẈṀ - Link: integer, n
Ż         - [0..n]
 Ṛ        - reverse
  Ẇ       - all contiguous slices (of implicit range(n)) = [[n],...,[2],[1],[0],[n,n-1],...,[2,1],[1,0],...,[n,n-1,n-2,...,2,1,0]]
   D      - to decimal (vectorises)
     ŒṖ   - partitions of (implicit decimal digits of) n
    f     - filter discard from left if in right
       Ẉ  - length of each
        Ṁ - maximum

— জোনাথন অ্যালান
সূত্র

6

জাভাস্ক্রিপ্ট (ES6), 56 বাইট

আরবোর পাইথন উত্তরের একটি বন্দর উল্লেখযোগ্যভাবে খাটো। তবে খুব বেশি পুনরাবৃত্তি হওয়ার কারণে এটি কিছু পরীক্ষার ক্ষেত্রে ব্যর্থ হয়।

f=(n,a=0,c=0,s)=>a<0?f(n,a-~c):n==s?c:f(n,--a,c+1,[s]+a)

এটি অনলাইন চেষ্টা করুন!

জাভাস্ক্রিপ্ট (ES6), 66 বাইট

স্ট্রিং হিসাবে ইনপুট নেয়।

f=(s,n=x='',o=p=n,i=0)=>s[i++]?o==s?i:f(s,--n,o+n,i):f(s,p+s[x++])

এটি অনলাইন চেষ্টা করুন!

f = (               // f = recursive function taking:
  s,                //   s = input number, as a string
  n =               //   n = counter
  x = '',           //   x = position of the next digit to be added to p
  o = p = n,        //   o = generated output; p = prefix
  i = 0             //   i = number of consecutive descending numbers
) =>                //
  s[i++] ?          // increment i; if s[i] was defined:
    o == s ?        //   if o is matching s:
      i             //     stop recursion and return i
    :               //   else:
      f(            //     do a recursive call with:
        s,          //       s unchanged
        --n,        //       n - 1
        o + n,      //       (n - 1) appended to o
        i           //       i unchanged (but it was incremented above)
      )             //     end of recursive call
  :                 // else:
    f(              //   this is a dead end; try again with one more digit in the prefix:
      s,            //     s unchanged
      p + s[x++]    //     increment x and append the next digit to p
    )               //   end of recursive call

— Arnauld
সূত্র

আমার কোড পরিবর্তনগুলি প্রয়োগ করে 54 বাইট

— আরবো

5

পার্ল 6 , 43 41 40 বাইট

-1 বাইট ধন্যবাদ নওহেলহোফকে

{/(<-[0]>.*?|0)+<?{[==] 1..*Z+$0}>/;+$0}

এটি অনলাইন চেষ্টা করুন!

রেজেক্স ভিত্তিক সমাধান। আমি পরিবর্তে একটি উত্থানের তালিকা থেকে মেলে আরও ভাল উপায় নিয়ে আসার চেষ্টা করছি, তবে পার্ল 6 পার্টিশনটি ভাল করে না

ব্যাখ্যা:

{                                        }  # Anonymous code block
 /                                /;        # Match in the input
   <-[0]>.*?      # Non-greedy number not starting with 0
            |0    # Or 0
  (           )+  # Repeatedly for the rest of the number
                <?{             }>  # Where
                        1..*Z+$0       # Each matched number plus the ascending numbers
                                       # For example 1,2,3 Z+ 9,8,7 is 10,10,10
                   [==]                # Are all equal
                                    +$0  # Return the length of the list

— জো কিং
সূত্র

40 বাইট

— নয়েলহোহফ

4

পাইথন 3 , 232 228 187 181 180 150 149 বাইট

-1 জনাথন ফ্র্যাচকে ধন্যবাদ

e=enumerate
t=int
h=lambda n,s=1:max([1]+[i-len(n[j:])and h(n[j:],s+1)or s+1for j,_ in e(n)for i,_ in e(n[:j],1)if(t(n[:j])-t(n[j:j+i])==1)*t(n[0])])

এটি অনলাইন চেষ্টা করুন!

প্রাথমিক অবারিত কোড:

def count_consecutives(left, right, so_far=1):
    for i,_ in enumerate(left, start=1):
        left_part_of_right, right_part_of_right = right[:i], right[i:]
        if (int(left) - int(left_part_of_right)) == 1:
            if i == len(right):
                return so_far + 1
            return count_consecutives(left_part_of_right, right_part_of_right, so_far + 1)
    return so_far

def how_many_consecutives(n):
    for i, _ in enumerate(n):
        left, right = n[:i], n[i:]
        for j, _ in enumerate(left, start=1):            
            left_part_of_right = right[:j]
            if int(left) - int(left_part_of_right) == 1 and int(n[i]) > 0:     
                return count_consecutives(left, right)
    return 1

— Nishioka
সূত্র

1

s+1 forহতে পারে s+1for, (t(n[:j])-t(n[j:j+i])==1)*t(n[0])হতে পারে t(n[:j])-t(n[j:j+i])==1>=t(n[0])।

— জোনাথন ফ্রেচ

দেখে মনে হচ্ছে যে দ্বিতীয় পরামর্শটি কোনও কাজ না নিলেও এটি কাজ করে না কারণ এরপরে আপনাকে পৃথকীকরণের জন্য পৃথক স্থান প্রয়োজন if।

— নিশিওকা

সত্য ... বিকল্প 149 ।

— জনাথন ফ্রেচ 15

4

পাইথন 2 , 78 74 73 বাইট

l=lambda n,a=0,c=0,s="":c*(n==s)or a and l(n,a-1,c+1,s+`a-1`)or l(n,a-~c)

এটি অনলাইন চেষ্টা করুন!

_{-1 বাইট ধন্যবাদ আর্নল্ডকে}

স্ট্রিং হিসাবে ইনপুট নেয়। প্রোগ্রামটি বরং দ্রুত পাইথনের পুনরাবৃত্তি গভীরতার সীমাতে চলে যায় তবে এটি বেশিরভাগ পরীক্ষার ক্ষেত্রে শেষ করতে পারে।

কিভাবে এটা কাজ করে

l=lambda n,                              # The input number, in the form of a string
         a=0,                            # The program will attempt to reconstruct n by
                                         #  building a string by pasting decreasing
                                         #  numbers, stored in a, after each other.
         c=0,                            # A counter of the amount of numbers
         s="":                           # The current constructed string
              c*(n==s)                   # Return the counter if s matches n
              or                         # Else
              a and l(n,a-1,c+1,s+`a-1`) # If a is not yet zero, paste a-1 after s
              or                         # Else
              l(n,a-~c)                  # Start again, from one higher than last time

— ArBo
সূত্র

1

চমৎকার উত্তর! a+c+1সংক্ষিপ্ত করা যেতে পারে a-~c।

— আর্নৌল্ড

3

05 এ বি 1 ই , 10 বাইট

ÝRŒʒJQ}€gà

অত্যন্ত ধীর গতির, সুতরাং নীচের টিআইও কেবলমাত্র 750 এর নীচের পরীক্ষার ক্ষেত্রে কাজ করে ..

এটি অনলাইনে চেষ্টা করুন ।

ব্যাখ্যা:

Ý           # Create a list in the range [0, (implicit) input]
            #  i.e. 109 → [0,1,2,...,107,108,109]
 R          # Reverse it
            #  i.e. [0,1,2,...,107,108,109] → [109,108,107,...,2,1,0]
  Œ         # Get all possible sublists of this list
            #  i.e. [109,108,107,...,2,1,0]
            #   → [[109],[109,108],[109,108,107],...,[2,1,0],[1],[1,0],[0]]
   ʒ  }     # Filter it by:
    J       #  Where the sublist joined together
            #   i.e. [10,9] → "109"
            #   i.e. [109,108,107] → "109108107"
     Q      #  Are equal to the (implicit) input
            #   i.e. 109 and "109" → 1 (truthy)
            #   i.e. 109 and "109108107" → 0 (falsey)
       €g   # After filtering, take the length of each remaining inner list
            #  i.e. [[109],[[10,9]] → [1,2]
         à  # And only leave the maximum length (which is output implicitly)
            #  i.e. [1,2] → 2

— কেভিন ক্রুইজসেন
সূত্র

2

কোড গল্ফ - যেখানে আপনার প্রোগ্রামে 1 বাইট যুক্ত n!করা n lg nঠিক ততটাই মূল্যহীন।

— কর্সিকা

3

পাইথ, 16 বাইট

lef!.EhM.+vMT./z

এটি এখানে অনলাইনে চেষ্টা করুন , বা এখানে সমস্ত পরীক্ষার কেস একবারে যাচাই করুন ।

lef!.EhM.+vMT./z   Implicit: z=input as string
             ./z   Get all divisions of z into disjoint substrings
  f                Filter the above, as T, keeping those where the following is truthy:
          vMT        Parse each substring as an int
        .+           Get difference between each pair
      hM             Increment each
   !.E               Are all elements 0? { NOT(ANY(...)) }
 e                 Take the last element of the filtered divisions
                     Divisions are generated with fewest substrings first, so last remaining division is also the longest
l                  Length of the above, implicit print

— সোক
সূত্র

3

জেলি , 11 বাইট

ŒṖḌ’Dɗ\ƑƇẈṀ

$O\left(n^{0.3}\right)$

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

ŒṖḌ’Dɗ\ƑƇẈṀ  Main link. Argument: n (integer)

ŒṖ           Yield all partitions of n's digit list in base 10.
        Ƈ    Comb; keep only partitions for which the link to the left returns 1.
       Ƒ       Fixed; yield 1 if calling the link to the left returns its argument.
      \          Cumulatively reduce the partition by the link to the left.
     ɗ             Combine the three links to the left into a dyadic chain.
  Ḍ                  Undecimal; convert a digit list into an integer.
   ’                 Decrement the result.
    D                Decimal; convert the integer back to a digit list.

— ডেনিস
সূত্র

3

কাঠকয়লা , 26 বাইট

Ｆ⊕ＬθＦ⊕Ｌθ⊞υ⭆κ⁻Ｉ…θιλＩ﹪⌕υθ⊕Ｌθ

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ব্যাখ্যা:

Ｆ⊕Ｌθ

ইনপুটটির iদৈর্ঘ্যে 0 থেকে লুপ করুন।

Ｆ⊕Ｌθ

ইনপুটটির kদৈর্ঘ্যে 0 থেকে লুপ করুন।

⊞υ⭆κ⁻Ｉ…θ⊕ιλ

ইনপুটটির kপ্রথম iঅঙ্কগুলির দ্বারা প্রদত্ত সংখ্যা থেকে শুরু করে অবতরণী ক্রমের প্রথম সংখ্যাগুলি গণনা করুন, তাদেরকে সংযুক্ত করুন এবং প্রতিটি ফলাফলের স্ট্রিং পূর্বনির্ধারিত খালি তালিকায় জমা করুন।

Ｉ﹪⌕υθ⊕Ｌθ

ইনপুটটির প্রথম মিলের অনুলিপিটির অবস্থান সন্ধান করুন এবং ইনপুটটির দৈর্ঘ্যের তুলনায় 1 টি আরও কমিয়ে আনুন।

উদাহরণ: 2019নিম্নলিখিত স্ট্রিংগুলির একটি ইনপুট দেওয়ার জন্য :

 0
 1  0
 2  0-1
 3  0-1-2
 4  0-1-2-3
 5  
 6  2
 7  21
 8  210
 9  210-1
10  
11  20
12  2019
13  201918
14  20191817
15  
16  201
17  201200
18  201200199
19  201200199198
20  
21  2019
22  20192018
23  201920182017
24  2019201820172016

2019 তারপরে 12 টি সূচকে পাওয়া যাবে যা মডিউল 5 হ্রাস করে 2, পছন্দসই উত্তর দেবে।

— নিল
সূত্র

3

হাস্কেল, 87 বাইট

maximum.map length.(0#)
a#(b:c)=[a:x|c==[]||b>0,x<-b#c,a==x!!0+1]++(10*a+b)#c
a#b=[[a]]

ইনপুট হ'ল সংখ্যার একটি তালিকা।

এটি অনলাইন চেষ্টা করুন!

ফাংশন #উভয়কেই দেখে সম্ভাব্য সকল বিভাজনের একটি তালিকা তৈরি করে

aবাকি ইনপুট ( x<-b#c) এর সাথে পুনরাবৃত্ত কল দিয়ে সমস্ত বিভাজনে বর্তমান নম্বরটি প্রেরণ করা কেবলমাত্র পরবর্তী সংখ্যাটি শূন্য ( b>0) না হলে (বা এটি ইনপুট ( c==[])) এর সর্বশেষ সংখ্যা এবং aপ্রথমটির চেয়ে বড় হয় পূর্ববর্তী বিভক্ত সংখ্যা x( a==x!!0+1)।

এবং

bবর্তমান সংখ্যাতে ইনপুট তালিকা থেকে পরবর্তী অঙ্কটি সংযোজন aএবং বাকী ইনপুটটি দিয়ে চলছে ( (10*a+b)#c)

বেস কেসটি তখন হয় যখন ইনপুট তালিকাটি খালি থাকে (যেমন প্যাটার্নের সাথে মেলে না (b:c))। বর্তমান সংখ্যা পুনরাবৃত্তির শুরু aহচ্ছে 0( (0#)), যা কখনই প্রথম শাখা (prepending হিট a, সব আগের টুকরা করা), কারণ এটি টুকরা যে কোন সংখ্যার চেয়ে অনেক বেশী হতে হবে।

প্রতিটি বিভাজনের দৈর্ঘ্য নিন এবং সর্বাধিক ( maximum.map length) সন্ধান করুন।

এছাড়াও 87 বাইট সহ একটি বৈকল্পিক:

fst.maximum.(0#)
a#(b:c)=[(r+1,a)|c==[]||b>0,(r,x)<-b#c,a==x+1]++(10*a+b)#c
a#b=[(1,a)]

যা মূলত একইভাবে কাজ করে তবে পুরো বিভক্তিকে তালিকায় রাখার পরিবর্তে এটি কেবল (r,x)বিভাজনের দৈর্ঘ্যের একটি জোড়াকে বিভক্তির rপ্রথম সংখ্যা রাখে x।

— nimi
সূত্র

3

পাইথন 3 , 302 282 271 বাইট

-10 বাইটস @ এলপিড্রোর টিপকে ধন্যবাদ জানায়।

স্ট্রিং হিসাবে ইনপুট নেয়। মূলত, এটি বাম থেকে সংখ্যার বৃহত্তর টুকরোগুলি গ্রহণ করে এবং দেখায় যে সংখ্যার সেই স্লাইসের জন্য সমস্ত সংখ্যা ব্যবহার করে একটি ক্রম গঠন করা যেতে পারে।

R=range
I=int
L=len
def g(n,m,t=1):
 for i in R(1,L(m)+1):
  if I(m)==I(n[:i])+1:
   if i==L(n):return-~t
   return g(n[i:],n[:i],t+1)
 return 1
def f(n):
 for i in R(L(n)):
  x=n[:i]
  for j in R(1,L(x)+1):
   if (I(x)==I(n[i:i+j])+1)*I(n[i]):return g(n[i:],x)
 return 1

এটি অনলাইন চেষ্টা করুন!

— নীল এ।
সূত্র

1

যেহেতু আপনি range3 বার ব্যবহার করছেন আপনি R=rangeউভয় ফাংশনের বাইরে নির্ধারণ করতে পারেন এবং তারপরে 4 বাইট সংরক্ষণ করার R(whatever)পরিবর্তে ব্যবহার করতে পারেন range(whatever)।

— এলপেড্রো

3

জাপট , 27 বাইট

ò pÊÔpÊqÊfl²i1Uì q"l?"¹ÌèÊÉ

এটি অনলাইন চেষ্টা করুন! অথবা বেশিরভাগ পরীক্ষার কেসগুলি পরীক্ষা করে দেখুন

এটি ভাল স্কোর করে না, তবে এটি একটি অনন্য পদ্ধতি ব্যবহার করে এবং এতে আরও অনেক গল্ফ দেওয়ার সুযোগ থাকতে পারে। এটি যথেষ্ট ভাল সম্পাদন করে যে 201200199198সময় নির্ধারণের সময় বাদ দেওয়া ছাড়া অন্য সমস্ত পরীক্ষার কেসগুলি ।

ব্যাখ্যা:

ò                              #Get the range [0...input]
  pÊ                           #Add an "l" to the end
    Ô                          #Reverse it
     pÊ                        #Add an "l" to the end
       qÊ                      #Add an "l" between each number and turn to a string
         f            ¹        #Find the substrings that match this regex:
          l²                   # The string "ll"
            i1                 # With this inserted between the "l"s:
              Uì               #  All the digits of the input
                 q"l?"         #  With optional spaces between each one
                       Ì       #Get the last match
                        èÊ     #Count the number of "l"s
                          É    #Subtract 1

— কামিল দ্রাকারী
সূত্র

আমি মনে করি এটি 27 এর জন্য কাজ করে

— শ্যাগি

25 বাইট

— শেগি

@ শেগি উভয়ই ইনপুটটিতে ব্যর্থ হয়েছে 21201কারণ তারা প্রয়োগ করে না যে ক্রমটির শেষটি সঠিকভাবে প্রান্তিক হয় (আমার মূল সংস্করণ থেকে "কমা দিয়ে শেষ হয়" লাইন)। এটি বা এই বিকল্প কাজ করে।

— কামিল দ্রাকারী

আহ, ঠিক আছে.

— সেক্ষেত্রে

@ শেগি দ্যাট এবং ২৮ বাইট সমাধানগুলিতে আমি ব্যর্থ হয়েছি 210কারণ 0 এর পরে একটি ডিলিমিটার নেই Here এখানে একটি স্থির 28 বাইট রয়েছে যা কাজ করে।

— কামিল দ্রাকারী

2

হাস্কেল, 65 বাইট

f i=[y|x<-[0..],y<-[1..length i],i==(show=<<[x+y-1,x+y-2..x])]!!0

ইনপুট একটি স্ট্রিং।

এটি অনলাইন চেষ্টা করুন!

আমার অন্যান্য উত্তরের থেকে সম্পূর্ণ আলাদা । একটি সাধারণ ব্রুট ফোর্স যা ইনপুট তালিকার সমতুল্য কোনও খুঁজে না পাওয়া পর্যন্ত একটানা অবতরণকারী সংখ্যার সমস্ত তালিকাকে চেষ্টা করে।

আমরা যদি ইনপুট নম্বরটি 64-বিট পূর্ণসংখ্যার মধ্যে সীমাবদ্ধ রাখি তবে আমরা লুপ yদিয়ে 6 টি বাইট সংরক্ষণ করতে পারি [1..19], কারণ বৃহত্তম 64-বিট পূর্ণসংখ্যার 19 সংখ্যা রয়েছে এবং আরও উপাদানগুলির সাথে তালিকাগুলি পরীক্ষা করার প্রয়োজন নেই।

হাস্কেল, 59 বাইট

f i=[y|x<-[0..],y<-[1..19],i==(show=<<[x+y-1,x+y-2..x])]!!0

এটি অনলাইন চেষ্টা করুন!

— nimi
সূত্র

2

পাইথন 2 , 95 বাইট

lambda n:max(j-i for j in range(n+1)for i in range(-1,j)if''.join(map(str,range(j,i,-1)))==`n`)

আরেকটি ধীর, নিষ্ঠুর শক্তি সমাধান solution

এটি অনলাইন চেষ্টা করুন!

— ডেনিস
সূত্র

2

ডায়ালগ এপিএল, 138 বাইট

একটি মুখের বিট, কিন্তু এটি বড় সংখ্যার জন্যও দ্রুত কাজ করে। আপনি যদি এটি অনলাইনে চেষ্টা করে থাকেন তবে ডিএফএন উপসর্গ করুন ⎕←এবং অঙ্কের তালিকা হিসাবে ডানদিকে ইনপুট সরবরাহ করুন।

{⌈/⍵((≢⊂)×1∧.=2-/10⊥¨⊂)⍨⍤1⊢1,{⍬≡1↓⍵:↑⍬1⋄0=⊃⍵:0,∇1↓⍵⋄↑,0 1∘.,⊂⍤1∇1↓⍵}1↓⍵}

ব্যাখ্যা

প্রথমত, ডানদিকে অভ্যন্তরীণ dfn যা ⊂সংখ্যার সাথে সংখ্যাগুলির তালিকার (সহ ) পার্টিশনের সম্ভাব্য উপায়গুলির তালিকা তৈরি করে। উদাহরণস্বরূপ 1 0 1 0 ⊂ 2 0 1 9নেস্টেড ভেক্টরকে ফেরত দেয় (2 0)(1 9)।

{
   ⍬≡1↓⍵: ↑⍬1       ⍝ Edge case: If ⍵ is singleton list, return the column matrix (0 1)
   0=⊃⍵: 0,∇1↓⍵     ⍝ If head of ⍵ is 0, return 0 catenated to this dfn called on tail ⍵
   ↑,0 1∘.,⊂⍤1∇1↓⍵  ⍝ Finds 1 cat recursive call on tail ⍵ and 0 cat recursive call on ⍵. 
}                    ⍝ Makes a matrix with a row for each possibility.

আমরা 1,শুরুতে 1 এর কলাম যুক্ত করতে ব্যবহার করি এবং ⍵ এর জন্য বৈধ পার্টিশনের ম্যাট্রিক্স দিয়ে শেষ করব ⍵

এখন পেরেন্সে বামে ফাংশন ট্রেন। ⍨ট্রেনে বাম আর্গুমেন্টের কারণে পার্টিশন ম্যাট্রিক্সের সারি এবং ডান যুক্তি হ'ল ব্যবহারকারীর ইনপুট। ট্রেনটি একেবারে বাম দিকের চারপাশে কাঁটা কাঁটাযুক্ত স্তূপ।

((≢⊂)×1∧.=2-/10⊥¨⊂)⍨     ⍝ ⍨ swaps left and right arguments of the train.
                  ⊂       ⍝ Partition ⍵ according to ⍺. 
             10⊥¨         ⍝ Decode each partition (turns strings of digits into numbers)
          2-/             ⍝ Difference between adjacent cells
      1∧.=                ⍝ All equal 1?
   ⊂                      ⍝ Partition ⍵ according to ⍺ again
  ≢                       ⍝ Number of cells (ie number of partitions)
     ×                    ⍝ Multiply.

পার্টিশনটি যদি অবতরণকারী সংখ্যার ক্রম তৈরি করে, ট্রেনটি ক্রমের দৈর্ঘ্যটি ফেরত দেয়। অন্যথায় শূন্য।

⍤1⊢ব্যবহারকারীর ইনপুট এবং পার্টিশন ম্যাট্রিক্সের প্রতিটি সারির মধ্যে ফাংশন ট্রেন প্রয়োগ করে, ম্যাট্রিক্সের প্রতিটি সারির জন্য একটি মান ফিরিয়ে দেয়। এর উদ্ভূত ফাংশনটির ⊢অপারেন্ড থেকে ⍤তর্ক এবং তর্ক মধ্যে পার্থক্য করা প্রয়োজন ⍤।

⌈/ সর্বাধিক সন্ধান করে।

একটি সংক্ষিপ্ত অ্যালগরিদম খুঁজে পেতে পারি তবে আমি এইভাবে চেষ্টা করতে চেয়েছিলাম যা আমি সবচেয়ে সরাসরি এবং ঘোষিত হিসাবে ভাবতে পারি।

— akhmorn
সূত্র

পিপিসিজিতে আপনাকে স্বাগতম! এটি একটি চিত্তাকর্ষক প্রথম পোস্ট!

— 21

1

টিএসকিউএল, 169 বাইট

দ্রষ্টব্য: এটি কেবল তখনই কার্যকর করা যায় যখন ইনপুটটিকে পূর্ণসংখ্যায় রূপান্তর করা যায়।

লুপিংয়ের জন্য পুনরাবৃত্ত স্কয়ার ব্যবহৃত হয়।

Golfed:

DECLARE @ varchar(max) = '1211109876';

WITH C as(SELECT left(@,row_number()over(order by 1/0))+0t,@+null z,0i
FROM spt_values UNION ALL
SELECT t-1,concat(z,t),i+1FROM C WHERE i<9)SELECT
max(i)FROM C WHERE z=@

Ungolfed:

DECLARE @ varchar(max) = '1211109876';

WITH C as
(
  SELECT
    left(@,row_number()over(order by 1/0))+0t,
    @+null z,
    0i
  FROM
    spt_values
  UNION ALL
  SELECT
    t-1,
    concat(z,t),
    i+1
  FROM C
  WHERE i<9
)
SELECT max(i)
FROM C
WHERE z=@

চেষ্টা কর

— t-clausen.dk
সূত্র

0

আর , 101 বাইট

function(a,N=nchar(a)){for(x in 1:N)F=max(F,which(Reduce(paste0,seq(substr(a,1,x),,-1,N),a=T)==a));F}

এটি অনলাইন চেষ্টা করুন!

কোনও আর উত্তর ছাড়াই 2 সপ্তাহেরও বেশি সময় কেটে গেছে, তাই আমি নিজের পোস্ট করার সিদ্ধান্ত নিয়েছি :)

কোডটি বেশ দ্রুততর কারণ এটি "সীমিত" ব্রুট ফোর্স পদ্ধতির ব্যবহার করে

নিবন্ধভুক্ত কোড এবং ব্যাখ্যা:

function(a){                  # get string a as input (e.g. "2019")

  N = nchar(a)                # set N = length of a (e.g. 4)
  Y = 0                       # initialize Y = 0 (in the actual code we abuse F)

  for(x in 1:N){              # for x in 1 ... N    

    S = substr(a,1,x)         # get the first x characters of a (e.g. "20" for x=2)

    Q = seq(S,,-1,N)          # create a decreasing sequence (step = -1) 
                              # of length N starting from S converted into integer
                              # (e.g. Q = c(20,19,18,17) for x=2)

    R = Reduce(paste0,Q,a=T)  # concatenate all the increasing sub-sequences of Q
                              # (e.g. R = c("20","2019","201918","20191817") for x=2)

    I = which(R == a)         # Get the index where R == a, if none return empty vector
                              # (e.g. I = 2 for x=2)

    Y = max(Y,I)              # store the maximum index found into Y
  }
  return(Y)                   # return Y
}

— digEmAll
সূত্র

আমার সংখ্যায় কতটা ধারাবাহিক অবতরণ হয়?

চ্যালেঞ্জ

ইনপুট

আউটপুট

উদাহরণ:

সাধারণ নিয়ম:

জেলি , 15 9 বাইট

কিভাবে?

জাভাস্ক্রিপ্ট (ES6), 56 বাইট

জাভাস্ক্রিপ্ট (ES6), 66 বাইট

মন্তব্য

পার্ল 6 , 43 41 40 বাইট

ব্যাখ্যা:

পাইথন 3 , 232 228 187 181 180 150 149 বাইট

পাইথন 2 , 78 74 73 বাইট

কিভাবে এটা কাজ করে

05 এ বি 1 ই , 10 বাইট

পাইথ, 16 বাইট

জেলি , 11 বাইট

কিভাবে এটা কাজ করে

কাঠকয়লা , 26 বাইট

হাস্কেল, 87 বাইট

পাইথন 3 , 302 282 271 বাইট

জাপট , 27 বাইট

হাস্কেল, 65 বাইট

হাস্কেল, 59 বাইট

পাইথন 2 , 95 বাইট

ডায়ালগ এপিএল, 138 বাইট

ব্যাখ্যা

টিএসকিউএল, 169 বাইট

আর , 101 বাইট

নিবন্ধভুক্ত কোড এবং ব্যাখ্যা: