Défi:

Créez un programme qui prend en entrée un entier positif non nul et sort les 4 nombres suivants dans l'ordre décrit ci-dessous.

Remarque: il n'est pas nécessaire de vérifier si l'entrée est réellement un entier positif non nul

Séquence:

Chaque numéro de cette séquence (à l'exception du premier, qui est l'entrée) doit être composé de n chiffres, où n est un nombre pair. Si nous divisons le nombre en n / 2 paires, pour chaque paire, le premier chiffre doit être le nombre de fois où le deuxième chiffre est apparu dans le numéro précédent

Explication visuelle :
Considérez cet exemple "démarreur de séquence" ou entrée 6577
Le numéro suivant dans la séquence devrait ressembler à ceci 161527
car l'entrée a 1 "6", 1 "5" et 2 "7".

Si l'entrée comporte trop de chiffres (plus de 9 d'un seul chiffre), vous ne pourrez pas obtenir une sortie correcte.
Exemple: 111111111111(12 1)
Le numéro suivant de la séquence doit décrire 12 1. Ainsi, nous l'avons divisé en 9 1 et 3 1 (somme 9 + 3 = 12)
Numéro suivant:9131

Vous devez itérer 4 fois pour l'entrée et la sortir (soit renvoyer une liste / tableau de 4 entiers, soit la sortir en les séparant avec un espace, les retours à la ligne sont également acceptables)

"Le nombre peut être écrit de différentes manières, comment l'écrire?" :
Si vous y réfléchissez, l'exemple d'entrée 6577peut également être écrit comme 271516 (deux 7, un 5, un six). Cependant, cette sortie n'est pas valide. Vous devez répéter le nombre de gauche à droite. Ainsi 161527. Si c'était le cas, 7657vous itéreriez le montant de 7, puis le montant de 6 puis le montant de 5, donc une sortie valide serait271615

Exemple d'E / S:

Entrée: 75
Sortie:1715 211715 12311715 4112131715

Entrée: 1
Sortie:11 21 1211 3112

Entrée: 111111111111(12 1)
Sortie:9131 192113 31191213 23411912

C'est différent de la question "Dites ce que vous voyez", car les séquences sont différentes: https://oeis.org/A005150 <- Celui-ci renvoie des nombres comme celui-ci:
Input: 1211 Output: 111221
Alors que la séquence que je demande ferait
Entrée: 1211 Sortie: 3112

Les deux séquences sont différentes et nécessitent des algorithmes différents.
Ma séquence demandée: https://oeis.org/A063850 Séquence
"Possible duplicate": https://oeis.org/A005150

Spécifications importantes:

Comme ce n'était pas assez clair pour certaines personnes qui ont essayé de répondre à cette question, la sortie correcte pour k caractères où k> 9 n'est pas "kc" (où c est char) mais 9c (k-9) c etc. 12 1 n'est pas 121 (12 1) mais 9131(9 1, (12-9) 1 et ainsi de suite)

En cas de doute, votre code est erroné s'il produit un nombre avec un nombre impair de chiffres (comme 121), il devrait avoir une sortie de nombres pairs en raison de la nature de la séquence.

C'est du code-golf donc du code avec le moins d'octets qui gagne.

PowerShell , 111 104 octets

$z=$args;1..4|%{($z=-join($z-split'\B'|group|%{for($c,$n=$_.Count,$_.Name;$c-gt9;$c-=9){"9$n"}"$c$n"}))}

Essayez-le en ligne!

Python 2 , 116 octets

x=input()
exec"x=''.join(x.count(n)/9*(`9`+n)+`x.count(n)%9`+n for i,n in enumerate(x)if n not in x[:i]);print x;"*4

Essayez-le en ligne!

05AB1E , 30 23 21 octets

4F©Ùv9y«®y¢9‰`U×XyJ}=

Essayez-le en ligne!

Explication

4F                     # 4 times do:
  ©                    # store a copy of the current number in register
   Ùv                  # for each unique digit y in the number
     9y«               # concatenate 9 with y
        ®y¢            # count occurrences of y in current number
           9‰          # divmod by 9
             `U        # store the result of modulus in X
               ×       # repeat the number "9y" result_of_div times
                X      # push result of modulus
                 y     # push y
                  J    # join everything to one number
                   }   # end inner loop
                    =  # print the current number without popping

Mathematica, 117 octets

Grid@{Rest@NestList[FromDigits[Join@@(Reverse/@Tally@IntegerDigits@#//.{a_,b_}/;a>9->{9,b}~Sequence~{a-9,b})]&,#,4]}&

Il semble que cela ne devrait pas avoir besoin d'être aussi long.

C # 246 octets

namespace System{using Linq;using f=String;class p{static void Main(f[] s){f p=s[0];for(int i=0,n;i++<4;Console.Write(p+" "))p=f.Concat(p.GroupBy(c=>c).SelectMany(g=>new int[(n=g.Count())/9].Select(_ =>"9"+g.Key).Concat(new[]{n%9+""+g.Key})));}}}

Non golfé:

namespace System
{
    using Linq;
    using f = String;
    class p
    {
        static void Main(f[] s)
        {
            f p = s[0];
            for (int i = 0, n; i++ < 4; Console.Write(p + " "))

                p = f.Concat(p.GroupBy(c => c).SelectMany(g =>
                    new int[(n = g.Count()) / 9].Select(_ => "9" + g.Key).Concat(new[] { n % 9 + "" + g.Key }
                )));
            Console.ReadKey();
        }
    }
}

Essayez-le ici (Tapez l'entrée dans le cadre inférieur une fois sa compilation et appuyez sur ENTRÉE)

Gelée , 27 octets

L,Ḣ
D©®i$ÞŒgs9$€Ç€€FḌµ4µÐ¡Ḋ

Essayez-le en ligne!

Les €s successifs ne peuvent pas être imbriqués car les chaînes ne peuvent pas être imbriquées.

Imbrication avec lien séparé: 27 octets.

Impression au lieu du cumul: 27 octets.

Explication

L,Ḣ                     - helper function, does the look-and-say. Input is a list of digits
 ,                      - return 2-tuple of:
L                       -   length of input
  Ḣ                     -   first element of input

D©®i$ÞŒgs9$€Ç€€FḌµ4µÐ¡Ḋ - main link, takes input as integer
                 µ4µÐ¡  - repeat 4 times, saving the results of each iteration:
D                       -   convert integer to list of digits
 ©                      -   save into register, for later use
  ®i$Þ                  -   sort list's elements by first occurrence in list
      Œg                -   group runs of equal elements
        s9$€            -   split each run into sets which are at most 9 elements long
            Ç€€         -   do the look-and-say with helper function
               FḌ       -   flatten and convert back into integer for next iteration
                      Ḋ - remove the first element from the list since it includes the
                           initial element

PHP, 141 octets

for($a=$argn;$i++<4;$a=$o,print$a._,$o="")foreach(array_count_values(str_split($a))as$n=>$c)$o.=str_repeat("9$n",$c/9^0).($c%9?($c%9).$n:"");

Essayez-le en ligne!