Anda juga membuat program yang mengambil bilangan bulat sebagai input dan menampilkan pertama berapa pun urutan itu dari tampilan dan katakan .

Sebagai contoh:

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

Cara tepat Anda menampilkan daftar tidak penting, selama pengguna dapat dengan jelas melihat nomor yang berbeda dari urutan tersebut. Inilah tangkapannya. Anda tidak dapat menggunakan variabel apa pun yang ditentukan pengguna.

Sebagai contoh:

1. Tidak ada variabel, termasuk variabel cakupan.
2. Ketika Anda memiliki fungsi, mereka tidak dapat memiliki nama. (Pengecualian, jika bahasa Anda memerlukan fungsi utama atau mirip dengan pekerjaan, Anda mungkin memiliki fungsi itu.)
3. Ketika Anda memiliki fungsi, mereka tidak bisa menamai argumen.

Selain itu, Anda tidak boleh menggunakan perpustakaan dengan kemampuan khusus yang berkaitan dengan tampilan dan urutan kata, dan Anda tidak dapat mengakses jaringan, atau menyediakan program Anda dengan file apa pun (meskipun dapat menghasilkan dan menggunakan sendiri.) Ini adalah kode golf, jadi kode terpendek dalam karakter menang!

GolfScript (31 karakter)

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

Diadaptasi dari jawaban saya ke pertanyaan lihat-dan-katakan sebelumnya . Yang ini memiliki pembatasan yang kurang berat untuk bahasa fungsional, yang memungkinkan penyimpanan 5 karakter, tetapi karena sebagian besar jawaban untuk pertanyaan sebelumnya tidak dapat diadaptasi (ini adalah pembatasan yang sangat berat untuk bahasa yang tidak fungsional) Saya pikir itu tidak masuk akal untuk menutupnya sebagai korban penipuan.

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

Ia bekerja dengan menggunakan fungsi grup untuk mengelompokkan mereka ke dalam kelompok hal yang sama. Kemudian menggunakan pelamar dengan fungsi untuk membangun fungsi yang secara bersamaan membaca panjangnya, dan menambahkannya dengan salah satu elemen. Ini menggunakan perbaikan dan peta untuk membuat definisi rekursif (point-free.) Dan begitulah.

J (42 karakter)

Pemrograman point-free (juga disebut tacit) adalah alami di J.

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

Itu fungsi, untuk menggunakannya Anda menulis kode, spasi, dan nomor input. Sebagai contoh,

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

Perhatikan kotak cantik di output.

Tambahan : Berikut adalah beberapa "cheat" yang saya terlalu malu untuk digunakan pada awalnya, tetapi sekarang saya telah melihat yang lain menggunakannya terlebih dahulu ...

• Berikut adalah versi 36 karakter dengan "konvensi panggilan" yang berbeda: ganti 8 dengan jumlah istilah yang Anda inginkan.

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

• Dan jika memiliki nol ekstra dalam output OK, berikut adalah versi 32 char:

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

GolfScript, 36 karakter

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

Variabel sangat jarang digunakan dalam GolfScript, dan tugas ini tentu saja tidak membutuhkannya. Input ada di stdin, output ke stdout. Sebagai contoh, input 8memberikan 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]]

Saya dapat menulis penjelasan rinci tentang kode ini nanti, tetapi setidaknya Anda dapat dengan mudah mengatakan bahwa itu tidak menggunakan variabel oleh fakta bahwa itu tidak termasuk operator penugasan variabel di :mana saja.

Haskell, 118 karakter (80 tanpa impor)

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

Bash dan coreutils, 111 73 karakter

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

uniq -c melakukan pengangkatan berat untuk menghasilkan nomor berikutnya dalam urutan. yes, seddan evalbuat jumlah pengulangan yang diperlukan dari pipa pemrosesan. Sisanya hanya memformat.

Output ditempatkan dalam file bernama o::

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

Mathematica, 65 karakter

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

Contoh:

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

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

J, 37 karakter

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

Berdasarkan jawaban saya untuk pertanyaan Pola Kacang . Mungkin ada beberapa potensi untuk memperpendek di sini. Penggunaan adalah untuk jawaban J lainnya:

   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

Ini juga memiliki masalah nol ekstra jawaban pola kacang saya.

Perl 6: 63 53 karakter

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

Buat daftar malas urutan Look and Say ( 1,*.subst(/(\d)$0*/,{.chars~.[0]},:g)...*), dan kemudian dapatkan elemen sebanyak yang ditentukan oleh pengguna ( [^get], yang merupakan subscript dan cara array [0..(get-1)]), dan saysemuanya.

Daftar malas bekerja dengan terlebih dahulu mengambil 1, kemudian untuk menghasilkan setiap nomor berurutan, dibutuhkan yang terakhir yang ditemukan dan menggantikan semua urutan dari digit yang sama, seperti yang dicocokkan /(\d)$0*/, dan menggantikannya dengan {berapa banyak} + {digit apa} , atau .chars~.[0].

Satu-satunya variabel dalam kode ini adalah $0, tangkapan pertama pertandingan, dan $_variabel topikal implisit, yang .methodditelepon, dan tidak satu pun dari yang ditentukan pengguna.

GolfScript, 57 43 karakter

Pendekatan saya sendiri. Berakhir lebih lama dari yang ada dengan sedih = (.

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

Contoh output untuk stdin dari 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 alternatif tanpa 9sentinel, namun lebih lama di 47 karakter. Saya menduga itu lebih berpotensi:

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

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

⎕input dievaluasi. Di tautan saya telah menggantinya dengan 8, karena tryapl.org tidak mengizinkan input pengguna.

Tidak ada variabel bernama ( a←1), tidak ada fungsi bernama ( f←{}), tidak ada argumen ( ⍺, ⍵).

Hanya komposisi fungsi:

• operator monadik — masing-masing:, f¨mengurangi f/:, bepergian:f⍨
• operator diad — daya f⍣n:, menyusun:f∘g
• garpu— (f g h)B ←→ (f B)g(h B);A(f g h)B ←→ (A f B)g(A h B)
• di atas— (f g)B ←→ f(g B);A(f g)B ←→ f(A g B)
• 4 kereta (fork-atops) -(f g h k) ←→ (f (g h k))

Fungsi primitif yang digunakan:

• Baik:A⊢B ←→ B
• membalikkan:⌽B
• pertama:⊃B
• menggabungkan:A,B
• tidak cocok A≢B:, hitung:≢B
• melampirkan:, ⊂Bpartisi:A⊂B
• meratakan:∊B

Di tryapl.org, jika Anda menghapus trailing ⊢1, yang merupakan argumen untuk hal yang dikomposisikan secara besar-besaran ini, Anda dapat melihat diagram bagaimana ia diuraikan:

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

J 66 (dengan I / O)

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

tanpa IO, skor 43:

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

Pertanyaan lucu untuk mengajukan diri, kapan 9 yang pertama muncul?