La sequenza "Guarda e dì" o "Dì ciò che vedi" è una serie di numeri in cui ognuno descrive l'ultimo.

1
11 (one one)
21 (two ones)
1211 (one two, one one)
111221 (one one, one two, two ones)
312211 (three ones, two twos, one one)

e ancora e ancora ... https://oeis.org/A005150

Ad ogni modo, questa è una normale sfida al golf del codice (vince il conteggio dei byte minimi) per creare un programma che accetta due argomenti, un numero iniziale e la quantità di iterazioni. Ad esempio se hai inserito "1" e "2" il risultato sarebbe "21". Se hai inserito "2" e "4" il risultato sarebbe "132112". Divertiti!

Pyth, 10 8 byte

-2 byte di @FryAmTheEggman

ussrG8Qz

Spiegazione:

            Implicit: z=first line as string, Q=second line
u         the result of reducing lambda G:
  s s rG8   flattened run-length-encoded G
  Q       Q times
  z     starting with z

Provalo qui .

CJam, 8 byte

q~{se`}*

Il formato di input è prima il numero iniziale, poi le iterazioni, separate da alcuni spazi bianchi.

Provalo qui.

Spiegazione

q~   e# Read and evaluate input, dumping both numbers on the stack.
{    e# Run this block once for each iteration...
  s  e#   Convert to string... in the first iteration this just stringifies the input
     e#   number again. In subsequent iterations it flattens and then stringifies the
     e#   array we get from the run-length encoding.
  e` e#   Run-length encode.
}*

L'array viene anche appiattito prima di essere stampato, quindi il risultato è solo il numero richiesto.

JavaScript, 57 byte

F=(a,b)=>b?F(a.replace(/(.)\1*/g,c=>c.length+c[0]),b-1):a

La ricorsione funziona bene per questo problema. Il primo parametro è il numero iniziale come stringa e il secondo è il numero di iterazioni.

MATL , 9 byte

:"Y'wvX:!

Gli input sono: numero di iterazioni, numero iniziale.

Provalo online!

:      % implicit input: number of iterations. Create vector with that size
"      % for loop
  Y'   %   RLE. Pushes two arrays: elements and numbers of repetitions.
       %   First time implicitly asks for input: initial number
  w    %   swap
  v    %   concatenate vertically
  X:   %   linearize to column array
  !    %   transpose to row array
       % implicitly end loop
       % implicitly display

R, 87 byte

function(a,n){for(i in 1:n){r=rle(el(strsplit(a,"")));a=paste0(r$l,r$v,collapse="")};a}

Ungolfed e spiegato

f=function(a,n){
    for(i in 1:n){                      # For 1...n
        r=rle(el(strsplit(a,"")))       # Run length encoding
        a=paste0(r$l,r$v,collapse="")   # concatenate length vector and values vector and collapse
    };
    a                                   # print final result
}

Perl 6, 63 byte

say (@*ARGS[0],*.trans(/(.)$0*/=>{$/.chars~$0})…*)[@*ARGS[1]]

Questo è il più breve possibile per ora, ci potrebbero essere alcune bandiere difficili che potrebbero ridurlo, non sono sicuro

Rubino, 63 byte

Un programma completo, poiché la domanda sembra chiederlo. Accetta input come argomenti della riga di comando.

i,n=$*
n.to_i.times{i=i.gsub(/(.)\1*/){"#{$&.size}#$1"}}
puts i

^{No, gsub!non può essere utilizzato, poiché le stringhe $*sono bloccate: /}

Retina , 46 45 27 byte

Martin ha fatto molto per aiutare a giocare a golf.

