Sfida semplice: data una serie di numeri interi positivi, trova il numero che contiene tra le sue cifre la sequenza più lunga di cifre consecutive. Il trucco? È consentito che le cifre nelle serie 0123456789scorrano intorno ai possibili valori ( ) e procedano all'indietro. Così sia 2345, 89012e 5432109sono percorsi validi di cifre consecutive (ma non 3456765né 321090123come la corsa deve essere sempre nella stessa direzione, anche se 3456765possono essere considerati come due piste: 34567e 765). In caso di vincoli, restituisci il primo.

Casi test:

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

Appunti:

• Ci sarà almeno un numero nell'input.
• I numeri di input possono contenere zero iniziali.
• L'input e l'output possono essere in qualsiasi formato ragionevole . Quindi i numeri di input possono essere presi come stringhe, elenchi di cifre / caratteri ...
• L'output può contenere spazi vuoti finali e / o iniziali e newline purché il numero sia stampato.
• Questo è code-golf , quindi può vincere il programma / funzione più breve per ogni lingua!

Gelatina , 18 byte

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

Provalo online!

Prende e ritorna come elenco di cifre in modo da preservare gli zeri iniziali.

JavaScript (ES6), 104 102 98 byte

Accetta input come un elenco di elenchi di cifre. Restituisce il migliore.

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

Casi test

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

Gelatina ,  18 16  15 byte

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

Un collegamento monadico che prende un elenco di elenchi di cifre e restituisce quello più a sinistra contenente una corsa massima come descritto.

Provalo online! oppure vedere una suite di test (con elaborazione per far sembrare l'I / O come nella domanda).

Come?

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

Prende un elenco di elenchi di cifre a; restituisce uno dei suoi elenchi.

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

Provalo online!

Buccia , 20 byte

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

Prende e restituisce un elenco di elenchi di cifre. Provalo online!

Spiegazione

←Ö¤<(→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

Prendi input per array, array di differenze di colonna [X (2) -X (1), ..., X (n) -X (n-1)], controlla il valore più frequente nell'array (1 ordine crescente - 1 altrimenti), ottieni l'indice per il valore più frequente o -9 moltiplicato per il valore più frequente (-9 si verifica in ordine crescente, 9 altrimenti), trova gli indici consecutivi (ovvero la cui differenza è uguale a 1) e somma per favore, perché è tardi. Uscita il più grande.

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)

Provalo online!