Einfache Herausforderung: Suchen Sie anhand einer Reihe positiver ganzzahliger Zahlen die Zahl, deren Ziffern die längste Folge aufeinanderfolgender Ziffern enthalten. Der Trick? Es ist zulässig, dass die Ziffern in den Läufen die möglichen Werte ( 0123456789) umbrechen und rückwärts ablaufen. Also beide 2345, 89012und 5432109galten Läufe von aufeinanderfolgenden Ziffern (aber nicht 3456765noch 321090123als der Lauf in der gleichen Richtung sein muss immer, obwohl 3456765als zwei Läufe in Betracht gezogen werden kann: 34567und 765). Bei Unentschieden geben Sie das erste zurück.

Testfälle:

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

Anmerkungen:

• Die Eingabe enthält mindestens eine Nummer.
• Eingabenummern können führende Nullen enthalten.
• Eingabe und Ausgabe können in jedem vernünftigen Format erfolgen . So können eingegebene Zahlen als Zeichenfolgen, Ziffern- / Zeichenlisten ... verwendet werden.
• Die Ausgabe kann abschließende und / oder führende Leerzeichen und Zeilenumbrüche enthalten, solange die Nummer gedruckt wird.
• Das ist Code-Golf , also kann das kürzeste Programm / die kürzeste Funktion für jede Sprache gewinnen!

Jelly , 18 Bytes

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

Probieren Sie es online!

Nimmt und kehrt als Liste von Ziffern zurück, um führende Nullen beizubehalten.

JavaScript (ES6), 104 102 98 Byte

Nimmt die Eingabe als Liste von Ziffernlisten. Gibt den besten zurück.

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

Testfälle

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

Jelly ,  18 16  15 Bytes

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

Ein monadischer Link, der eine Liste von Ziffernlisten erstellt und die ganz links stehende Liste zurückgibt, die wie beschrieben einen maximalen Lauf enthält.

Probieren Sie es online! oder sehen Sie sich eine Testsuite an (mit der Verarbeitung, damit E / A so aussieht, als ob es in Frage käme).

Wie?

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

Nimmt eine Liste von Ziffernlisten auf a; gibt eine seiner Listen zurück.

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

Probieren Sie es online!

Schale , 20 Bytes

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

Nimmt eine Liste von Ziffernlisten auf und gibt sie zurück. Probieren Sie es online!

Erläuterung

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

Eingaben in Array, Array der Spaltendifferenzen [X (2) -X (1), ..., X (n) -X (n-1)] übernehmen, den häufigsten Wert im Array überprüfen (1 aufsteigende Reihenfolge - 1 sonst), erhalte den Index entweder für den häufigsten Wert oder -9 multipliziert mit dem häufigsten Wert (-9 tritt in aufsteigender Reihenfolge auf, ansonsten 9), finde die aufeinanderfolgenden Indizes (dh deren Differenz gleich 1 ist) und summiere sie bitte, weil es spät ist. Ausgabe am größten.

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)

Probieren Sie es online!