+`(\d)(\1?)*(?=.*_)_?
$#2$1

Provalo online

Accetta input nel formato:

<start><count>

<start> è il numero iniziale.

<count> è in unario, tutti i caratteri di sottolineatura ed è il numero di iterazioni eseguite.

Iterazione singola, 20 16 byte:

(\d)(\1?)*
$#2$1

Haskell , 62 byte

import Data.List
0%y=y
x%y=do x<-group$(x-1)%y;[length x,x!!0]

Provalo online!

JavaScript ES6, 71 byte

(m,n)=>[...Array(n)].map(_=>m=m.replace(/(.)\1*/g,x=>x.length+x[0]))&&m

Accetta input come una stringa e un numero.

Perl 5, 50 byte

$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say

Gli argomenti sono in ordine inverso (numero di iterazioni quindi seed). Esempio:

> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 4 2
132112
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 0 2
2
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 2 0
1110
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 1 10
1110
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 11 1
3113112221232112111312211312113211

05AB1E , 9 byte (non concorrenti)

Corretto a causa dei commenti di Emigna, vedi sotto / modifiche.

F.¡vygyÙJ

Provalo online!

R , 61 57 byte

-4 grazie a @JayCe, proprio quando ero sicuro che non potesse essere più semplice!

f=function(a,n)`if`(n,f(t(sapply(rle(c(a)),c)),n-1),c(a))

Provalo online!

Mathematica, 81 73 byte

FromDigits@Nest[Flatten[(Tally/@Split@#)~Reverse~3]&,IntegerDigits@#,#2]&

Gelatina , 6 byte (non competitiva)

ŒrUFµ¡

Provalo online!

           Implicit input: first argument.
     µ¡    Do this to it <second argument> times:
Œr            Run-length encode into [value, times] pairs
  U           Flip them
   F          Flatten list

Stax , 10 byte

Çα▲ì4↔┌j█♀

Esegui ed esegui il debug online!

Ho speso troppi byte nel formato IO corretto ...

Spiegazione

Usa la versione decompressa per spiegare.

DE|R{rm:f$e
D              Do `2nd parameter` times
 E             Convert number to digits
                   Starting from the `1st parmeter`
  |R           Convert to [element, count] pairs for each run
    {rm        Revert each pair
       :f      Flatten the array
         $     Convert array to string of digits
          e    Convert string of digits to integer

La parte essenziale è D|R{rm:f (8 byte).

Se il primo input può essere preso come una matrice di cifre, l'intero programma può essere scritto in 9 byte: esegui ed esegui il debug online!

Python 3, 138 byte

Ho usato un approccio ricorsivo.

def g(a,b):
 if b<1:return a
 else:
  c,n=1,'';f,*a=str(a)+'_'
  for i in a:
   if i==f:c+=1
   else:n+=str(c)+f;f,c=i,1
  return g(n,b-1)

La funzione accetta due ints ae bcome descritto.

Sono sorpreso di quanto siano concise le voci qui! Forse qualcuno verrà anche con un metodo Python migliore.

Perl, 38 + 2 byte

for$i(1..<>){s/(.)\1*/(length$&).$1/ge}

Richiede la -pbandiera:

$ perl -pe'for$i(1..<>){s/(.)\1*/(length$&).$1/ge}' <<< $'1\n5'
312211

L'input è una stringa a più righe:

input number
numbers of iterations

Se sono necessari anche tutti i passaggi, è possibile modificarlo come segue, ovvero 44 + 2 byte:

$ perl -nE'for$i(1..<>){s/(.)\1*/(length$&).$1/ge,print}' <<< $'1\n5'
11
21
1211
111221
312211

Piloni , 11

i:At,{n,A}j

Come funziona:

i      # Get input from command line.
:A     # Initialize A
  t    # Set A to the top of the stack.
,      # Pop the top of the stack.
{      # Start a for loop.
 n     # Run length encode the stack.
  ,    # Seperate command and iteration
   A   # Repeat A times.
    }  # End for loop.
j      # Join the stack with '' and print it and then exit. 

SmileBASIC, 100 98 byte

DEF S N,T?N
WHILE""<N
C=C+1C$=SHIFT(N)IF C$!=(N+@L)[0]THEN O$=O$+STR$(C)+C$C=0
WEND
S O$,T-T/T
END

Stampa tutti i passaggi. T/Tè lì per terminare il programma quando T è 0.

APL (Dyalog Classic) , 22 byte

{∊(≢,⊃)¨⍵⊂⍨1,2≠/⍵}⍣⎕,⎕

Provalo online!

Retina , 27 byte

~(`^
K`
$
+`(.)\1$*¶$$.&$$1

Provalo online!

K (ngn / k) , 30 byte

{y{,/{(#x;*x)}'(&~=':x)_x}/,x}

Provalo online!

Python 3.6, 100 98 93 byte

import re
f=lambda s,n:n and eval("f'"+re.sub(r'((.)\2*)',r'{len("\1")}\2',f(s,n-1))+"'")or s

Provalo online!

Nota che crea un lambda che accetta una stringa e un numero intero e restituisce una stringa. Esempio:f('1', 5) == '312211'

Trova tutti i caratteri ripetuti ( ((.)\2*)regex), crea una stringa f dalla loro lunghezza e il carattere stesso ( r'{len("\1")}\2'), quindi lo valuta. Utilizza la ricorsione sul contatore ( n and ...f(s,n-1)... or s) per evitare di dover definire una funzione corretta e un loop.