2019 आ गया है और शायद सभी ने इस संख्या की ख़ासियत पर ध्यान दिया है: यह वास्तव में दो उप-संख्याओं (20 और 19) द्वारा रचित है जो लगातार उतरते संख्याओं के अनुक्रम का प्रतिनिधित्व करते हैं।

चुनौती

एक संख्या को देखते हुए x, निरंतर, अवरोही संख्याओं के अधिकतम अनुक्रम की लंबाई लौटाएं जो कि उप-संख्याओं को लेकर बनाई जा सकती हैंx ।

टिप्पणियाँ :

उप संख्या अग्रणी शून्य नहीं हो सकते (उदाहरण के लिए 1009में विभाजित नहीं किया जा सकता 10, 09)
लगातार और साधन उतरते अनुक्रम में एक संख्या पिछले संख्या -1 के बराबर होना चाहिए, या कि $n_{i+1} = n_{i}-1$ (उदाहरण के लिए 52नहीं विभाजन में हो सकता है 5,2, क्योंकि 5और 2लगातार नहीं हैं, 2 ≠ 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

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
डिफ़ॉल्ट I / O नियमों के साथ आपके जवाब के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

code-golf

— digEmAll
स्रोत

1

सैंडबॉक्स से माइग्रेट: codegolf.meta.stackexchange.com/questions/2140/…

— digEmAll

1

क्या परीक्षण का मामला 210 -> 2,1,0गलत है (उसी के साथ 0 -> 0)? कार्यों का कहना है " उप-संख्याओं में अग्रणी शून्य नहीं हो सकता है ", क्या शून्य एक विशेष मामला है?

— ბიმო

2

@ बीएमओ: ठीक है, यहाँ विषय थोथा फिलाओसोफिकल है ...: डी मेरे पास, 0 एक नंबर है जिसमें (बेकार) अग्रणी शून्य है, इसलिए हाँ शून्य एक विशेष मामला है

— digEmAll

2

क्या आप इन ... घनीभूत संख्याओं को कहेंगे ? एक्सडी खेद है कि मजाकिया भी नहीं था

— हाइपरन्यूट्रिनो 3

क्षमा करें, मेरी टिप्पणी को हटा दिया गया जिसमें मैंने इसके बारे में पूछा था 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

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

ArBo के पायथन उत्तर का एक पोर्ट काफी छोटा है। हालाँकि, यह बहुत अधिक पुनरावृत्ति के कारण कुछ परीक्षण मामलों पर विफल रहता है।

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

इसे ऑनलाइन आज़माएं!

जावास्क्रिप्ट (ईएस 6), 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 बाइट्स

— ArBo

5

पर्ल 6 , 43 41 40 बाइट्स

-1 बाइट धन्यवाद nwellnhof के लिए

{/(<-[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 बाइट्स

— nwellnhof

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

— निशियोका
स्रोत

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 ।

— जोनाथन फ्रीच

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

— अरबो
स्रोत

1

अच्छा उत्तर! a+c+1को छोटा किया जा सकता है a-~c।

— अरनौलद

3

05AB1E , 10 बाइट्स

ÝRŒʒJQ}€gà

अत्यधिक धीमी गति से, इसलिए नीचे दिया गया TIO केवल 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सिर्फ इसके लायक नहीं है।

— corsiKa

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 घटाया जाता है।

— नील
स्रोत

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#)) है, जो पहली शाखा कभी नहीं करता है (prependinga है पिछले सभी विभाजन के लिए ), क्योंकि यह कभी भी विभाजन की संख्या से अधिक नहीं होगी।

प्रत्येक विभाजन की लंबाई लें और अधिकतम ( 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 बाइट्स @ElPedro द्वारा टिप के लिए धन्यवाद।

एक स्ट्रिंग के रूप में इनपुट लेता है। मूल रूप से, यह बाईं ओर से संख्या के बड़े स्लाइसों को बढ़ाता है, और देखता है कि संख्या के उस स्लाइस के लिए सभी नंबरों का उपयोग करके एक अनुक्रम बनाया जा सकता है या नहीं।

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क्योंकि वे लागू नहीं करते हैं कि अनुक्रम अंत सही ढंग से संरेखित होता है (मेरे मूल संस्करण से "अल्पविराम के साथ समाप्त होता है" लाइन)। यह या यह वैकल्पिक काम करता है।

— कामिल द्रकरी

आह अच्छा। उस स्तिथि में: 26 बाइट्स

— झबरा

@ शैगी और उस 28 बाइट समाधान पर मैं असफल रहा 210 क्योंकि 0. के बाद कोई सीमांकक नहीं है। यहां एक निश्चित 28 बाइट काम करती है।

— कामिल दकरी

2

हास्केल, 65 बाइट्स

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

इनपुट एक स्ट्रिंग है।

इसे ऑनलाइन आज़माएं!

मेरे अन्य उत्तर के लिए पूरी तरह से अलग है । एक सरल जानवर बल जो निरंतर अवरोही संख्याओं की सभी सूचियों को आजमाता है जब तक कि वह एक ऐसा न मिल जाए जो इनपुट सूची के बराबर हो।

अगर हम 64-बिट पूर्णांक के लिए इनपुट संख्या को सीमित, हम 6 बाइट्स पाशन द्वारा बचा सकता है yके माध्यम से [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

अजगर २ , 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`)

एक और धीमा, ब्रूट-बल समाधान।

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

2

डायलाग एपीएल, 138 बाइट्स

एक कौर का सा, लेकिन यह बड़ी संख्या में भी तेजी से काम करता है। यदि आप इसे ऑनलाइन आज़माते हैं, तो dfn द्वारा उपसर्ग करें ⎕←और अंक की सूची के रूप में दाईं ओर इनपुट प्रदान करें।

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

व्याख्या

सबसे पहले, दाईं ओर का आंतरिक डीएफएन जो ⊂अंकों की सूची के विभाजन (साथ ) के संभावित तरीकों की एक सूची का पुन: निर्माण करता है । उदाहरण के लिए 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, शुरुआत में 1s के एक कॉलम को जोड़ने और ⍵ के लिए वैध विभाजन के मैट्रिक्स के साथ समाप्त करने के लिए उपयोग करते हैं।

अब फंक्शन ट्रेन बाईं ओर परेंस में है। के कारण ⍨प्रशिक्षित करने के लिए छोड़ दिया तर्क विभाजन मैट्रिक्स की पंक्ति है और सही तर्क उपयोगकर्ता इनपुट है। ट्रेन एक बाईं ओर एक कांटे के साथ कांटे का ढेर है।

((≢⊂)×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
स्रोत

PPCG में आपका स्वागत है! यह एक प्रभावशाली पहली पोस्ट है!

— R

1

TSQL, 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}

इसे ऑनलाइन आज़माएं!

बिना किसी R उत्तर के 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 बाइट्स

कैसे?

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

जावास्क्रिप्ट (ईएस 6), 66 बाइट्स

टिप्पणी की गई

पर्ल 6 , 43 41 40 बाइट्स

स्पष्टीकरण:

पायथन 3 , 232 228 187 181 180 150 149 बाइट्स

पायथन 2 , 78 74 73 बाइट्स

यह काम किस प्रकार करता है

05AB1E , 10 बाइट्स

पायथ, 16 बाइट्स

जेली , 11 बाइट्स

यह काम किस प्रकार करता है

चारकोल , 26 बाइट्स

हास्केल, 87 बाइट्स

अजगर 3 , 302 282 271 बाइट्स

जाप , 27 बाइट्स

हास्केल, 65 बाइट्स

हास्केल, 59 बाइट्स

अजगर २ , 95 बाइट्स

डायलाग एपीएल, 138 बाइट्स

व्याख्या

TSQL, 169 बाइट्स

आर , 101 बाइट्स

अनियंत्रित कोड और स्पष्टीकरण: