Generador de patrón de guisante ascendente

8

Para aquellos que no están familiarizados con el patrón de guisante , es un patrón matemático simple.

Existen múltiples variaciones de este patrón, pero nos centraremos en uno:

Patrón de guisante ascendente

Se parece a esto:

1
11
21
1112
3112
211213
...

Parece realmente difícil obtener la siguiente línea, pero es realmente fácil. La forma de obtener la siguiente línea es contando la cantidad de veces que un dígito se repite en la línea anterior (comience a contar con la más baja, la más grande):

one
one one
two ones
one one, one two
three ones, one two
two ones, one two, one three
...

Requisitos / Reglas:

  • Empezaremos a las 1
  • Será un fragmento
  • Debe haber una manera de especificar el número de líneas que genera (por ejemplo 5 , dará las primeras 5 líneas)
  • El código debe ser lo más corto posible
  • Debe comenzar a contar de menor a mayor (la variación ascendente)
ajax333221
fuente
Soy nuevo aquí, por favor dime cómo puedo mejorar. Por ejemplo, ¿debo especificar un límite de fecha?
ajax333221
1
Puede especificar si desea que un programa completo con E / S o un fragmento sea suficiente (o si no le importa). Pero a primera vista parece lo suficientemente bien especificado.
JB
@JB Gracias por tus palabras esclarecedoras. He actualizado mi publicación
ajax333221
La 13ª iteración, y todas las iteraciones posteriores, son 21322314. ¿Es esto correcto?
Joey Adams

Respuestas:

4

APL, 32 caracteres

⍪⌽({⍵,⍨,/{⌽⍵,+/⍵⍷d}¨⍳⌈/d←⊃⍵}⍣⎕)1

Esto genera líneas a partir de 0 (es decir , 0genera 1, 1genera 1seguido de 1 1, etc.), según lo especificado por la entrada del usuario. Utilicé Dyalog APL para esto, y ⎕IOdebería establecerse en su valor predeterminado de 1.

Ejemplo:

      ⍪⌽({⍵,⍨,/{⌽⍵,+/⍵⍷d}¨⍳⌈/d←⊃⍵}⍣⎕)1
⎕:
      0
1

      ⍪⌽({⍵,⍨,/{⌽⍵,+/⍵⍷d}¨⍳⌈/d←⊃⍵}⍣⎕)1
⎕:
      13
               1 
             1 1 
             2 1 
         1 1 1 2 
         3 1 1 2 
     2 1 1 2 1 3 
     3 1 2 2 1 3 
     2 1 2 2 2 3 
     1 1 4 2 1 3 
 3 1 1 2 1 3 1 4 
 4 1 1 2 2 3 1 4 
 3 1 2 2 1 3 2 4 
 2 1 3 2 2 3 1 4 
 2 1 3 2 2 3 1 4

Una vez que tenga más tiempo, escribiré una explicación. ⍨

Dillon Cower
fuente
3

Python (2.x), 81 80 caracteres

l='1'
exec"print l;l=''.join(`l.count(k)`+k for k in sorted(set(l)))\n"*input()

Todos los consejos o comentarios son bienvenidos!

uso: python peapattern.py
15 # ingrese el número de iteraciones
1
11
21
1112
3112
211213
312213
212223
114213
31121314
41122314
31221324
21322314
21322314
21322314
ChristopheD
fuente
2

Perl, 83

Estoy bastante seguro de que algún gurú de Perl podría superar esto, pero aquí va:

