Für diejenigen, die nicht mit dem Erbsenmuster vertraut sind , ist es ein einfaches mathematisches Muster.

Es gibt mehrere Variationen dieses Musters, aber wir werden uns auf eine konzentrieren:

Aufsteigendes Erbsenmuster

Es sieht aus wie das:

1
11
21
1112
3112
211213
...

Es scheint wirklich schwer zu sein, die folgende Zeile zu bekommen, aber es ist wirklich einfach. Um zur nächsten Zeile zu gelangen, müssen Sie zählen, wie oft sich eine Ziffer in der vorherigen Zeile wiederholt hat (beginnen Sie mit der Zählung mit der niedrigsten bis zur größten):

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

Anforderungen / Regeln:

• Wir werden um beginnen 1
• Es wird ein Ausschnitt sein
• Es muss eine Möglichkeit geben, die Anzahl der generierten Zeilen anzugeben (z. B. 5 werden die ersten 5 Zeilen angegeben).
• Der Code sollte so kurz wie möglich sein
• Es muss vom niedrigsten zum größten zählen (die aufsteigende Variante)

APL, 32 Zeichen

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

Dies erzeugt Zeilen ab 0 (dh 0erzeugt 1, 1erzeugt 1gefolgt von 1 1usw.), wie durch Benutzereingaben angegeben. Ich habe dafür Dyalog APL verwendet und ⎕IOsollte auf den Standardwert 1 gesetzt werden.

Beispiel:

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

Sobald ich mehr Zeit habe, schreibe ich eine Erklärung auf. ⍨

Python (2.x), 81 80 Zeichen

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

Alle Tipps oder Kommentare sind willkommen!

Verwendung: python peapattern.py
15 # Geben Sie die Anzahl der Iterationen ein
1
11
21
1112
3112
211213
312213
212223
114213
31121314
41122314
31221324
21322314
21322314
21322314

Perl, 83

Ich bin mir ziemlich sicher, dass ein Perl-Guru dies übertreffen könnte, aber hier ist:

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

Erweitert:

$_++;$n=<>;

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

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

Die Anzahl der Zeilen wird über STDIN übergeben.

J, 60 46 39 26 Zeichen

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

Edit 3 : Hat eine viel schönere Art gefunden, dies auszudrücken.

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

Bearbeiten 2 : Endlich einen Weg gefunden, das Argument an das Ende der Sequenz zu verschieben und das unnötige Zuweisungsmaterial loszuwerden.

Vorher:

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

Bearbeiten 1 : Korrigiert die Ausgabe, die yZeilen statt der ydritten Zeile sein sollte. Verkürzt auch die Dinge ein bisschen. Schade um die 0s, kann die verdammten Sachen nicht loswerden.

Verwendungszweck:

   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

Zugegeben, die Verwendung ist jetzt hässlicher, aber Hübschheit ist hier nicht der Name des Spiels ...

Haskell, 116

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

Verwendungszweck:

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

Common Lisp, 140 Zeichen

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

Dies ist Lisp, daher gibt die Funktion eine Liste von Listen zurück. (mx) generiert X Unterlisten.

Mathematica, 70

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

Jelly , 13 11 Bytes (Feedback erwünscht)

1ṢŒrUFƲСṖY

Probieren Sie es online aus!

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.