Mantan Menteri Pertahanan AS, Donald Rumsfeld, terkenal mempopulerkan ungkapan "yang dikenal." Di sini kita akan menyaring komentarnya menjadi bait empat baris.

Secara khusus, tampilkan teks ini:

known knowns
known unknowns
unknown knowns
unknown unknowns

Kapitalisasi tidak penting (misalnya, Known unKnownsbaik-baik saja), dan satu baris baru trailing dapat diterima, tetapi tidak ada perubahan pemformatan lainnya yang diizinkan. Itu berarti satu spasi di antara kata-kata, dan LF(59 byte) atau CR/LF(62 byte) antara baris.

Aturan

• Program lengkap atau fungsi dapat diterima. Jika suatu fungsi, Anda dapat mengembalikan output daripada mencetaknya.
• Celah standar dilarang.
• Ini adalah kode-golf sehingga semua aturan golf biasa berlaku, dan kode terpendek (dalam byte) menang.

Python 2 , 54 52 byte

^{-2 byte terima kasih kepada xnor}

k='unknowns'
for i in 8,6,2,0:print k[i/3:7],k[i%3:]

Cobalah online!

Hasil dari /dan %akan menjadi [[2, 2], [2, 0], [0, 2], [0, 0]]indeks awal, menghapus unkapan 2, menjaga string tidak berubah saat0

Vim 28 25 byte

Ini jawaban Vim pertamaku, segala tip bermain golf dipersilakan.

2iunknown ␛rsY3P2xw.+.jw.

Terima kasih Lynn karena telah menulis skrip python untuk membuat animasi yang fantastis.

Ini juga dapat dijalankan oleh V Coba Online!

Juga 25:

2iknown ␛rsY3pwiun␛+.+.w.

bash, 36 byte

printf %s\\n {,un}known\ {,un}knowns

solusi lain

36

eval echo\ {,un}known\ {,un}knowns\;

37

eval printf '%s\\n' \{,un}known{\\,s}

38

eval eval echo\\ \{,un}known{\\,'s\;'}

41

x=\\\ {,un}known;eval "eval echo$x$x\s\;"

45

x='\ {,un}known' e=eval;$e "$e echo$x$x\s\;"
x='\ {,un}known' e=eval\ ;$e"$e\echo$x$x\s\;"

jika baris baru dan ruang ekstra diterima 31 byte:

echo '
'{,un}known\ {,un}knowns

05AB1E , 13 12 byte

Disimpan 1 byte berkat Erik the Outgolfer (hindari string penutup)

„Š¢—‚#D's«â»

Cobalah online!

Penjelasan

„Š¢—‚           # push the string "known unknown"
     #          # split on spaces
      D         # duplicate
       's«      # append "s" to each
          â     # cartesian product
           »    # join on newline

CJam ( 26 25 byte)

