Sie müssen auch ein Programm erstellen, das eine Ganzzahl als Eingabe verwendet und die erste ausgibt, unabhängig davon, welche Zahl in der Look & Say-Sequenz enthalten war .

Beispielsweise:

$ ./LAS
8
[1,11,21,1211,111221,312211,13112221,1113213211]

Die genaue Art und Weise, wie Sie die Liste ausgeben, ist unwichtig, solange Benutzer die verschiedenen Nummern der Sequenz deutlich sehen können. Hier ist der Haken. Sie können keine benutzerdefinierten Variablen verwenden.

Beispielsweise:

1. Keine Variablen, einschließlich Gültigkeitsbereichsvariablen.
2. Wenn Sie Funktionen haben, können diese keinen Namen haben. (Ausnahme: Wenn Ihre Sprache eine Hauptfunktion oder eine ähnliche Funktion benötigt, haben Sie möglicherweise diese Funktion.)
3. Wenn Sie Funktionen haben, können diese keine benannten Argumente haben.

Außerdem dürfen Sie keine Bibliothek mit bestimmten Funktionen in Bezug auf die Look & Say-Sequenz verwenden, und Sie können nicht auf das Netzwerk zugreifen oder Ihrem Programm Dateien zur Verfügung stellen (obwohl es eigene generieren und verwenden kann). Dies ist Code Golf, so gewinnt der kürzeste Code in Zeichen!

GolfScript (31 Zeichen)

~[]\{[1\{.2$={;\)}1if\}*].n@}*;

Angepasst von meiner Antwort auf eine frühere Look-and-Say-Frage . Diese hat eine weniger belastende Einschränkung für funktionale Sprachen, die das Speichern von 5 Zeichen ermöglicht, aber da die meisten Antworten auf die vorherige Frage nicht angepasst werden können (es ist eine verrückte belastende Einschränkung für nicht funktionale Sprachen), halte ich es nicht für sinnvoll als Betrüger zu schließen.

Haskell 206 Chars

import Data.List
import Control.Applicative
import Data.Function
main= readLn >>= print .(flip take (map read $ fix (("1":). map (concat .(map ((++)<$>(show . length)<*>((:[]). head))). group))::[Integer]))

Es funktioniert, indem die Gruppenfunktion verwendet wird, um sie in Gruppen gleicher Dinge zu gruppieren. Anschließend werden Applikative mit Funktionen verwendet, um eine Funktion zu erstellen, die gleichzeitig die Länge liest und an eines der Elemente anfügt. Es verwendet einen Fix und eine Map, um eine rekursive Definition zu erstellen (punktfrei). Und los geht's.

J (42 Zeichen)

Punktfreie (auch stillschweigende) Programmierung ist in J. natürlich.

