Vous êtes aussi un programme qui prend un entier comme entrée et qui sort le premier quel que soit le nombre de la séquence de recherche et de représentation .

Par exemple:

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

La façon exacte dont vous affichez la liste est sans importance, tant que les utilisateurs peuvent voir distinctement les différents numéros de la séquence. Voici le hic cependant. Vous ne pouvez utiliser aucune sorte de variable définie par l'utilisateur.

Par exemple:

1. Aucune variable, y compris les variables de portée.
2. Lorsque vous avez des fonctions, elles ne peuvent pas avoir de nom. (Exception, si votre langue nécessite une fonction principale ou similaire pour fonctionner, vous pouvez avoir cette fonction.)
3. Lorsque vous avez des fonctions, elles ne peuvent pas avoir d'arguments nommés.

En outre, vous ne pouvez pas utiliser une bibliothèque avec des capacités spécifiques liées à la séquence de recherche et de prononciation, et vous ne pouvez pas accéder au réseau, ni fournir à votre programme des fichiers (bien qu'il puisse générer et utiliser le sien.) Il s'agit du code golf, donc le code le plus court en caractères gagne!

GolfScript (31 caractères)

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

Adapté de ma réponse à une précédente question de recherche et d'opinion . Celui-ci a une restriction moins onéreuse pour les langages fonctionnels, ce qui permet d'enregistrer 5 caractères, mais parce que la plupart des réponses à la question précédente ne peuvent pas être adaptées (c'est une restriction follement onéreuse pour les langages non fonctionnels) Je ne pense pas que cela ait du sens pour le fermer comme une dupe.

Haskell 206 caractères

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

Il fonctionne en utilisant la fonction de groupe pour les regrouper en groupes de choses égales. Ensuite, il utilise des applicatifs avec des fonctions pour construire une fonction qui lit simultanément la longueur et l'ajoute à l'un des éléments. Il utilise un correctif et une carte pour créer une définition récursive (sans point). Et c'est parti.

J (42 caractères)

La programmation sans point (également appelée tacite) est naturelle dans J.

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

C'est une fonction, pour l'utiliser, vous écrivez le code, un espace et le numéro d'entrée. Par exemple,

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

Remarquez les jolies cases dans la sortie.

Addendum : Voici quelques "tricheurs" que j'étais trop timide pour utiliser au début, mais maintenant que j'en ai vu d'autres les utiliser en premier ...

• Voici une version de 36 caractères avec une "convention d'appel" différente: remplacez 8 par le nombre de termes que vous souhaitez.

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

• Et si avoir des zéros supplémentaires dans la sortie est OK, voici une version 32 caractères:

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

GolfScript, 36 caractères

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

Les variables sont assez rarement utilisées dans GolfScript, et cette tâche n'en a certainement pas besoin. L'entrée se fait sur stdin, la sortie sur stdout. Par exemple, l'entrée 8donne la sortie:

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

Je peux écrire une explication détaillée de ce code plus tard, mais au moins vous pouvez facilement dire qu'il n'utilise aucune variable du fait qu'il n'inclut l'opérateur d'affectation de variable :nulle part.

Haskell, 118 caractères (80 sans importations)

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

Bash et coreutils, 111 73 caractères

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

uniq -cfait le gros du travail pour produire le numéro suivant de la séquence. yes, sedEt evalcréer le nombre nécessaire de répétitions du pipeline de traitement. Le reste n'est que du formatage.

La sortie est placée dans un fichier appelé o.:

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

Mathematica, 65 caractères

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

Exemple:

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

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

J, 37 caractères

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

Basé sur ma réponse à la question Pea Pattern . Il peut y avoir un potentiel de raccourcissement ici. L'utilisation est la même que pour l'autre réponse 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

Il y a aussi le problème de zéros supplémentaires que ma réponse au motif de pois avait.

Perl 6: 63 53 caractères

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

Créez une liste paresseuse de la séquence Look and Say ( 1,*.subst(/(\d)$0*/,{.chars~.[0]},:g)...*), puis obtenez autant d'éléments que spécifié par l'utilisateur ( [^get], qui est un indice de tableau et signifie [0..(get-1)]), et saytous.

La liste paresseuse fonctionne en prenant d'abord 1, puis pour générer chaque nombre successif, elle prend le dernier qu'elle a trouvé et substitue toutes les séquences du même chiffre, comme apparié par /(\d)$0*/, et les remplace par {combien} + {quel chiffre} , ou .chars~.[0].

Les seules variables de ce code sont $0la première capture de la correspondance et la $_variable topique implicite qui met à nu l' .methodappel, et aucune d'entre elles n'est définie par l'utilisateur.

GolfScript, 57 43 caractères

Ma propre approche. A fini plus longtemps que l'existant malheureusement = (.

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

Exemple de sortie pour stdin de 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]

Version alternative sans 9sentinelle, mais elle est plus longue avec 47 caractères. Je soupçonne qu'il a plus de potentiel:

~[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 caractères

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

⎕est évalué en entrée. Dans le lien, je l'ai remplacé par 8, car tryapl.org ne permet pas la saisie par l'utilisateur.

Pas de variables nommées ( a←1), pas de fonctions nommées ( f←{}), pas d'arguments ( ⍺, ⍵).

Seule composition des fonctions:

• opérateurs monadiques: chacun:, f¨réduit f/:, commute:f⍨
• opérateurs dyadiques - puissance:, f⍣ncomposer:f∘g
• fourches— (f g h)B ←→ (f B)g(h B);A(f g h)B ←→ (A f B)g(A h B)
• au sommet— (f g)B ←→ f(g B);A(f g)B ←→ f(A g B)
• 4 trains (embranchements) -(f g h k) ←→ (f (g h k))

Fonctions primitives utilisées:

• droite:A⊢B ←→ B
• sens inverse:⌽B
• premier:⊃B
• enchaîner:A,B
• ne correspond pas:, A≢Bcompte:≢B
• joindre:, ⊂Bpartition:A⊂B
• aplatir:∊B

Dans tryapl.org, si vous supprimez la fin ⊢1, qui est l'argument de cette chose composée massive, vous pouvez voir un diagramme de la façon dont elle est analysée:

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

J 66 (avec E / S)

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

sans IO, marque 43:

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

Drôle de question à vous poser, quand est-ce que les 9 premiers à apparaître?