Étant donné l'entrée d'une liste de nombres au format d'une séquence entière augmentant sténographiquement, sortez la séquence en entier.

Le format de séquence entière augmentant le raccourci fonctionne en trouvant chaque nombre n avec moins de chiffres que le nombre le précédant, m . Avec d comme nombre de chiffres dans n , les derniers d chiffres de m sont remplacés par tous les chiffres de n . Voici un exemple d'entrée:

123 45 6 7 89 200

En appliquant la règle de remplacement, nous transformons d'abord 45 en 145 car 45 <123:

123 145 6 7 89 200

En appliquant à plusieurs reprises la même règle, cela devient:

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

La séquence est maintenant triée (il n'y a pas de nombres auxquels la règle s'applique), c'est donc la sortie finale.

Vous pouvez supposer que

• la notation abrégée est toujours utilisée lorsque cela est possible. Par exemple, l'entrée sera 12 3, jamais 12 13.

• les nombres ne diminueront jamais tout en restant le même nombre de chiffres. Par exemple, l'entrée ne le sera jamais 333 222.

• l'application de la règle de raccourci n'aboutira jamais à un nombre qui est toujours inférieur au nombre précédent de la séquence. Par exemple, l'entrée ne le sera jamais 123 12.

• les nombres seront toujours des entiers positifs et ne contiendront jamais de 0 en tête (si vous utilisez un format de chaîne).

• la séquence complète et développée ne contiendra jamais de numéros en double. (Cependant, la séquence raccourcie pourrait; ex. 10 1 20 1-> 10 11 20 21.)

• il y aura au moins un nombre dans l'entrée.

L'entrée et la sortie peuvent être soit des listes / tableaux de nombres / chaînes, soit une seule chaîne avec des éléments séparés par des non-chiffres.

Puisqu'il s'agit de code-golf , le code le plus court en octets gagnera.

Cas de test, avec entrée et sortie sur lignes alternées:

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

Gelée, 7 octets

DUṛ"\UḌ

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

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 octets

3 octets de réduction merci @Neil .

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

La fonction ci-dessus attend un tableau de chaînes.

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

Rétine, 45 octets

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

Utilise des groupes d'équilibrage pour compter les chiffres, ce qui coûte cher. Je n'ai pas encore trouvé de meilleure approche mais ça m'intéresse.

Essayez-le en ligne ici.

Gema, 35 caractères

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

Entrée: chaîne avec des nombres séparés par quelque chose, chaîne de sortie.

Exemple d'exécution:

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

Ruby, 39 caractères

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

Entrée: tableau de chaînes, sortie: tableau de chaînes.

Exemple d'exécution:

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 octets

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

Essayez-le en ligne!