Вы тоже создаете программу, которая принимает целое число в качестве входных данных и выводит первое, что когда-либо было в этом числе последовательности вида и произнесения .

Например:

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

Точный способ вывода списка не имеет значения, поскольку пользователи могут отчетливо видеть разные номера последовательности. Здесь подвох хотя. Вы не можете использовать какую-либо пользовательскую переменную.

Например:

1. Нет переменных, включая переменные в области видимости.
2. Когда у вас есть функции, они не могут иметь названия. (Исключение: если вашему языку требуется основная функция или что-то подобное для работы, у вас может быть эта функция.)
3. Когда у вас есть функции, они не могут иметь именованных аргументов.

Кроме того, вы не можете использовать библиотеку с конкретными возможностями, относящимися к последовательности «посмотрите и произнесите», и вы не можете получить доступ к сети или предоставить вашей программе какие-либо файлы (хотя она может генерировать и использовать свои собственные). Это код гольф, так короткий код в символах выигрывает!

GolfScript (31 символ)

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

Адаптировано из моего ответа на предыдущий вопрос «посмотри и скажи» . У этого есть менее обременительное ограничение для функциональных языков, которое позволяет сохранять 5 символов, но поскольку большинство ответов на предыдущий вопрос не могут быть адаптированы (это безумно обременительное ограничение для нефункциональных языков), я не думаю, что это имеет смысл чтобы закрыть это как обман.

Haskell 206 символов

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

Он работает, используя функцию group, чтобы сгруппировать их в группы одинаковых вещей. Затем он использует аппликативы с функциями для создания функции, которая одновременно считывает длину и добавляет ее к одному из элементов. Он использует исправление и карту для создания рекурсивного определения (без указания точки). И все.

J (42 символа)

Бессмысленное (также называемое молчаливое) программирование естественно для J.

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

Это функция, для ее использования вы пишете код, пробел и номер ввода. Например,

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

Обратите внимание на красивые коробки в выводе.

Приложение : Вот пара «читов», которые я поначалу был слишком застенчив, чтобы использовать, но теперь, когда я видел, как другие используют их сначала ...

• Вот 36-символьная версия с другим «соглашением о вызовах»: замените 8 на количество терминов, которое вы хотите.

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

• И если с дополнительными нулями на выходе все в порядке, вот версия с 32 символами:

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

GolfScript, 36 символов

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

Переменные довольно редко используются в GolfScript, и эта задача, безусловно, не нуждается в них. Вход на стандартный вывод, вывод на стандартный вывод. Например, ввод 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]]

Я могу написать подробное объяснение этого кода позже, но, по крайней мере, вы можете легко сказать, что он не использует переменные, потому что он нигде не содержит оператора присваивания переменных :.

Haskell, 118 символов (80 без импорта)

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

Bash и Coreutils, 111 73 символов

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

uniq -cделает тяжелую работу, чтобы произвести следующий номер в последовательности. yes, sedИ evalсоздать необходимое количество повторов конвейера обработки. Остальное просто форматирование.

Вывод помещается в файл с именем o.:

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

Mathematica, 65 символов

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

Пример:

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

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

J, 37 символов

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

Основано на моем ответе на вопрос о Образце гороха . Здесь может быть некоторый потенциал для сокращения. Использование так же, как для другого ответа 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

У этого также есть проблема дополнительных нулей, которую имел мой образец гороха.

Perl 6: 63 53 персонажа

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

Создайте ленивый список последовательности Look и Say ( 1,*.subst(/(\d)$0*/,{.chars~.[0]},:g)...*), а затем получите столько элементов, сколько указано пользователем ( [^get]что является индексом массива [0..(get-1)]), и sayих всех.

Ленивый список работает, сначала беря 1, затем генерируя каждое последующее число, он берет последнее найденное число и заменяет все последовательности одной и той же цифры в соответствии с соответствием /(\d)$0*/и заменяет их {сколько} + {какая цифра} или .chars~.[0].

Единственными переменными в этом коде являются $0: первый захват совпадения и неявная актуальная $_переменная, которая .methodвызывается без вызова, и ни одна из них не определяется пользователем.

GolfScript, 57 43 символа

Мой собственный подход. Закончилась дольше, чем существующая, к сожалению = (.

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

Пример вывода для стандартного ввода 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]

Альтернативная версия без 9часового, но длиннее - 47 символов. Я подозреваю, что у этого есть больший потенциал:

~[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"))

Дьялог АПЛ, 35 знаков

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

⎕оценивается вход. В ссылке я заменил ее на 8, так как tryapl.org не позволяет вводить данные пользователем.

Без именованных переменных ( a←1), без именованных функций ( f←{}), без аргументов ( ⍺, ⍵).

Только состав функций:

• монадические операторы - каждый:, f¨уменьшить:, f/коммутировать:f⍨
• диадические операторы - power:, f⍣ncompose:f∘g
• вилки— (f g h)B ←→ (f B)g(h B);A(f g h)B ←→ (A f B)g(A h B)
• поверх- (f g)B ←→ f(g B);A(f g)B ←→ f(A g B)
• 4 поезда (вилочные) -(f g h k) ←→ (f (g h k))

Используемые примитивные функции:

• верно:A⊢B ←→ B
• обратный:⌽B
• первый:⊃B
• конкатенации:A,B
• не совпадают: A≢B, посчитайте:≢B
• вложите:, ⊂Bраздел:A⊂B
• выравниваться:∊B

В tryapl.org, если вы удалите трейлинг ⊢1, который является аргументом для этой массивной составной вещи, вы можете увидеть диаграмму ее анализа:

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

J 66 (с вводом / выводом)

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

без IO, оценка 43:

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

Забавный вопрос, который нужно задать себе, когда появятся первые 9?