Sei anche tu un programma che prende un numero intero come input e genera il primo qualunque sia stato quel numero dell'aspetto e dì sequenza .

Per esempio:

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

L'esatta modalità di output dell'elenco non è importante, a condizione che gli utenti possano vedere distintamente i diversi numeri della sequenza. Ecco il trucco però. Non è possibile utilizzare alcun tipo di variabile definita dall'utente.

Per esempio:

1. Nessuna variabile, comprese le variabili con ambito.
2. Quando hai delle funzioni, non possono avere un nome. (Eccezione, se la tua lingua richiede una funzione principale o simile per funzionare, potresti avere quella funzione.)
3. Quando hai funzioni, non possono avere argomenti con nome.

Inoltre, non puoi utilizzare una libreria con funzionalità specifiche relative alla sequenza look and say e non puoi accedere alla rete o fornire al tuo programma alcun file (anche se può generare e utilizzare il proprio.) Questo è il codice golf, così vince il codice più breve in caratteri!

GolfScript (31 caratteri)

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

Adattato dalla mia risposta a una precedente domanda look-and-say . Questo ha una restrizione meno onerosa per i linguaggi funzionali, che consente di salvare 5 caratteri, ma poiché la maggior parte delle risposte alla domanda precedente non può essere adattata (è una restrizione follemente onerosa per i linguaggi non funzionali) Non penso che abbia senso per chiuderlo come un duplicato.

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

Funziona usando la funzione di gruppo per raggrupparli in gruppi di cose uguali. Quindi utilizza applicativi con funzioni per creare una funzione che legge contemporaneamente la lunghezza e la aggiunge a uno degli elementi. Usa una correzione e una mappa per creare una definizione ricorsiva (senza punti). E il gioco è fatto.

J (42 caratteri)

La programmazione senza punti (detta anche tacita) è naturale in J.

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

Questa è una funzione, per usarla scrivi il codice, uno spazio e il numero di input. Per esempio,

   ,@:((#,{.);.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│
└─┴───┴───┴───────┴───────────┴───────────┴───────────────┴───────────────────┘

Notare le graziose caselle nell'output.

Addendum : qui ci sono un paio di "trucchi" che all'inizio ero troppo timida per usare, ma ora che ne ho visti altri usarli per primi ...

• Ecco una versione di 36 caratteri con una "convenzione di chiamata" diversa: sostituisci 8 con il numero di termini che desideri.

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

• E se avere zero in più nell'output è OK, ecco una versione da 32 caratteri:

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

GolfScript, 36 caratteri

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

Le variabili sono usate abbastanza raramente in GolfScript, e questa attività certamente non ne ha bisogno. L'input è su stdin, l'output su stdout. Ad esempio, l'input 8fornisce l'output:

[[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]]

Potrei scrivere una spiegazione dettagliata di questo codice in seguito, ma almeno si può facilmente dire che non utilizza variabili dal fatto che non include l'operatore di assegnazione delle variabili da :nessuna parte.

Haskell, 118 caratteri (80 senza importazioni)

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

Bash e coreutils, 111 73 caratteri

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

uniq -csta facendo il sollevamento pesante per produrre il numero successivo nella sequenza. yes, sedE evalcreare il necessario numero di ripetizioni della pipeline di elaborazione. Il resto è solo formattazione.

L'output viene inserito in un file chiamato o.:

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

Mathematica, 65 caratteri

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

Esempio:

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

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

J, 37 caratteri

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

Sulla base della mia risposta alla domanda sul modello di pisello . Potrebbe esserci qualche potenziale di accorciamento qui. L'uso è come per l'altra risposta J:

   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

Ha anche il problema degli zeri extra della mia risposta al modello di pisello.

Perl 6: 63 53 caratteri

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

Crea un elenco pigro della sequenza Look and Say ( 1,*.subst(/(\d)$0*/,{.chars~.[0]},:g)...*), quindi ottieni tutti gli elementi specificati dall'utente ( [^get]che è un indice e mezzo dell'array [0..(get-1)]) e saytutti.

L'elenco pigro funziona prendendo dapprima 1, quindi per generare ogni numero successivo, prende l'ultimo trovato e sostituisce tutte le sequenze della stessa cifra, corrispondenti a /(\d)$0*/, e le sostituisce con {quante} + {quale cifra} o .chars~.[0].

Le uniche variabili in questo codice sono $0, la prima acquisizione della corrispondenza e la $_variabile implicita e attuale che .methodnon viene definita e nessuna di queste è definita dall'utente.

GolfScript, 57 43 caratteri

Il mio approccio. Finì più a lungo di quello esistente purtroppo = (.

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

Output di esempio per stdin di 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]

Versione alternativa senza 9sentinella, ma è più lunga con 47 caratteri. Sospetto che abbia più potenziale:

~[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 personaggi

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

⎕viene valutato l'input. Nel link l'ho sostituito con 8, poiché tryapl.org non consente l'input dell'utente.

Nessuna variabile con nome ( a←1), nessuna funzione con nome ( f←{}), nessun argomento ( ⍺, ⍵).

Solo composizione di funzioni:

• operatori monadici — ciascuno:, f¨ridurre f/:, permutare:f⍨
• operatori diadici - potenza:, f⍣ncomporre:f∘g
• forchette— (f g h)B ←→ (f B)g(h B);A(f g h)B ←→ (A f B)g(A h B)
• in cima— (f g)B ←→ f(g B);A(f g)B ←→ f(A g B)
• 4 treni (fork-atops) -(f g h k) ←→ (f (g h k))

Funzioni primitive utilizzate:

• destra:A⊢B ←→ B
• inverso:⌽B
• primo:⊃B
• concatenare:A,B
• non corrisponde A≢B:, conta:≢B
• racchiudi:, ⊂Bpartizione:A⊂B
• appiattire:∊B

In tryapl.org, se rimuovi il finale ⊢1, che è l'argomento di questa enorme cosa composta, puoi vedere un diagramma di come viene analizzato:

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

J 66 (con I / O)

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

senza IO, segna 43:

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

Divertente domanda da porsi, quando verranno mostrati i primi 9?