Você também cria um programa que usa um número inteiro como entrada e gera o primeiro que nunca esse número foi da sequência de look and say .

Por exemplo:

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

A maneira exata de exibir a lista não é importante, desde que os usuários possam ver distintamente os diferentes números da sequência. Aqui está o problema. Você não pode usar nenhum tipo de variável definida pelo usuário.

Por exemplo:

1. Nenhuma variável, incluindo variáveis ​​de escopo.
2. Quando você tem funções, elas não podem ter um nome. (Exceção, se o seu idioma exigir uma função principal ou semelhante ao trabalho, você poderá ter essa função.)
3. Quando você tem funções, elas não podem ter argumentos nomeados.

Além disso, você não pode usar uma biblioteca com recursos específicos relacionados à seqüência look and say, e não pode acessar a rede ou fornecer ao seu programa nenhum arquivo (embora ele possa gerar e usar os seus próprios.) código tão curto em caracteres ganha!

GolfScript (31 caracteres)

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

Adaptado da minha resposta para uma pergunta anterior do tipo "olha e diga" . Este possui uma restrição menos onerosa para linguagens funcionais, o que permite salvar 5 caracteres, mas como a maioria das respostas à pergunta anterior não pode ser adaptada (é uma restrição loucamente onerosa para linguagens não funcionais), não acho que faça sentido. para fechá-lo como um idiota.

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

Ele funciona usando a função de grupo para agrupá-los em grupos de coisas iguais. Em seguida, ele usa aplicativos com funções para criar uma função que lê simultaneamente o comprimento e o anexa a um dos elementos. Ele usa uma correção e um mapa para criar uma definição recursiva (sem pontos). E pronto.

J (42 caracteres)

A programação sem pontos (também chamada tácita) é natural em J.

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

Essa é uma função: para usá-lo, você escreve o código, um espaço e o número de entrada. Por exemplo,

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

Observe as caixas bonitas na saída.

Adendo : Aqui estão alguns "truques" que eu era tímido demais para usar no começo, mas agora que eu já vi outros usá-los primeiro ...

• Aqui está uma versão de 36 caracteres com uma "convenção de chamada" diferente: substitua 8 pelo número de termos que você deseja.

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

• E se houver zeros extras na saída, aqui está uma versão de 32 caracteres:

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

GolfScript, 36 caracteres

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

As variáveis ​​raramente são usadas no GolfScript, e essa tarefa certamente não precisa delas. A entrada está em stdin, a saída em stdout. Por exemplo, a entrada 8fornece a saída:

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

Posso escrever uma explicação detalhada desse código posteriormente, mas pelo menos você pode facilmente dizer que ele não usa variáveis ​​pelo fato de não incluir o operador de atribuição de variáveis ​​em :nenhum lugar.

Haskell, 118 caracteres (80 sem importações)

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

Bash e coreutils, 111 73 caracteres

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

uniq -cestá fazendo o trabalho pesado para produzir o próximo número na sequência. yes, sedE evalcriar o necessário número de repetições do pipeline de processamento. O resto é apenas formatação.

A saída é colocada em um arquivo chamado o.:

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

Mathematica, 65 caracteres

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

Exemplo:

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

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

J, 37 caracteres

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

Com base na minha resposta à pergunta Pea Pattern . Pode haver algum potencial de redução aqui. O uso é como para a outra resposta 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

Ele também tem o problema de zeros extras que minha resposta no padrão de ervilha teve.

Perl 6: 63 53 caracteres

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

Crie uma lista lenta da sequência Look and Say ( 1,*.subst(/(\d)$0*/,{.chars~.[0]},:g)...*) e obtenha quantos elementos [^get]forem especificados pelo usuário ( que é um índice e meios de matriz [0..(get-1)]) e saytodos eles.

A lista lenta funciona primeiro com 1, depois para gerar cada número sucessivo, pega o último encontrado e substitui todas as seqüências do mesmo dígito, conforme correspondido por /(\d)$0*/, e as substitui por {quantos} + {que dígito} , ou .chars~.[0].

As únicas variáveis ​​nesse código são $0: a primeira captura da correspondência e a $_variável tópica implícita que .methodé chamada, e nenhuma delas é definida pelo usuário.

GolfScript, 57 43 caracteres

Minha própria abordagem. Acabou mais do que o existente, infelizmente = (.

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

Saída de amostra para 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]

Versão alternativa sem o 9sentinela, ainda mais com 47 caracteres. Eu suspeito que tem mais potencial:

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

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

⎕é entrada avaliada. No link, substituí-o por 8, pois o tryapl.org não permite a entrada do usuário.

Sem variáveis ​​nomeadas ( a←1), sem funções nomeadas ( f←{}), sem argumentos ( ⍺, ⍵).

Somente composição de funções:

• operadores monádicos - cada um:, f¨reduza f/:, comute:f⍨
• operadores diádicos - poder:, f⍣ncompor:f∘g
• garfos - (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 trens (bifurcações) -(f g h k) ←→ (f (g h k))

Funções primitivas usadas:

• certo:A⊢B ←→ B
• marcha ré:⌽B
• primeiro:⊃B
• concatenar:A,B
• não corresponde A≢B:, conte:≢B
• delimitar:, ⊂Bpartição:A⊂B
• aplainar:∊B

No tryapl.org, se você remover a trilha, ⊢1que é o argumento para essa coisa composta maciça, poderá ver um diagrama de como ela é analisada:

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

J 66 (com E / S)

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

sem IO, pontuação 43:

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

Pergunta engraçada para se colocar, quando é o primeiro 9 a aparecer?