Năm 2019 đã đến và có lẽ mọi người đều nhận thấy tính đặc thù của con số này: thực tế nó được tạo bởi hai số phụ (20 và 19) đại diện cho một chuỗi các số giảm dần liên tiếp.

Thử thách

Cho một số x, trả về độ dài của dãy số tối đa liên tiếp, giảm dần có thể được hình thành bằng cách lấy các số phụ của x.

Ghi chú:

• sub-số không thể chứa số không hàng đầu (ví dụ như 1009không thể được chia thành 10, 09)
• liên tiếp và giảm dần có nghĩa là một số trong chuỗi phải bằng số trước -1 hoặc (ví dụ: không thể tách thành vì và không liên tiếp, )$n_{i+1} = n_{i}-1$525,2522 ≠ 5 - 1
• trình tự phải được lấy bằng cách sử dụng số lượng đầy đủ, ví dụ như trong 7321bạn không thể loại bỏ 7và nhận được chuỗi 3, 2,1
• chỉ có một chuỗi có thể được lấy từ các số, ví dụ như 3211098không thể phân chia thành hai dãy 3, 2, 1và 10, 9,8

Đầu vào

• Số nguyên ( >= 0): có thể là số hoặc chuỗi hoặc danh sách các chữ số

Đầu ra

• Một số nguyên duy nhất cho số lượng phụ giảm dần tối đa (lưu ý rằng giới hạn dưới của số này là 1, tức là một số được tạo bởi chính nó trong một chuỗi giảm dần có độ dài một)

Ví dụ:

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

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Thạch ,  15  9 byte

Sửa lỗi nhờ Dennis

ŻṚẆDfŒṖẈṀ

Hãy thử trực tuyến! (thậm chí321mất nửa phút vì mã ít nhất là$O(N^2)$ )

Làm sao?

ŻṚẆ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

JavaScript (ES6), 56 byte

Một cổng câu trả lời Python của ArBo ngắn hơn đáng kể. Tuy nhiên, nó thất bại trên một số trường hợp thử nghiệm vì quá nhiều đệ quy.

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

Hãy thử trực tuyến!

JavaScript (ES6), 66 byte

Đưa đầu vào dưới dạng một chuỗi.

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++])

Hãy thử trực tuyến!

Đã bình luận

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

Perl 6 , 43 41 40 byte

-1 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Giải pháp dựa trên Regex. Thay vào đó, tôi đang cố gắng đưa ra một cách tốt hơn để khớp từ danh sách giảm dần, nhưng Perl 6 không làm tốt phân vùng

Giải trình:

{                                        }  # 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

Python 3 , 232 228 187 181 180 150 149 byte

-1 cảm ơn @ Jonathan Frech

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])])

Hãy thử trực tuyến!

Mã không mã hóa ban đầu:

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

Python 2 , 78 74 73 byte

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)

Hãy thử trực tuyến!

_{-1 byte nhờ Arnauld}

Đưa đầu vào dưới dạng một chuỗi. Chương trình khá nhanh chạy vào giới hạn độ sâu đệ quy của Python, nhưng nó có thể hoàn thành hầu hết các trường hợp thử nghiệm.

Làm thế nào nó hoạt động

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 byte

ÝRŒʒJQ}€gà

Vô cùng chậm, vì vậy TIO dưới đây chỉ hoạt động đối với các trường hợp thử nghiệm dưới 750 ..

Hãy thử trực tuyến .

Giải trình:

Ý           # 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

Bình thường, 16 byte

lef!.EhM.+vMT./z

Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc tại đây .

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

Thạch , 11 byte

ŒṖḌ’Dɗ\ƑƇẈṀ

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ŒṖḌ’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.

Than , 26 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｆ⊕Ｌθ

Lặp lại itừ 0 đến chiều dài của đầu vào.

Ｆ⊕Ｌθ

Lặp lại ktừ 0 đến chiều dài của đầu vào.

⊞υ⭆κ⁻Ｉ…θ⊕ιλ

Tính các ksố đầu tiên trong chuỗi giảm dần bắt đầu từ số được cho bởi các ichữ số đầu tiên của đầu vào, nối chúng và tích lũy từng chuỗi kết quả trong danh sách trống được xác định trước.

Ｉ﹪⌕υθ⊕Ｌθ

Tìm vị trí của bản sao phù hợp đầu tiên của đầu vào và giảm modulo 1 nhiều hơn độ dài của đầu vào.

Ví dụ: Đối với đầu vào của 2019các chuỗi sau đây được tạo:

 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 sau đó được tìm thấy ở chỉ số 12, được giảm modulo 5 để đưa ra 2, câu trả lời mong muốn.

Haskell, 87 byte

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]]

Đầu vào là một danh sách các chữ số.

Hãy thử trực tuyến!

Hàm #xây dựng một danh sách tất cả các phân chia có thể bằng cách nhìn vào cả hai

