Para aqueles que não estão familiarizados com o Padrão de Ervilha , é um padrão matemático simples.

Existem várias variações desse padrão, mas vamos nos concentrar em um:

Padrão de ervilha ascendente

Se parece com isso:

1
11
21
1112
3112
211213
...

Parece realmente difícil obter a seguinte linha, mas é realmente fácil. A maneira de obter a próxima linha é contando o número de vezes que um dígito repetiu na linha anterior (comece a contar da menor para a maior):

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

Requisitos / Regras:

• Vamos começar às 1
• Será um trecho
• Deve haver uma maneira de especificar o número de linhas geradas (por exemplo 5 , fornecerá as 5 primeiras linhas)
• O código deve ser o mais curto possível
• Ele deve começar a contar do menor para o maior (a variação ascendente)

APL, 32 caracteres

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

Isso gera linhas a partir de 0 (ou seja , 0gera 1, 1gera 1seguido por 1 1etc.), conforme especificado pela entrada do usuário. Eu usei o Dyalog APL para isso e ⎕IOdeve ser definido como o padrão 1.

Exemplo:

      ⍪⌽({⍵,⍨,/{⌽⍵,+/⍵⍷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

Assim que tiver mais tempo, escreverei uma explicação. ⍨

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()

Todas as dicas ou comentários são bem-vindos!

uso: python peapattern.py
15 # digite o número de iterações
1
11
21
1112
3112
211213
312213
212223
114213
31121314
41122314
31221324
21322314
21322314
21322314

Perl, 83

Tenho certeza de que algum guru do Perl poderia superar isso, mas aqui vai:

$_++;$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;
}

O número de linhas é passado via STDIN.

J, 60 46 39 26 caracteres

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

Edit 3 : surgiu com uma maneira muito melhor de expressar isso.

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

Edit 2 : Finalmente encontrou uma maneira de mover o argumento para o final da sequência e se livrar das coisas desnecessárias de atribuição.

Anteriormente:

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

Editar 1 : corrige a saída que deve ser ylinhas, e não a ylinha th. Também reduz um pouco as coisas. Que vergonha 0, não consigo me livrar das malditas coisas.

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

É certo que o uso é mais feio agora, mas beleza não é o nome do jogo aqui ...

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 comum, 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)))

Como Lisp, a função retorna uma lista de listas. (mx) gera X sublistas.

Mathematica, 70

NestList[FromDigits@TakeWhile[DigitCount@#~Riffle~Range@9,#>0&]&,1,#]&

Gelatina , 13 11 bytes (Feedback apreciado)

1ṢŒrUFƲСṖY

Experimente online!

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.