Di lo que ves

30

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!

Hola llama
fuente
2
¿Podemos recibir / devolver una lista de dígitos?
LegionMammal978
55
Cerraría las preguntas anteriores como engañados si fuera necesario; Esto no tiene las restricciones.
lirtosiast
44
No veo esto como un duplicado. Tanto el aspecto anterior como los desafíos fueron muy restrictivos (uno sin números en el código fuente, el otro sin variables con nombre, funciones con nombre o argumentos con nombre). Muy pocos idiomas permitirán respuestas a los desafíos anteriores que también son competitivos aquí.
trichoplax
3
¿Se nos permite salir como una lista de números?
lirtosiast

Respuestas:

9

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í .

lirtosiast
fuente
Pero al menos no escribo corchetes ni comillas; solo espacios entre los números :-P
Luis Mendo
2
En la Rusia soviética,ussrG8Qz
mbomb007
8

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.

Martin Ender
fuente
6

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.

Mwr247
fuente
Puede guardar tres bytes con un curry recursivo extraño: b=>F=a=>b--?F(a.replace(/(.)\1*/g,c=>c.length+c[0])):adescubrí que mientras jugaba mi respuesta antes de
darme
4

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
Luis Mendo
fuente
Si puede generar como una matriz, Pyth tiene 8.
lirtosiast
@ThomasKwa Buen punto. Supuse que era posible
Luis Mendo
4

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
}
Billywob
fuente
3

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

Teclas de acceso rápido
fuente
3

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: /

daniero
fuente
¿Podrías usar la -pbandera para guardar bytes? Si lo usa, gsubopera en una línea de STDIN como si fuera $_.gsub!. Entonces el argumento de la línea de comando son las iteraciones, entonces n,=$*, y la otra entrada se lee desde STDIN.
Value Ink
3

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
mbomb007
fuente
2

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.

ETHproducciones
fuente
('1',2)me da 12, cuando debería ser 21. Tu longitud debe venir antes del personaje en el reemplazo.
Mwr247
@ Mwr247 Vaya, lo siento.
ETHproductions
2

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
msh210
fuente
Como subrutina, supongo que puedo afeitarme un byte terminándolo en $_lugar de say, supongo, pero no lo he probado. La solución actual es un programa.
msh210
2

05AB1E , 9 bytes (no competidor)

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

F.¡vygyÙJ

Pruébalo en línea!

Urna de pulpo mágico
fuente
1
Creo que te perdiste la parte de tomar 2 argumentos (número inicial y número de iteraciones). Afortunadamente, puede agregar Fal principio y tomar los argumentos comoiterations,initialNo
Emigna
1
Y el byte perdido por eso podría recuperarse reemplazando Dgscon gy.
Emigna 01 de
@Emigna, ¿qué yhacer en ese contexto?
Urna mágica del pulpo
1
Igual que la primera y, empuje el valor actual en el bucle. Entonces, en lugar de duplicar y cambiarlo a la parte superior, simplemente lo empuja nuevamente cuando lo necesita.
Emigna 01 de
@Emigna debería parecer que todavía tengo mucho que aprender jaja.
Urna de pulpo mágico
2

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!

J.Doe
fuente
1
Ligeramente golf: TIO
JayCe
Esa t(sapply(z,c))llamada es inteligente.
J.Doe
1

Mathematica, 81 73 bytes

FromDigits@Nest[Flatten[(Tally/@Split@#)~Reverse~3]&,IntegerDigits@#,#2]&
Un simmons
fuente
Anteponga su código con cuatro espacios para que aparezca como código :)
Ogaday
1

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
Lynn
fuente
1

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!

Weijun Zhou
fuente
0

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.

Ogaday
fuente
0

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
andlrc
fuente
0

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. 
Morgan Thrapp
fuente
0

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.

12Me21
fuente
0

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.

BoppreH
fuente