Défi simple: étant donné une série de nombres entiers positifs, trouvez le nombre qui contient parmi ses chiffres la plus longue série de chiffres consécutifs. L'astuce? Il est autorisé que les chiffres dans les exécutions entourent les valeurs possibles ( 0123456789) et s'exécutent en arrière. Ainsi , les deux 2345, 89012et 5432109sont valides de runs chiffres consécutifs (mais pas , 3456765ni 321090123que la course doit être toujours dans la même direction, bien que 3456765peut être considéré comme deux pistes: 34567et 765). En cas d'égalité, retournez le premier.

Cas de 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

Remarques:

• Il y aura au moins un nombre dans l'entrée.
• Les numéros d'entrée peuvent contenir des zéros non significatifs.
• L'entrée et la sortie peuvent être dans n'importe quel format raisonnable . Ainsi, les nombres saisis peuvent être considérés comme des chaînes, des listes de chiffres / caractères ...
• La sortie peut contenir des espaces et des retours à la ligne de fin et / ou de début tant que le numéro est imprimé.
• C'est du golf de code , donc le programme / la fonction la plus courte pour chaque langue peut gagner!

Gelée , 18 octets

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

Essayez-le en ligne!

Prend et retourne sous forme de liste de chiffres afin de conserver les zéros non significatifs.

JavaScript (ES6), 104 102 98 octets

Prend la saisie sous forme de liste de listes de chiffres. Renvoie le meilleur.

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

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

Gelée ,  18 16  15 octets

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

Un lien monadique prenant une liste de listes de chiffres, et renvoyant celui le plus à gauche contenant une course maximale comme décrit.

Essayez-le en ligne! ou voir un suite de tests (avec un traitement pour donner l'impression que les E / S sont dans la question).

Comment?

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 octets

Prend une liste de listes de chiffres a; renvoie l'une de ses listes.

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

Essayez-le en ligne!

Coque , 20 octets

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

Prend et renvoie une liste de listes de chiffres. Essayez-le en ligne!

Explication

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

Prendre l'entrée dans le tableau, tableau des différences de colonne [X (2) -X (1), ..., X (n) -X (n-1)], vérifier la valeur la plus fréquente dans le tableau (1 ordre croissant - 1 sinon), obtenez l'indice de la valeur la plus fréquente ou -9 multiplié par la valeur la plus fréquente (-9 se produit dans l'ordre croissant, 9 sinon), trouvez les indices consécutifs (c'est-à-dire dont la différence est égale à 1) et additionnez-le s'il vous plaît, car il est tard. Sortie le plus grand.

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)

Essayez-le en ligne!