Desafío simple: dada una serie de números enteros positivos, encuentre el número que contiene entre sus dígitos la ejecución más larga de dígitos consecutivos. ¿El truco? Está permitido que los dígitos en las ejecuciones se ajusten a los valores posibles ( 0123456789) y se ejecuten hacia atrás. Entonces 2345, ambas , 89012y 5432109son ejecuciones válidas de dígitos consecutivos (pero no 3456765ni 321090123como la ejecución debe estar siempre en la misma dirección, aunque 3456765puede considerarse como dos ejecuciones: 34567y 765). En caso de empate, devuelva el primero.

Casos de prueba:

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

Notas:

• Habrá al menos un número en la entrada.
• Los números de entrada pueden contener ceros a la izquierda.
• La entrada y salida pueden estar en cualquier formato razonable . Por lo tanto, los números de entrada pueden tomarse como cadenas, listas de dígitos / caracteres ...
• La salida puede contener espacios en blanco finales y / o iniciales y nuevas líneas siempre que se imprima el número.
• Este es el código de golf , ¡así que puede ganar el programa / función más corto para cada idioma!

Jalea , 18 bytes

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

Pruébalo en línea!

Toma y devuelve una lista de dígitos para preservar los ceros a la izquierda.

JavaScript (ES6), 104 102 98 bytes

Toma la entrada como una lista de listas de dígitos. Devuelve el mejor.

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

Casos de prueba

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

Jalea ,  18 16  15 bytes

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

Un enlace monádico que toma una lista de listas de dígitos y devuelve el más a la izquierda que contiene una ejecución máxima como se describe.

Pruébalo en línea! o ver un conjunto de pruebas (con procesamiento para hacer que la E / S parezca estar en la pregunta).

¿Cómo?

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 bytes

Toma una lista de listas de dígitos a; devuelve una de sus listas.

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

Pruébalo en línea!

Cáscara , 20 bytes

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

Toma y devuelve una lista de listas de dígitos. Pruébalo en línea!

Explicación

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

Tome la entrada a la matriz, matriz de diferencias de columna [X (2) -X (1), ..., X (n) -X (n-1)], verifique el valor más frecuente en la matriz (1 orden ascendente - 1 de lo contrario), obtenga el índice para el valor más frecuente o -9 multiplicado por el valor más frecuente (-9 ocurre en orden ascendente, 9 de lo contrario), encuentre los índices consecutivos (es decir, cuya diferencia es igual a 1) y sume por favor, porque es tarde Salida la más 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)

Pruébalo en línea!