La secuencia "Mira y dice" o "Di lo que ves" es una serie de números donde cada uno describe el último.

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)

y sigue y sigue ... https://oeis.org/A005150

De todos modos, este es un desafío de código de golf regular (gana menos conteo de bytes) para hacer un programa que tome dos argumentos, un número inicial y la cantidad de iteraciones. Por ejemplo, si conectó "1" y "2", el resultado sería "21". Si conectó "2" y "4", el resultado sería "132112". ¡Que te diviertas!

Pyth, 10 8 bytes

-2 bytes por @FryAmTheEggman

ussrG8Qz

Explicación:

            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

Probarlo aquí .

CJam, 8 bytes

q~{se`}*

El formato de entrada es el número inicial primero, las iteraciones segundo, separadas por un espacio en blanco.

Pruébalo aquí.

Explicación

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.
}*

La matriz también se aplana antes de imprimirse, por lo que el resultado es solo el número requerido.

JavaScript, 57 bytes

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

La recursión funciona bien para este problema. El primer parámetro es el número inicial como una cadena, y el segundo es el número de iteraciones.

MATL , 9 bytes

:"Y'wvX:!

Las entradas son: número de iteraciones, número inicial.

Pruébalo en línea!

:      % 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 bytes

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

Ungolfed y explicado

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 bytes

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

Esto es lo más corto que podría obtener por ahora, puede haber algunas banderas difíciles que podrían reducirlo, no estoy seguro

Ruby, 63 bytes

Un programa completo, ya que la pregunta parece pedir eso. Toma datos como argumentos de línea de comando.

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

^{No, gsub!no se puede usar, ya que las cadenas $*están congeladas: /}

Retina , 46 45 27 bytes

Martin hizo mucho para ayudar a jugar golf.

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

Pruébalo en línea

Toma entrada en el formato:

<start><count>

<start> Es el número inicial.

<count> está en unario, todos los guiones bajos, y es cuántas iteraciones se realizan.

Iteración simple, 20 16 bytes:

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

Haskell , 62 bytes

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

Pruébalo en línea!

JavaScript ES6, 71 bytes

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

Toma la entrada como una cadena y un número.

Perl 5, 50 bytes

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

Los argumentos están en orden inverso (número de iteraciones luego semilla). Ejemplo:

> 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 bytes (no competidor)

Corregido debido a los comentarios de Emigna, ver abajo / ediciones.

F.¡vygyÙJ

Pruébalo en línea!

R , 61 57 bytes

-4 gracias a @JayCe, ¡justo cuando estaba seguro de que no podía hacerse más simple!

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

Pruébalo en línea!

Mathematica, 81 73 bytes

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

Gelatina , 6 bytes (no competitiva)

ŒrUFµ¡

Pruébalo en línea!

           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 bytes

Çα▲ì4↔┌j█♀

¡Ejecute y depure en línea!

Pasé demasiados bytes en el formato IO adecuado ...

Explicación

Utiliza la versión desempaquetada para explicar.

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 esencial es D|R{rm:f(8 bytes).

Si la primera entrada se puede tomar como una matriz de dígitos, todo el programa se puede escribir en 9 bytes: ¡ Ejecute y depure en línea!

Python 3, 138 bytes

Usé un enfoque recursivo.

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 función acepta dos entradas ay bcomo se describe.

¡Estoy sorprendido de lo breves que son las entradas aquí! Tal vez alguien venga con un mejor método de Python también.

Perl, 38 + 2 bytes

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

Requiere la -pbandera:

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

La entrada es una cadena de varias líneas:

input number
numbers of iterations

Si también se requieren todos los pasos, podemos cambiarlo a lo siguiente, que es 44 + 2 bytes:

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

Pilones , 11

i:At,{n,A}j

Cómo funciona:

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 bytes

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

Imprime todos los pasos. T/Testá ahí para finalizar el programa cuando T es 0.

APL (Dyalog Classic) , 22 bytes

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

Pruébalo en línea!

Retina , 27 bytes

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

Pruébalo en línea!

K (ngn / k) , 30 bytes

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

Pruébalo en línea!

Python 3.6, 100 98 93 bytes

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

Pruébalo en línea!

Tenga en cuenta que esto crea una lambda que toma una cadena y un número entero, y devuelve una cadena. Ejemplo:f('1', 5) == '312211'

Encuentra todos los caracteres repetidos ( ((.)\2*)regex), crea una cadena f de su longitud y el propio carácter ( r'{len("\1")}\2'), luego lo evalúa. Utiliza la recursividad en el contador ( n and ...f(s,n-1)... or s) para evitar tener que definir una función adecuada y un bucle.