Usted también crea un programa que toma un número entero como entrada y emite el primero, cualquiera que sea ese número de la secuencia de mirar y decir .

Por ejemplo:

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

La forma exacta en que genera la lista no es importante, siempre que los usuarios puedan ver claramente los diferentes números de la secuencia. Aquí está la trampa sin embargo. No puede usar ningún tipo de variable definida por el usuario.

Por ejemplo:

1. Sin variables, incluidas las variables de ámbito.
2. Cuando tiene funciones, no pueden tener un nombre. (Excepción, si su idioma requiere una función principal o similar al trabajo, puede tener esa función).
3. Cuando tiene funciones, no pueden tener argumentos con nombre.

Además, no puede usar una biblioteca con capacidades específicas relacionadas con la secuencia de mirar y decir, y no puede acceder a la red ni proporcionar a su programa ningún archivo (aunque puede generar y usar el suyo). Este es el código golf, ¡Entonces el código más corto en caracteres gana!

GolfScript (31 caracteres)

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

Adaptado de mi respuesta a una pregunta previa de mirar y decir . Este tiene una restricción menos onerosa para los lenguajes funcionales, lo que permite guardar 5 caracteres, pero debido a que la mayoría de las respuestas a la pregunta anterior no se pueden adaptar (es una restricción locamente onerosa para los lenguajes no funcionales) No creo que tenga sentido para cerrarlo como un engañado.

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

Funciona usando la función de grupo para agruparlos en grupos de cosas iguales. Luego usa aplicativos con funciones para construir una función que lee simultáneamente la longitud y la agrega con uno de los elementos. Utiliza una solución y un mapa para crear una definición recursiva (sin puntos). Y listo.

J (42 caracteres)

La programación sin puntos (también llamada tácita) es natural en J.

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

Esa es una función, para usarla escribes el código, un espacio y el número de entrada. Por ejemplo,

   ,@:((#,{.);.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 los cuadros bonitos en la salida.

Anexo : Aquí hay un par de "trucos" que al principio era demasiado tímido para usar, pero ahora que he visto a otros usarlos primero ...

• Aquí hay una versión de 36 caracteres con una "convención de llamada" diferente: reemplace 8 con el número de términos que desee.

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

• Y si tener ceros adicionales en la salida está bien, aquí hay una versión de 32 caracteres:

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

GolfScript, 36 caracteres

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

Las variables rara vez se usan en GolfScript, y esta tarea ciertamente no las necesita. La entrada está en stdin, salida a stdout. Por ejemplo, la entrada 8da la salida:

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

Puedo escribir una explicación detallada de este código más adelante, pero al menos puedes decir fácilmente que no usa variables por el hecho de que no incluye el operador de asignación de variables en :ningún lado.

Haskell, 118 caracteres (80 sin importaciones)

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

Bash y Coreutils 111 73 caracteres

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

uniq -cestá haciendo el trabajo pesado para producir el siguiente número en la secuencia. yes, sedY evalcrear el número necesario de repeticiones de la canalización de procesamiento. El resto es solo formatear.

La salida se coloca en un archivo llamado o.:

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

Mathematica, 65 caracteres

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

Ejemplo:

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.

Basado en mi respuesta a la pregunta del patrón de guisantes . Puede haber algún potencial para acortar aquí. El uso es como para la otra respuesta 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

También tiene el problema de ceros adicionales que tenía mi respuesta de patrón de guisante.

Perl 6: 63 53 caracteres

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

Cree una lista perezosa de la secuencia Look and Say ( 1,*.subst(/(\d)$0*/,{.chars~.[0]},:g)...*), y luego obtenga tantos elementos como especifique el usuario ( [^get]que es un subíndice de matriz y medios [0..(get-1)]), y saytodos ellos.

La lista perezosa funciona tomando primero 1, luego para generar cada número sucesivo, toma el último que encontró y sustituye todas las secuencias del mismo dígito, según corresponda /(\d)$0*/, y las reemplaza con {cuántos} + {qué dígito} o .chars~.[0].

Las únicas variables en este código son $0, la primera captura de la coincidencia, y la $_variable tópica implícita que se .methodllama, y ​​ninguna de estas son definidas por el usuario.

GolfScript, 57 43 caracteres

Mi propio enfoque Terminó más tiempo que el existente tristemente = (.

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

Salida de muestra 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]

Versión alternativa sin el 9centinela, pero es más larga con 47 caracteres. Sospecho que tiene más 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

⎕Se evalúa la entrada. En el enlace lo he reemplazado por 8, ya que tryapl.org no permite la entrada del usuario.

Sin variables con nombre ( a←1), sin funciones con nombre ( f←{}), sin argumentos ( ⍺, ⍵).

Única composición de funciones:

• operadores monádicos: cada uno:, f¨reducir:, f/conmutar:f⍨
• operadores diádicos: potencia: f⍣ncomponer:f∘g
• horquillas (f g h)B ←→ (f B)g(h B);A(f g h)B ←→ (A f B)g(A h B)
• encima de ellas (f g)B ←→ f(g B);A(f g)B ←→ f(A g B)
• 4 trenes (horquillas a bordo) -(f g h k) ←→ (f (g h k))

Funciones primitivas utilizadas:

• Correcto:A⊢B ←→ B
• marcha atrás:⌽B
• primero:⊃B
• concatenar:A,B
• no coincide:, A≢Bcuenta:≢B
• adjuntar: ⊂Bpartición:A⊂B
• aplanar:∊B

En tryapl.org, si elimina el final ⊢1, que es el argumento de esta cosa compuesta masiva, puede ver un diagrama de cómo se analiza:

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

J 66 (con E / S)

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

sin IO, puntajes 43:

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

Pregunta divertida para hacerte, ¿cuándo aparecerán los primeros 9?