Dato un input di un elenco di numeri nel formato di una sequenza intera crescente abbreviata, emette la sequenza per intero.

Il formato di sequenza di numeri interi crescente abbreviato funziona trovando ogni numero n con meno cifre rispetto al numero che lo precede, m . Con d come numero di cifre in n , le ultime d cifre di m vengono sostituite con tutte le cifre di n . Ecco un esempio di input:

123 45 6 7 89 200

Applicando la regola di sostituzione, trasformiamo prima 45 in 145 perché 45 <123:

123 145 6 7 89 200

Applicando ripetutamente la stessa regola, questo diventa:

123 145 146 7 89 200
123 145 146 147 89 200
123 145 146 147 189 200

La sequenza è ora ordinata (non ci sono numeri a cui si applica la regola), quindi questo è l'output finale.

Si può presumere che

• la notazione abbreviata viene sempre utilizzata quando possibile. Ad esempio, l'input sarà 12 3, mai 12 13.

• i numeri non diminuiranno mai rimanendo lo stesso numero di cifre. Ad esempio, l'input non sarà mai 333 222.

• l'applicazione della regola abbreviata non comporterà mai un numero che è ancora inferiore al numero precedente nella sequenza. Ad esempio, l'input non sarà mai 123 12.

• i numeri saranno sempre numeri interi positivi e non contengono mai 0 iniziali (se si utilizza un formato stringa).

• la sequenza completa ed espansa non conterrà mai numeri duplicati. (Tuttavia, la sequenza abbreviata potrebbe; es. 10 1 20 1-> 10 11 20 21.)

• ci sarà almeno un numero nell'input.

L'input e l'output possono essere liste / matrici di numeri / stringhe o una singola stringa con elementi separati da qualsiasi non cifra.

Dato che si tratta di code-golf , vincerà il codice più breve in byte.

Casi di test, con input e output su linee alternate:

1 2 3 10 1 2 20 5 100 200 10 3 5 26 9 99 999 9999
1 2 3 10 11 12 20 25 100 200 210 213 215 226 229 299 999 9999
223 1184 334 441 5 927 2073 589 3022 82 390 5 9
223 1184 1334 1441 1445 1927 2073 2589 3022 3082 3390 3395 3399
5 10 5 20 5 30 5 40 5 50 5
5 10 15 20 25 30 35 40 45 50 55
7 8 9 70 80 90 700 800 900 7000 8000 9000
7 8 9 70 80 90 700 800 900 7000 8000 9000
42
42

Gelatina, 7 byte

DUṛ"\UḌ

Provalo online! o verifica tutti i casi di test .

Come funziona

DUṛ"\UḌ  Main link. Input: A (list of integers)

D        Convert each integer to a list of its base 10 digits.
 U       Reverse each digit list.
    \    Do a cumulative reduce, applying the dyadic link to the left:
   "       For each pair of corresponding digits:
  ṛ          Select the right one.
           Vectorization leaves digits that do not have a counterpart untouched.
     U   Reverse the resulting digit arrays.
      Ḍ  Convert from base 10 to integer.

Javascript, 45 42 byte

3 byte di sconto grazie @Neil .

a=>a.map(x=>z=z.slice(0,-x.length)+x,z='')

La funzione precedente prevede una matrice di stringhe.

f=
a=>a.map(x=>z=z.slice(0,-x.length)+x,z='')

F=a=>document.body.innerHTML+='<pre>'+a+'\n'+f(a)+'\n</pre>';

F(['1','2','3','10','1','2','20','5','100','200','10','3','5','26','9','99','999','9999'])
F(['223','1184','334','441','5','927','2073','589','3022','82','390','5','9'])
F(['5','10','5','20','5','30','5','40','5','50','5'])
F(['7','8','9','70','80','90','700','800','900','7000','8000','9000'])

Retina, 45 byte

+`(?=(?<1>\d)+)(?<=(\d)(?(1)x)(?<-1>\d)+ )
$1

Utilizza i gruppi di bilanciamento per contare le cifre che costano molto. Non ho ancora trovato un approccio migliore ma mi interessa.

Provalo online qui.

Gema, 35 personaggi

<D>=@set{p;@fill-right{${p;};$0}}$p

Input: stringa con numeri separati da qualsiasi cosa, stringa di output.

Esecuzione di esempio:

bash-4.3$ gema '<D>=@set{p;@fill-right{${p;};$0}}$p' <<< '123 45 6 7 89 200'
123 145 146 147 189 200

Rubino, 39 personaggi

->a{l='';a.map{|c|l=l[0..-c.size-1]+c}}

Input: array di stringhe, output: array di stringhe.

Esecuzione di esempio:

2.1.5 :001 > ->a{l='';a.map{|c|l=l[0..-c.size-1]+c}}[%w{123 45 6 7 89 200}]
 => ["123", "145", "146", "147", "189", "200"] 

Python 2 , 58 byte

s=''
for i in input():s=s[:max(len(s)-len(i),0)]+i;print s

Provalo online!