"unknown"_2>\]2m*{S*'sN}%

Demo online

Dengan produk Cartesian ["known" "unknown"]sendiri, maka masing-masing elemen bergabung dengan ruang dan diakhiri dengan sdan sebuah baris baru.

Terima kasih kepada Erik untuk penghematan satu byte.

R , 52 51 50 byte

cat(gsub(1,"known","1 1s
1 un1s
un1 1s
un1 un1s"))

Cobalah online!

Substitusi dan perintah cetak yang sangat singkat menjadikannya jawaban R yang sangat kompetitif dalam tantangan string !

Bahkan jika itu sangat membosankan. Agak lebih menarik sekarang, dan dengan satu byte tersimpan berkat Joe .

Menyimpan byte lain berkat jawaban ini, juga oleh J.Doe!

Haskell , 60 58 53 51 byte

f<$>l<*>l
f x y=x++' ':y++"s"
l=["known","unknown"]

Cobalah online!

Menghasilkan daftar garis seperti yang baru-baru ini diizinkan. Terima kasih kepada @firefrorefiddle karena telah menunjukkan.

-2 byte berkat cole .

Versi 58 byte:

f=<<"? ?s\n? un?s\nun? ?s\nun? un?s"
f '?'="known"
f c=[c]

Cobalah online! Menghasilkan satu string.

C # (.NET Core) , 54 byte

v=>@"z zs
z unzs
unz zs
unz unzs".Replace("z","known")

Cobalah online!

Retina , 33 32 byte

 s¶ uns¶un s¶un uns
 |s
known$&

Cobalah online! Sunting: Disimpan 1 byte berkat @ovs. Penjelasan: Ini hampir merupakan pendekatan sepele menggunakan placeholder untuk known, kecuali di sini saya cukup menyisipkannya sebelum setiap ruang atau s, yang menghemat 3 4 byte.

PHP, 55 51 47 byte

<?=strtr("1 1s
1 01s
01 1s
01 01s",[un,known]);

coba online

Retina , 33 32 byte

Disimpan 1 byte menggunakan pendekatan pencetakan perantara dari Leo.

 ¶u

knowns
u
 un
:`s 
 
m`^
un

Cobalah online!

Penjelasan

 ¶u

Mengubah input yang tidak ada (yaitu kosong) menjadi string pada baris kedua. Yang satu itu kelihatannya sangat aneh, tetapi karakter-karakter ini adalah kode untuk hal-hal yang terjadi di antara dua contoh known[s]pada dua baris pertama hasilnya. Ruang dan linefeed hanya diri mereka sendiri dan uini un.

knowns

Sekarang kita menyisipkan knownsdi setiap posisi (yaitu di awal, akhir, dan di antara setiap pasangan karakter).

u
 un

Kami memecahkan kode u.

:s 
 

Kemudian kita singkirkan sdi depan spasi, yaitu yang ada di paruh pertama setiap baris, dan cetak hasilnya.

m`^
un

Dan akhirnya kami menambahkan unkedua baris dan mencetak hasilnya lagi.

Ini mengalahkan pendekatan sepele dari hanya menggunakan placeholder knownsebesar 4 byte, tetapi bukan implementasi Neil yang lebih efisien dari pendekatan itu.

Bahasa Pemrograman Shakespeare , 1021 1012 993 byte

-19 byte, terima kasih kepada Joe King!

,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:Am I nicer a big cat?If sois the remainder of the quotient betweenI the sum ofa cat a big cat worse a big cat?If notlet usScene V.You be the sum ofa fat fat fat pig the cube ofthe sum ofa cat a big big cat.Speak thy.You be the sum ofyou the sum ofa cat a fat fat fat pig.Speak thy.Scene V:.[Exit Ajax][Enter Page]Page:You be the product ofthe sum ofa cat a big big cat the sum ofa pig a big big big big cat.Speak thy.You be the sum ofyou the sum ofa cat a big cat.Speak thy.Ford:You be the sum ofI a cat.Speak thy.You be the sum ofyou a big big big cat.Speak thy.Page:Speak thy.You be the sum ofyou the sum ofa cat a big big cat.Is the remainder of the quotient betweenAjax a big cat worse a cat?If soyou big big big big big cat.Speak thy.If solet usScene X.You be twice the sum ofa cat a big big cat.Speak thy.Scene X:.[Exit Page][Enter Ajax]Ford:You be the sum ofyou a cat.Be you worse a big big big cat?If solet usAct I.

Cobalah online!

Perl 6 , 45 byte

$_='known';.say for [X](($_,"un$_")xx 2)X~'s'

Cobalah

Diperluas

$_ = 'known';

.say                # print with trailing newline the value in topic variable ｢$_｣

  for               # do that for each of the following

    [X](
      ($_, "un$_")  # ('known','unknown')
        xx 2        # list repeated twice
    ) X~ 's'        # cross using &infix:«~» with 's' (adds ｢s｣ to the end)

Bagian [X](…)menghasilkan

(("known","known"),("known","unknown"),("unknown","known"),("unknown","unknown")).Seq

Kemudian menggunakannya X~di dalamnya memaksa daftar dalam menjadi Str (karena &infix:«~»operator), yang melakukan hal itu menambah ruang antara nilai.

("known known", "known unknown", "unknown known", "unknown unknown").Seq

Kemudian masing-masing digabungkan dengan s

("known knowns", "known unknowns", "unknown knowns", "unknown unknowns").Seq

Haskell, 57 52 byte

id=<<id=<<mapM(\s->[s,"un"++s])["known ","knowns\n"]

Cobalah online!

APL (Dyalog) , 64 47 35 byte

⍪,∘.{⍺,' ',⍵,'s'}⍨k('un',k←'known')

Cobalah online!

Bagaimana?

k←'known'- kadalah"known"

k('un',k←'known') - "known" "unknown"

∘.... ⍨- produk luar dengan sendirinya

    {⍺,' ',⍵,'s'} - dengan fungsi yang memformat args sebagai {⍺} {⍵}s

, - hancurkan tabel produk menjadi vektor

⍪ - Pisahkan ke kolom

Java 8, 56 55 byte

v->" s\n uns\nun s\nun uns".replaceAll(" |s","known$0")

-1 byte terima kasih kepada @SuperChafouin .

Penjelasan:

Coba di sini.

v->                         // Method with empty unused parameter
  " s\n uns\nun s\nun uns"  //  Literal String
   .replaceAll(" |s",       //  Replace all spaces and "s" with:
     "known                 //   Literal "known"
           $0")             //   + the match (the space or "s")
                            // End of method (implicit / single-line return-statement)

C (gcc),  79  78 76 byte

Terima kasih kepada @Justin Mariner karena bermain golf satu byte!

f(){printf("%s %1$ss\n%1$s un%1$ss\nun%1$s %1$ss\nun%1$s un%1$ss","known");}

Cobalah online!

Sekam , 14 byte

OΠṠemhw¨ṅW∫ḟωμ

Cobalah online!

Penjelasan

OΠṠemhw¨ṅW∫ḟωμ
       ¨ṅW∫ḟωμ    The compressed string "knowns unknowns"
      w           Split on spaces ["knowns","unknowns"]
   e              Make a list with:
    mh             this list with the last letter dropped from each word
  Ṡ                and this same list
                  [["known","unknown"],["knowns","unknowns"]]
 Π                Cartesian product [["known","knowns"],["unknown","knowns"],["known","unknowns"],["unknown","unknowns"]]
O                 Sort the list [["known","knowns"],["known","unknowns"],["unknown","knowns"],["unknown","unknowns"]]
                  Implicitely print joining with spaces and newlines

6502 kode mesin (C64), 48 byte

00 C0 A9 37 85 FB A9 73 4D 2B C0 8D 2B C0 A9 0D 4D 2C C0 8D 2C C0 A9 26 90 02
E9 02 A0 C0 20 1E AB 06 FB D0 E1 60 55 4E 4B 4E 4F 57 4E 53 0D 00

Demo online

Pemakaian: sys49152

Bagaimana itu bekerja

Kuncinya di sini adalah dengan menggunakan "loop counter" untuk 8 iterasi di mana bit 7 sampai 1 dari nilai awal adalah 1untuk unknown(s)dan 0untuk known(s)dalam satu iterasi. Penghitung ini digeser ke kiri setelah setiap iterasi (menggeser bit paling kiri ke bendera carry) dan bit 0awalnya 1jadi kita tahu kita selesai begitu bit terakhir digeser keluar. Pada iterasi pertama, knowndicetak karena saat memanggil program, flag carry jelas.

Di setiap iterasi, ujung string beralih antara <space>dan s<newline>.

Berikut daftar pembongkaran yang dikomentari:

         00 C0            .WORD $C000    ; load address
.C:c000  A9 37            LDA #$37       ; initialize loop counter ...
.C:c002  85 FB            STA $FB        ; ... as 0011 0111, see description
.C:c004   .loop:
.C:c004  A9 73            LDA #('s'^' ') ; toggle between 's' and space
.C:c006  4D 2B C0         EOR .plural
.C:c009  8D 2B C0         STA .plural
.C:c00c  A9 0D            LDA #$0D       ; toggle between newline and 0
.C:c00e  4D 2C C0         EOR .newline
.C:c011  8D 2C C0         STA .newline
.C:c014  A9 26            LDA #<.knowns  ; start at "known" except
.C:c016  90 02            BCC .noprefix  ; when carry set from shifting $fb:
.C:c018  E9 02            SBC #$02       ; than start at "un"
.C:c01a   .noprefix:
.C:c01a  A0 C0            LDY #>.knowns  ; high-byte of string start
.C:c01c  20 1E AB         JSR $AB1E      ; output 0-terminated string
.C:c01f  06 FB            ASL $FB        ; shift loop counter
.C:c021  D0 E1            BNE .loop      ; repeat if not 0 yet
.C:c023  60               RTS            ; done
.C:c024   .unknowns:
.C:c024  55 4E           .BYTE "un"
.C:c026   .knowns:
.C:c026  4B 4E 4F 57 4E  .BYTE "known"
.C:c02b   .plural:
.C:c02b  53              .BYTE "s"
.C:c02c   .newline
.C:c02c  0D 00           .BYTE $0d, $00

Perl 5 , 33 byte

Disclaimer : Saya tidak menyadari bahwa ekspansi penjepit mungkin dalam <...>operator (belajar berkat @ Kotor 's jawaban !) Dan menggunakan trik ekspansi pandai dari @ NahuelFouilleul ' s menakjubkan jawaban pesta , saya bisa membangun solusi ini. Saya dengan senang hati akan menghapus ini atas permintaan mereka.

print<"{,un}known {,un}knowns$/">

Cobalah online!

Perl 5 , 42 byte

41 byte kode +1 untuk -p.

s//K Ks
K unKs/;s/K/known/g;$\=s/^/un/gmr

Cobalah online!

Perl 5 , 45 byte

Mencoba mencari alternatif, tapi tidak bisa membuatnya lebih pendek ... Kupikir itu cukup berbeda untuk menjamin penambahan.

print"un"x/[3467]/,known,$_%2?"s
":$"for 0..7

Cobalah online!

Haskell, 71 66 56 54 byte

(<*>).map((++).init)<*>map(' ':)$["knowns","unknowns"]

Terima kasih kepada @ Leo untuk -3 byte!

_{Catatan: Dalam komentar pertanyaan, op mengatakan bahwa mengembalikan daftar string tidak masalah}

Coba di sini.

Jelly , 15 byte

“ṿ1“ŒwƘ»pż€⁾ sY

Cobalah online!

Ruby, 53 50 byte

$><<"a as
a unas
una as
una unas".gsub(?a,"known")

Batch, 66 byte

@set s= in (known unknown)do @
@for %%a%s%for %%b%s%echo %%a %%bs

Jawaban alternatif, juga 66 byte:

@for %%a in (k unk)do @for %%b in (k unk) do @echo %%anown %%bnowns

Haxe, 71 byte

(?x)->[for(a in x=["","un"])for(b in x)a+'known ${b}knowns'].join("\n")

Cobalah online!

C (gcc) , 70 66 byte

Berkat @ l4m2 untuk -4 byte!

f(i){for(i=8;i--;)printf("unknown%s"+(i>4|i==2)*2,i%2?" ":"s\n");}

Cobalah online!

PowerShell , 46 44 byte

' s
 uns
un s
un uns'-replace' |s','known$&'

Cobalah online!

(Hampir) penggantian string sederhana. Menggunakan pendekatan Neil untuk memangkas dua byte. Terima kasih kepada Martin karena menunjukkan hal itu.

Sayangnya, ini lebih pendek daripada metode lintas-produk yang lebih menarik dengan tiga lima tiga byte:

PowerShell , 49 47 byte

($a='known','unknown')|%{$i=$_;$a|%{"$i $_`s"}}

Cobalah online!

T-SQL, 56 54 byte

PRINT REPLACE('1 1s
1 un1s
un1 1s
un1 un1s',1,'known')

SQL mendukung jeda baris di dalam string literal, sangat mirip dengan beberapa bahasa lain yang sudah diposting.

EDIT : Sedikit lagi ( 82 bytes ), tapi sedikit lebih pintar:

SELECT k+s+k+p+k+s+u+p+u+s+k+p+u+s+u+p
FROM(SELECT'known'k,' 's,'unknown'u,'s
'p)t

EDIT 2 : Favorit saya sejauh ini, menggunakan cross-self-join dari tabel turunan ( 79 byte ):

WITH t AS(SELECT'known'a UNION SELECT'unknown')
SELECT z.a+' '+t.a+'s'FROM t,t z

EDIT 3 : Mengubah karakter pengganti dari 'x'menjadi 1, yang memungkinkan saya menghapus tanda kutip di sekitarnya dan menghemat 2 byte, karena REPLACEmelakukan konversi implisit ke string.

ReRegex , 38 byte

a/known/a as\na unas\nuna as\nuna unas

Cobalah online!

Javascript 66 54 53 50 byte

_=>` s
 uns
un s
un uns`.replace(/ |s/g,'known$&')

Sejarah

• menyimpan 12 byte berkat @someone (penggunaan eksplisit "un" di string utama)
• disimpan 1 byte berkat @ThePirateBay (split..join alih-alih ganti)
• disimpan 3 byte berkat @Neil (ganti yang lebih baik ())