$_++;$n=<>;for(;$n--;){print$_.$/;$r='';$r.=length($&).$1 while(s/(.)\1*//);$_=$r;}

Expandido:

$_++;$n=<>;

for(;$n--;)
{
    print $_.$/;

    $r='';$r .= length($&).$1 while (s/(.)\1*//);  # The magic
    $_=$r;
}

El número de filas se pasa a través de STDIN.

Señor llama
fuente
No soy un verdadero gurú, estoy seguro de que hay formas aún más cortas de encontrarlo, pero usando el mismo método: ¡ Pruébelo en línea!
Dom Hastings
2

J, 60 46 39 26 caracteres

1([:,(#,{.)/.~@/:~)@[&0~i.

Edición 3 : se le ocurrió una forma mucho más agradable de expresar esto.

1([:;[:|."1[:/:~~.,.[:+/"1[:~.=)@[&0~i.

Edición 2 : Finalmente encontré una manera de mover el argumento al final de la secuencia y deshacerse de las tareas innecesarias.

Previamente:

p=.3 :'([:,[:|."1[:/:~~.,.[:+/"1[:~.=)^:(i.y)1

Edición 1 : corrige la salida que debería ser yfilas en lugar de la yfila th. También acorta un poco las cosas. Lástima de los 0s, parece que no puede deshacerse de las malditas cosas.

Uso:

   1([:,(#,{.)/.~@/:~)@[&0~i. 1
1

   1([:,(#,{.)/.~@/:~)@[&0~i. 6
1 0 0 0 0 0
1 1 0 0 0 0
2 1 0 0 0 0
1 1 1 2 0 0
3 1 1 2 0 0
2 1 1 2 1 3

   1([:,(#,{.)/.~@/:~)@[&0~i. 10
1 0 0 0 0 0 0 0
1 1 0 0 0 0 0 0
2 1 0 0 0 0 0 0
1 1 1 2 0 0 0 0
3 1 1 2 0 0 0 0
2 1 1 2 1 3 0 0
3 1 2 2 1 3 0 0
2 1 2 2 2 3 0 0
1 1 4 2 1 3 0 0
3 1 1 2 1 3 1 4

Es cierto que el uso es más feo ahora, pero la belleza no es el nombre del juego aquí ...

Gareth
fuente
Esto será difícil de superar con cualquier 'lenguaje tradicional'. Tal vez golfscript o similar esté a la altura de la tarea ;-)
ChristopheD
1

Haskell, 116

import Data.List
main=interact(unlines.map(show=<<).($iterate((>>=
 \x->[length x,head x]).group.sort)[1]).take.read)

Uso:

$ runhaskell pea.hs <<< 15
1
11
21
1112
3112
211213
312213
212223
114213
31121314
41122314
31221324
21322314
21322314
21322314
Joey Adams
fuente
1

Lisp común, 140 caracteres

(defun m(x)
  (labels((p(l n)
    (if(= 0 n)
       nil
       (cons l
             (p(loop for d in(sort(remove-duplicates l)#'<)
                  append(list(count d l)d))
               (1- n))))))
    (p'(1) x)))

Esto es Lisp, por lo que la función devuelve una lista de listas. (mx) genera X sublistas.

Paul Richter
fuente
1

Mathematica, 70

NestList[FromDigits@TakeWhile[DigitCount@#~Riffle~Range@9,#>0&]&,1,#]&
Señor mago
fuente
1

Jelly , 13 11 bytes (se agradece su opinión)

1ṢŒrUFƲСṖY

Pruébalo en línea!

1ṢŒrUFƲСṖY
1     Ʋ         starting with 1, run these 4 links...
 ṢŒr            Ṣort the list and get the Œrun-length encoding of it,
    U           reverse each member of the RLE list (so it goes [repetitions, digit] instead of [digit, repetitions]),
     F          and Flatten the RLE list-of-lists to just a list of digits, which is the next number.
       С       do that (input) number of times,
         ṖY     Ṗop the last line off the output (an extra line is always calculated) and then print the numbers, separated by newlines.
Harry
fuente
1
U€simplemente puede ser U, se vectoriza hasta el nivel de fila. Luego puede guardar otro byte en línea ṢŒrUF, utilizando Ʋ(los últimos 4 enlaces como mónada):1ṢŒrUFƲСṖY
Lynn
Muchas gracias de nuevo por las mejoras @Lynn! Siempre es bueno pasar de una cadena de más de 5 enlaces a 4 para que pueda usar eso rápidamente.
Harry
1
¡De nada! (Nota Tiny: ṢŒrU€FƲhabría funcionado muy bien - que rueda [ , Œr, U€, F.] En una mónada Tal vez mi uso de "continuación" era un poco engañosa ^^; Del mismo modo, en algo así como abc$de$fƲoperará en los 4 enlaces [ a, bc$, de$, f] y conviértalos en una mónada. Este es el sentido en el que puedes pensar en las rápidas como "operadores de pila de tiempo de análisis": su resultado se devuelve a una pila y actúa como si fuera un enlace para futuras rápidas. )
Lynn
1
@ Lynn Ya veo, gracias de nuevo! ¡Mejorando mucho más los enlaces de "conteo" ahora, pude incorporar completamente esta respuesta y guardar un byte gracias a tu comentario!
Harry