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)

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

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

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.

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

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

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.

Mathematica, 70

NestList[FromDigits@TakeWhile[DigitCount@#~Riffle~Range@9,#>0&]&,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.