Sfida:

Creare un programma che accetta input di un numero intero diverso da zero e genera i 4 numeri successivi nella sequenza descritta di seguito.

Nota: non è necessario verificare se l'ingresso è effettivamente un numero intero diverso da zero

Sequenza:

Ogni numero in questa sequenza (a parte il primo, che è l'input) deve essere composto da n cifre, dove n è un numero pari. Se dividiamo il numero in n / 2 coppie, per ogni coppia, la prima cifra dovrebbe essere la quantità di volte in cui la seconda cifra è apparsa nel numero precedente

Spiegazione visiva :
prendere in considerazione questo esempio "sequenza di avvio" o input 6577
Il numero successivo nella sequenza dovrebbe apparire così 161527
poiché l'ingresso ha 1 "6", 1 "5" e 2 "7" s.

Se l'input ha troppe cifre (più di 9 di una singola cifra) non si sarebbe in grado di ottenere un risultato corretto
Esempio: 111111111111(12 1) Il
prossimo numero in sequenza deve descrivere 12 1. Quindi lo dividiamo in 9 1 e 3 1 (somma 9 + 3 = 12)
Numero successivo:9131

Dovresti iterare 4 volte per l'input ed emetterlo (o restituire un elenco / array di 4 numeri interi o emetterlo separandoli con uno spazio, anche le newline sono accettabili)

"Il numero può essere scritto in molti modi, come lo scrivo?" :
Se ci pensate, l'input di esempio 6577può anche essere scritto come 271516 (due 7, uno 5, uno sei). Tuttavia questo è un output non valido. Dovresti ripetere il numero da sinistra a destra. Quindi 161527. Se fosse 7657, ripeteresti la quantità di 7, quindi la quantità di 6, quindi la quantità di 5, quindi l'output valido sarebbe271615

Esempio I / O:

Ingresso: 75
Uscita:1715 211715 12311715 4112131715

Ingresso: 1
Uscita:11 21 1211 3112

Ingresso: 111111111111(12 1)
Uscita:9131 192113 31191213 23411912

Questo è diverso dalla domanda "Dì quello che vedi", perché le sequenze sono diverse: https://oeis.org/A005150 <- Questo restituisce numeri come questo:
Input: 1211 Output: 111221
Mentre la sequenza che sto chiedendo farebbe
Input: 1211 Output: 3112

Le due sequenze sono diverse e richiedono algoritmi diversi.
Sequenza richiesta: https://oeis.org/A063850 Sequenza
"Possibile duplicato": https://oeis.org/A005150

Specifica importante:

Dal momento che non era abbastanza chiaro per alcune persone che hanno cercato di rispondere a questa domanda, l'output corretto per k chars dove k> 9 non è "kc" (dove c è char) ma 9c (k-9) c ecc. Quindi l'output corretto per 12 1 non è 121(12 1) ma9131 (9 1, (12-9) 1 e così via)

In caso di dubbio, il codice è errato se emette mai un numero con una quantità dispari di cifre (come 121), dovrebbe avere un output di numeri pari a causa della natura della sequenza.

Questo è code-golf quindi vince il codice con meno byte.

PowerShell , 111 104 byte

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

Provalo online!

Python 2 , 116 byte

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

Provalo online!

05AB1E , 30 23 21 byte

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

Provalo online!

Spiegazione

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 byte

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

Sembra che non dovrebbe essere così lungo.

C # 246 byte

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})));}}}

Ungolfed:

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();
        }
    }
}

Provalo qui (digita l'input nel frame inferiore una volta compilato e premi INVIO)

Gelatina , 27 byte

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

Provalo online!

Il successivo € non possono essere nidificati perché le catene non possono essere nidificate.

Annidamento con collegamento separato: 27 byte.

Stampa invece del cumulo: 27 byte.

Spiegazione

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 byte

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:"");

Provalo online!