• trả trước số hiện tại acho tất cả các phần tách được trả về bởi một cuộc gọi đệ quy với phần còn lại của đầu vào ( x<-b#c), nhưng chỉ khi số tiếp theo không bằng 0 ( b>0) (hoặc đó là số cuối cùng trong đầu vào ( c==[])) và alớn hơn số đầu tiên số lần chia tương ứng trước đó x( a==x!!0+1).

và

• nối thêm chữ số tiếp theo btừ danh sách đầu vào vào số hiện tại avà tiếp tục với phần còn lại của đầu vào ( (10*a+b)#c)

Trường hợp cơ sở là khi danh sách đầu vào trống (tức là không khớp mẫu (b:c)). Đệ quy bắt đầu với số hiện tại alà 0( (0#)), không bao giờ chạm vào nhánh đầu tiên (chuẩn bị acho tất cả các phân tách trước đó), bởi vì nó sẽ không bao giờ lớn hơn bất kỳ số lượng phân tách nào.

Lấy độ dài của mỗi phần tách và tìm giá trị cực đại ( maximum.map length).

Một biến thể có 87 byte:

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)]

về cơ bản hoạt động theo cùng một cách, nhưng thay vì giữ toàn bộ phần tách trong một danh sách, nó chỉ giữ một cặp (r,x)độ dài của phần tách rmột số đầu tiên trong phần tách x.

Python 3 , 302 282 271 byte

-10 byte nhờ vào mẹo của @ElPedro.

Đưa đầu vào dưới dạng một chuỗi. Về cơ bản, phải tăng các lát số lớn hơn từ bên trái, và xem liệu đối với lát số đó, một chuỗi có thể được hình thành bằng cách sử dụng tất cả các số hay không.

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

Hãy thử trực tuyến!

Japt , 27 byte

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

Hãy thử trực tuyến! hoặc Kiểm tra hầu hết các trường hợp kiểm tra

Điều này không đạt điểm cao, nhưng nó sử dụng một phương pháp độc đáo và có thể còn nhiều chỗ để chơi golf hơn thế nữa. Nó cũng thực hiện đủ tốt để tất cả các trường hợp thử nghiệm khác hơn là 201200199198tránh thời gian ra.

Giải trình:

ò                              #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

Haskell, 65 byte

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

Đầu vào là một chuỗi.

Hãy thử trực tuyến!

Hoàn toàn khác với câu trả lời khác của tôi . Một lực lượng vũ phu đơn giản thử tất cả các danh sách các số giảm dần liên tiếp cho đến khi tìm thấy một danh sách bằng với danh sách đầu vào.

Nếu chúng tôi giới hạn số đầu vào ở số nguyên 64 bit, chúng tôi có thể lưu 6 byte bằng cách lặp yqua [1..19], bởi vì số nguyên 64 bit lớn nhất có 19 chữ số và không cần phải kiểm tra danh sách có nhiều phần tử hơn.

Haskell, 59 byte

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

Hãy thử trực tuyến!

Python 2 , 95 byte

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`)

Một giải pháp chậm, mạnh mẽ.

Hãy thử trực tuyến!

APL Dyalog, 138 byte

Một chút của một miệng, nhưng nó cũng hoạt động nhanh chóng cho số lượng lớn quá. Nếu bạn thử trực tuyến , hãy thêm tiền tố vào dfn ⎕←và cung cấp đầu vào bên phải dưới dạng danh sách các chữ số.

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

Giải trình

Đầu tiên, dfn bên trong bên phải, theo đó đệ quy một danh sách các cách có thể để phân vùng (với ⊂) danh sách các chữ số. Ví dụ 1 0 1 0 ⊂ 2 0 1 9trả về vector lồng nhau (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.

Chúng tôi sử dụng 1,để thêm một cột 1s khi bắt đầu và kết thúc với một ma trận các phân vùng hợp lệ cho.

Bây giờ các chức năng đào tạo bên trái trong parens. Do ⍨đối số bên trái của tàu là hàng của ma trận phân vùng và đối số bên phải là đầu vào của người dùng. Tàu là một đống dĩa với một đỉnh ở phía xa bên trái.

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

Nếu phân vùng tạo ra một chuỗi các số giảm dần, thì tàu trả về độ dài của chuỗi. Nếu không thì không.

⍤1⊢áp dụng đào tạo hàm giữa đầu vào của người dùng và từng hàng của ma trận phân vùng, trả về một giá trị cho mỗi hàng của ma trận. ⊢là cần thiết để phân tán giữa toán hạng đến ⍤và đối số với hàm dẫn xuất của ⍤.

⌈/ tìm tối đa

Có thể tìm thấy một thuật toán ngắn hơn nhưng tôi muốn thử theo cách này là thuật toán trực tiếp và khai báo nhất mà tôi có thể nghĩ ra.

TSQL, 169 byte

Lưu ý: điều này chỉ có thể được thực hiện khi đầu vào có thể được chuyển đổi thành một số nguyên.

Sql đệ quy được sử dụng để lặp.

Chơi gôn

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

Ung dung:

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

Dùng thử

R , 101 byte

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}

Hãy thử trực tuyến!

Đã hơn 2 tuần trôi qua mà không có câu trả lời R nào, vì vậy tôi quyết định đăng bài của riêng mình :)

Mã này khá nhanh vì nó sử dụng cách tiếp cận vũ phu "có giới hạn"

Mã không được kiểm soát và giải thích:

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
}