2019 년이 왔을 것입니다. 아마도 모든 사람들 이이 숫자의 특성을 발견했습니다. 실제로 연속적인 내림차순을 나타내는 두 개의 하위 번호 (20 및 19)로 구성됩니다.

도전

숫자가 주어지면의 x하위 숫자를 취함으로써 형성 될 수있는 연속적인 내림차순의 최대 시퀀스 길이를 반환합니다 x.

노트 :

• 하위 번호는 앞에 0을 포함 할 수 없습니다 (예 : , 1009로 나눌 수 없음 )1009
• 연속 수단 하강하는 순서 번호는 이전 번호 -1거나 같아야한다는 (예 로 분할 할 수 있기 때문에 와 연속되지이다 )$n_{i+1} = n_{i}-1$525,2522 ≠ 5 - 1
• 순서가에 예를 들어, 전체 번호를 사용하여 얻을 수 있어야 7321버리지 할 수 있습니다 7및 순서를 얻을 3, 2,1
• 하나의 시퀀스 번호로부터 획득 될 수 있으며, 예를 들어이 3211098두 시퀀스로 분할 할 수없는 3, 2, 1및 10, 9,8

입력

• 정수 ( >= 0) : 숫자, 문자열 또는 숫자 목록 일 수 있습니다.

산출

• (는 IS 숫자의 하한합니다 감소 하위 번호의 최대 개수 주어진 단일 정수 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

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 I / O 규칙으로 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 반환 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트와 링크를 추가하십시오 (예 : TIO ).
• 또한 답변에 대한 설명을 추가하는 것이 좋습니다.

젤리 ,  15  9 바이트

Dennis 덕분에 Bugfix

ŻṚẆDfŒṖẈṀ

온라인으로 사용해보십시오! (321코드가이상이므로 30 분이 소요됨)$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

자바 스크립트 (ES6), 56 바이트

ArBo의 Python 답변 포트 는 훨씬 짧습니다. 그러나 너무 많은 재귀로 인해 일부 테스트 사례에서 실패합니다.

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

펄 6 , 43 41 40 바이트

nwellnhof 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

정규식 기반 솔루션. 대신 내림차순 목록에서 일치시키는 더 좋은 방법을 찾으려고 노력하고 있지만 Perl 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

파이썬 (3) , 232 (228) 187 181 180 150 149 바이트

@ Jonathan Frech 덕분에 -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

파이썬 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)

온라인으로 사용해보십시오!

_{Arnauld 덕분에 -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

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

Pyth, 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

젤리 , 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.

숯 , 26 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｆ⊕Ｌθ

i0에서 입력 길이까지 반복 합니다.

Ｆ⊕Ｌθ

k0에서 입력 길이까지 반복 합니다.

⊞υ⭆κ⁻Ｉ…θ⊕ιλ

입력 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로줍니다.

하스켈, 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) 으로 재귀 호출에 의해 반환 된 모든 스플릿에 추가 하지만 다음 숫자가 0이 아니 b>0거나 (또는 ​​입력의 마지막 숫자 ( c==[])) a첫 번째보다 큰 경우에만 각각의 이전 스플릿 수 x( a==x!!0+1).

과

• b입력 목록에서 다음 숫자 를 현재 숫자 a로 추가하고 나머지 입력으로 진행합니다 ( (10*a+b)#c)

기본 사례는 입력 목록이 비어있는 경우입니다 (즉, 패턴이 일치하지 않음 (b:c)). 재귀는 현재 숫자 ( ) a로 시작합니다.이 숫자 는 분할 수보다 크지 않기 때문에 첫 번째 분기에 충돌하지 않습니다 ( 이전의 모든 분할보다 우선).0(0#)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.

파이썬 3 , 302 282 271 바이트

@ElPedro의 팁 덕분에 -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

온라인으로 사용해보십시오!

apt , 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

하스켈, 65 바이트

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

입력은 문자열입니다.

온라인으로 사용해보십시오!

내 다른 대답 과는 완전히 다릅니다 . 입력 목록과 같은 것을 찾을 때까지 연속적인 내림차순의 모든 목록을 시도하는 간단한 무차별 대입.

입력 수를 64 비트 정수로 제한하면 가장 큰 64 비트 정수에 19 자리가 있고 더 많은 요소가있는 목록을 테스트 할 필요가 없기 때문에 를 반복 y하여 6 바이트를 절약 할 수 있습니다 [1..19].

하스켈, 59 바이트

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

온라인으로 사용해보십시오!

파이썬 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`)

또 다른 느리고 무차별 솔루션입니다.

온라인으로 사용해보십시오!

Dyalog APL, 138 바이트

한입 가득하지만 큰 숫자도 빨리 작동합니다. 온라인으로 시도하는 경우 dfn을 접두사 ⎕←로 사용하고 오른쪽에 숫자 목록으로 입력하십시오.

{⌈/⍵((≢⊂)×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의 열을 추가하고 ⍵ 유효 파티션의 매트릭스로 끝날 수 있습니다.

이제 왼쪽의 기능 트레인이 parens로 표시됩니다. ⍨열차의 왼쪽 인수로 인해 파티션 행렬의 행이 있고 오른쪽 인수는 사용자 입력입니다. 기차는 맨 왼쪽 타인처럼 꼭대기에 쌓인 포크 더미입니다.

((≢⊂)×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.

파티션이 내림차순 시퀀스를 생성하면 열차는 시퀀스 길이를 반환합니다. 그렇지 않으면 0입니다.

⍤1⊢사용자 입력과 파티션 행렬의 각 행 사이에 함수 트레인을 적용하여 행렬의 각 행에 대한 값을 반환합니다. 의 파생 함수에 대한 ⊢피연산자 ⍤와 인수 를 명확하게하기 위해 필요합니다 ⍤.

⌈/ 최대 값을 찾습니다.

더 짧은 알고리즘을 찾을 수는 있지만 생각할 수있는 가장 직접적이고 선언적인 방법으로 시도하고 싶었습니다.

TSQL, 169 바이트

참고 : 입력을 정수로 변환 할 수있는 경우에만 실행할 수 있습니다.

반복에 사용되는 재귀 SQL.

골프 :

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=@

언 골프 드 :

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=@

사용해보십시오

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