Thử thách đơn giản: đưa ra một loạt các số nguyên dương, tìm số chứa trong số các chữ số của nó các chữ số liên tiếp dài nhất. Bí quyết? Nó được phép cho các chữ số trong các lần chạy để bao quanh các giá trị có thể ( 0123456789) và chạy ngược lại. Vì vậy, cả hai 2345, 89012và 5432109đang chạy hợp lệ của chữ số liên tiếp (nhưng không phải 3456765và cũng không 321090123như thời gian phải luôn theo cùng một hướng, mặc dù3456765 có thể được coi là hai chạy: 34567và 765). Trong trường hợp quan hệ, trả lại cái đầu tiên.

Các trường hợp thử nghiệm:

Input:  [3274569283, 387652323, 23987654323648, 2345687913624]
Output: 23987654323648 
        (The run is 98765432; run length: 8)

Input:  [123012363672023, 098761766325432, 15890123456765]
Output: 15890123456765
        (The run is 8901234567; run length: 10)

Input:  [43, 19, 456]
Output: 456

Input:  [5, 9, 0]
Output: 5

Input:  [71232107, 7012347]
Output: 7012347

Input:  [1234, 32109876]
Output: 32109876

Input:  [9090, 123]
Output: 123

Ghi chú:

• Sẽ có ít nhất một số trong đầu vào.
• Số đầu vào có thể chứa các số 0 đứng đầu.
• Đầu vào và đầu ra có thể ở bất kỳ định dạng hợp lý . Vì vậy, số đầu vào có thể được lấy dưới dạng chuỗi, danh sách các chữ số / ký tự ...
• Đầu ra có thể chứa dấu và / hoặc khoảng trắng hàng đầu và dòng mới miễn là số được in.
• Đây là môn đánh gôn , vì vậy có thể chương trình / chức năng ngắn nhất cho mỗi ngôn ngữ sẽ giành chiến thắng!

Thạch , 18 byte

I9,-;N¤yŒgỊS€ṀµÐṀḢ

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

Lấy và trả về dưới dạng danh sách các chữ số để bảo toàn các số 0 đứng đầu.

JavaScript (ES6), 104 102 98 byte

Lấy đầu vào là một danh sách các danh sách các chữ số. Trả về cái tốt nhất

a=>a.map(s=>s.map(n=>(i=(d=(x-(x=n)+11)%10)&&d-2?0:d-p?(p=d,1):i+1)>j&&(r=s,j=i),p=x=-10),j=-1)&&r

Các trường hợp thử nghiệm

let f =

a=>a.map(s=>s.map(n=>(i=(d=(x-(x=n)+11)%10)&&d-2?0:d-p?(p=d,1):i+1)>j&&(r=s,j=i),p=x=-10),j=-1)&&r

console.log(JSON.stringify(f([[3,2,7,4,5,6,9,2,8,3], [3,8,7,6,5,2,3,2,3], [2,3,9,8,7,6,5,4,3,2,3,6,4,8], [2,3,4,5,6,8,7,9,1,3,6,2,4]])))
console.log(JSON.stringify(f([[1,2,3,0,1,2,3,6,3,6,7,2,0,2,3], [0,9,8,7,6,1,7,6,6,3,2,5,4,3,2], [1,5,8,9,0,1,2,3,4,5,6,7,6,5]])))
console.log(JSON.stringify(f([[4,3], [1,9], [4,5,6]])))
console.log(JSON.stringify(f([[5], [9], [0]])))

Thạch ,  18 16  15 byte

I%⁵Œg%8ċ€1ṀµÐṀḢ

Một liên kết đơn âm lấy một danh sách các danh sách các chữ số và trả về một liên kết ngoài cùng bên trái có chứa một lần chạy tối đa như được mô tả.

Hãy thử trực tuyến! hoặc xem một bộ thử nghiệm (với việc xử lý để làm cho I / O trông giống như trong câu hỏi).

Làm sao?

I%⁵Œg%8ċ€1ṀµÐṀḢ - Link: list of lists of integers (digits) from [0-9]
           µÐṀ  - keep elements for which the link to the left is maximal:
I               -   incremental differences (i.e. [a2-a1, a3-a2, ...])
  ⁵             -   literal 10
 %              -   modulo by (i.e. [(a2-a1)%10, (a3-a2)%10, ...])
                -     this equates deltas of -9 and -1 with 1 and 9 respectively
   Œg           -   group runs of equal elements
     %8         -   modulo by 8; vectorised (9s become 1s, others unaffected)
       ċ€1      -   count number of 1s in €ach group
          Ṁ     -   maximum
              Ḣ - head (get the first one of those that were maximal)

Python 2 , 118 byte

Đưa ra một danh sách các danh sách các chữ số a; trả về một trong những danh sách của nó

lambda a:max(a,key=lambda l:len(max(re.findall('1+|9*',`[(x-y)%10for x,y in zip(l,l[1:])]`[1::3]),key=len)))
import re

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

Husk , 20 byte

←Ö¤<(→Of€1†%8gẊo%10-

Lấy và trả về một danh sách các danh sách các chữ số. Hãy thử trực tuyến!

Giải trình

←Ö¤<(→Of€1†%8gẊo%10-  Implicit input.
←                     Return first element of
 Ö                    the input sorted in a stable manner
   <                  in descending order
  ¤ (                 with respect to the following function:
                       Argument is list of digits, say [5,2,1,0,9,1,0].
                   -   Differences
               o%10    mod 10
              Ẋ        of all adjacent pairs: [7,9,9,9,2,1]
             g         Group adjacent equal elements: [[7],[9,9,9],[2],[1]]
          †%8          Vectorized mod 8: [[7],[1,1,1],[2],[1]]
       f€1             Keep those runs where 1 occurs: [[1,1,1],[1]]
      O                Sort in ascending order: [[1],[1,1,1]]
     →                 Take last element (gives [] on empty list): [1,1,1]
                       This is a list of 1s with length one less than
                       the longest run of consecutive digits.

MATLAB, 130 byte

Đưa đầu vào vào mảng, mảng chênh lệch cột [X (2) -X (1), ..., X (n) -X (n-1)], kiểm tra giá trị thường xuyên nhất trong mảng (thứ tự tăng dần 1 - 1 cách khác), lấy chỉ số cho giá trị thường xuyên nhất hoặc -9 nhân với giá trị thường xuyên nhất (-9 xảy ra theo thứ tự tăng dần, 9 nếu không), tìm các chỉ số liên tiếp (nghĩa là có chênh lệch bằng 1) và tính tổng làm ơn, vì đã muộn Sản lượng lớn nhất.

a=input('')
t=[]
for i=1:numel(a)
b=diff(num2str(a(i))-'0')
c=mode(b)
t=[t sum(diff(find(b==c|b==-9*c))==1)]
end
[t,I]=max(t),a(I)

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