,@:((#,{.);.1~(1,}.~:}:))&.>^:(<`((<1)"_))

Das ist eine Funktion, um sie zu verwenden, schreiben Sie den Code, ein Leerzeichen und die Eingabenummer. Beispielsweise,

   ,@:((#,{.);.1~(1,}.~:}:))&.>^:(<`((<1)"_)) 8
┌─┬───┬───┬───────┬───────────┬───────────┬───────────────┬───────────────────┐
│1│1 1│2 1│1 2 1 1│1 1 1 2 2 1│3 1 2 2 1 1│1 3 1 1 2 2 2 1│1 1 1 3 2 1 3 2 1 1│
└─┴───┴───┴───────┴───────────┴───────────┴───────────────┴───────────────────┘

Beachten Sie die hübschen Kästchen in der Ausgabe.

Nachtrag : Hier sind ein paar "Cheats", für die ich zuerst zu schüchtern war, aber jetzt, wo ich gesehen habe, dass andere sie zuerst benutzen ...

• Hier ist eine 36-Zeichen-Version mit einer anderen "Aufrufkonvention": Ersetzen Sie 8 durch die Anzahl der gewünschten Begriffe.

  ,@:((#,{.);.1~(1,}.~:}:))&.>^:(<8)<1
  

• Und wenn es in Ordnung ist, zusätzliche Nullen in der Ausgabe zu haben, ist hier eine 32-Zeichen-Version:

  ,@:((#,{.);.1~(1,}.~:}:))^:(<8)1
  

GolfScript, 36 Zeichen

~([1]\{.[0\{.2$=!{0\.}*;\)\}/](;}*]`

Variablen werden in GolfScript ziemlich selten verwendet, und diese Aufgabe benötigt sie sicherlich nicht. Die Eingabe erfolgt auf stdin, die Ausgabe auf stdout. Zum Beispiel gibt die Eingabe 8die Ausgabe:

[[1] [1 1] [2 1] [1 2 1 1] [1 1 1 2 2 1] [3 1 2 2 1 1] [1 3 1 1 2 2 2 1] [1 1 1 3 2 1 3 2 1 1]]

Ich kann später eine detaillierte Erklärung dieses Codes schreiben, aber zumindest können Sie leicht erkennen, dass er keine Variablen verwendet, da er den Variablenzuweisungsoperator :nirgendwo enthält.

Haskell, 118 Zeichen (80 ohne Importe)

import Data.List
import Control.Monad
main=readLn>>=print.flip take(iterate(ap((++).show.length)(take 1)<=<group)"1")

Bash und Coreutils, 111 73 Zeichen

eval echo 1\|`yes 'tee -a o|fold -1|uniq -c|(tr -dc 0-9;echo)|'|sed $1q`:

uniq -cmacht das schwere Heben, um die nächste Nummer in der Sequenz zu produzieren. yes, sedUnd evaldie erforderliche Anzahl von Wiederholungen der Verarbeitungspipeline erstellen. Der Rest ist nur Formatierung.

Die Ausgabe erfolgt in einer Datei mit dem Namen o.:

$ ./looksay.sh 8
ubuntu @ ubuntu: ~ $ cat o
1
11
21
1211
111221
312211
13112221
1113213211
$ 

Mathematica, 65 Zeichen

FromDigits/@NestList[Flatten@Reverse[Tally/@Split@#,3]&,{1},#-1]&

Beispiel:

FromDigits/@NestList[Flatten@Reverse[Tally/@Split@#,3]&,{1},#-1]&[8]

{1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211}

J, 37 Zeichen

1([:,((1,2&(~:/\))(#,{.);.1]))@[&0~i.

Basierend auf meiner Antwort auf die Frage nach dem Erbsenmuster . Hier besteht möglicherweise ein gewisses Maß an Verkürzung. Die Verwendung ist wie bei der anderen J-Antwort:

   1([:,((1,2&(~:/\))(#,{.);.1]))@[&0~i. 7
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 2 1 1 0 0 0 0
1 1 1 2 2 1 0 0
3 1 2 2 1 1 0 0
1 3 1 1 2 2 2 1

Es hat auch das Problem der zusätzlichen Nullen, das meine Erbsenmusterantwort hatte.

Perl 6: 63 53 Zeichen

say (1,*.subst(/(\d)$0*/,{.chars~.[0]},:g)...*)[^get]

Erstellen Sie eine verzögerte Liste der Look and Say-Sequenz ( 1,*.subst(/(\d)$0*/,{.chars~.[0]},:g)...*) und rufen Sie dann so viele Elemente ab, wie vom Benutzer angegeben wurden ( [^get]dies ist ein Array-Index und bedeutet [0..(get-1)]), und sayalle.

Die Lazy-Liste verwendet zuerst 1, um dann jede aufeinanderfolgende Zahl zu generieren, nimmt sie die zuletzt gefundene und ersetzt alle Sequenzen derselben Ziffer, die mit übereinstimmen /(\d)$0*/, und ersetzt sie durch {wie viele} + {welche Ziffer} oder .chars~.[0].

Die einzigen Variablen in diesem Code sind $0die erste Erfassung der Übereinstimmung und die implizite, aktuelle $_Variable, die nackt .methodaufgerufen wird, und keine dieser Variablen ist benutzerdefiniert.

GolfScript, 57 43 Zeichen

Mein eigener Ansatz. Endete länger als die bestehende leider = (.

~[1 9]{.);p[{...1<^0=?.@(\@(>.,(}do 0=]}@*;

Beispielausgabe für stdin von 8:

[1]
[1 1]
[2 1]
[1 2 1 1]
[1 1 1 2 2 1]
[3 1 2 2 1 1]
[1 3 1 1 2 2 2 1]
[1 1 1 3 2 1 3 2 1 1]

Alternative Version ohne 9Sentinel, jedoch mit 47 Zeichen länger. Ich vermute, es hat mehr Potenzial:

~[1]{.p[{...1<^.{0=?.@(\@(>1}{;,\0=0}if}do]}@*;

Scala 178

(0 to Console.in.readLine.toInt).map(i=>Function.chain(List.fill[String=>String](i)(y=>(('0',0,"")/:(y+" ")){case((a,b,c),d)=>if(d==a)(a,b+1,c)else(d,1,c+b+a)}._3.drop(2)))("1"))

Dyalog APL, 35 Zeichen

(⊢,⊂∘∊∘((≢,⊃)¨⊃⊂⍨2≢/0,⊃)∘⌽)⍣(⎕-1)⊢1

⎕wird Eingabe ausgewertet. In dem Link habe ich es durch 8 ersetzt, da tryapl.org keine Benutzereingaben zulässt.

Keine benannten Variablen ( a←1), keine benannten Funktionen ( f←{}), keine Argumente ( ⍺, ⍵).

Nur Zusammensetzung der Funktionen:

• monadische Operatoren - jeweils : f¨, reduzieren : f/, pendeln:f⍨
• dyadische Operatoren - Macht : f⍣n, komponieren:f∘g
• Gabeln - (f g h)B ←→ (f B)g(h B);A(f g h)B ←→ (A f B)g(A h B)
• atops - (f g)B ←→ f(g B);A(f g)B ←→ f(A g B)
• 4 Züge (Gabelung) -(f g h k) ←→ (f (g h k))

Verwendete primitive Funktionen:

• richtig:A⊢B ←→ B
• umkehren:⌽B
• zuerst:⊃B
• verketten:A,B
• nicht übereinstimmen : A≢B, zählen:≢B
• beilegen : ⊂B, Partition:A⊂B
• ebnen:∊B

Wenn Sie in tryapl.org das Trailing entfernen ⊢1, das das Argument für dieses massiv komponierte Ding ist, können Sie ein Diagramm sehen, wie es analysiert wird:

     ⍣               
   ┌─┴─┐             
 ┌─┼─┐ 7             
 ⊢ , ∘               
    ┌┴┐              
    ∘ ⌽              
 ┌──┴───┐            
 ∘    ┌─┴─┐          
┌┴┐   ¨ ┌─┼───┐      
⊂ ∊ ┌─┘ ⊃ ⍨ ┌─┼───┐  
  ┌─┼─┐ ┌─┘ 2 / ┌─┼─┐
  ≢ , ⊃ ⊂   ┌─┘ 0 , ⊃
            ≢

J 66 (mit E / A)

".@(_5}&',@((#,&:":{.);.1~1&(0})&(~:_1|.]))^:(<X)":1')@{.&.stdin''

ohne IO, Punktzahl 43:

NB. change the 8 for the number of numbers you'd want
,@((#,&:":{.);.1~1&(0})&(~:_1|.]))^:(<8)'1'

Lustige Frage, um sich zu stellen, wann die ersten 9 auftauchen?