โดนัลด์รัทมสเฟลด์อดีตรัฐมนตรีกลาโหมของสหรัฐอเมริกาซึ่งเป็นที่รู้จักอย่างแพร่หลายในวลี ที่นี่เรากำลังจะกลั่นความคิดเห็นของเขาลงในบทที่สี่บรรทัด

เอาท์พุทข้อความนี้โดยเฉพาะ:

known knowns
known unknowns
unknown knowns
unknown unknowns

การใช้อักษรตัวพิมพ์ใหญ่ไม่สำคัญ (ตัวอย่างเช่นใช้ได้Known unKnowns) และบรรทัดใหม่ต่อท้ายบรรทัดเดียวเป็นที่ยอมรับ แต่ไม่อนุญาตการเปลี่ยนแปลงการจัดรูปแบบอื่น ๆ นั่นหมายความว่ามีช่องว่างเดียวระหว่างคำและLF(59 ไบต์) หรือCR/LF(62 ไบต์) ระหว่างบรรทัด

กฎระเบียบ

• ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น หากฟังก์ชั่นคุณสามารถส่งคืนผลลัพธ์มากกว่าการพิมพ์
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟเพื่อให้ใช้กฎการเล่นกอล์ฟตามปกติทั้งหมดและรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

Python 2 , 54 52 ไบต์

^{-2 ไบต์ขอบคุณ xnor}

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

ลองออนไลน์!

ผลลัพธ์จาก/และ%จะเป็น[[2, 2], [2, 0], [0, 2], [0, 0]]ดัชนีเริ่มต้น, ลบunเวลา2, เก็บสตริงที่ไม่เปลี่ยนแปลงเมื่อ0

เป็นกลุ่ม28 25 ไบต์

นี่คือคำตอบ Vim แรกของฉันคำแนะนำการเล่นกอล์ฟ

2iunknown ␛rsY3P2xw.+.jw.

ขอขอบคุณคุณลินน์ที่เขียนสคริปต์ไพ ธ อนเพื่อสร้างแอนิเมชั่นที่ยอดเยี่ยม

สิ่งนี้สามารถเรียกใช้โดย V ลองใช้ออนไลน์!

ยัง 25:

2iknown ␛rsY3pwiun␛+.+.w.

ทุบตี, 36 ไบต์

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

โซลูชั่นอื่น ๆ

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\;"

ถ้าขึ้นบรรทัดใหม่และพื้นที่ว่างชั้นนำได้รับการยอมรับ 31 ไบต์:

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

05AB1E , 13 12 ไบต์

บันทึก 1 ไบต์ต้องขอบคุณErik the Outgolfer (หลีกเลี่ยงการปิดสตริง)

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

ลองออนไลน์!

คำอธิบาย

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

CJam ( 26 25 ไบต์)

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

การสาธิตออนไลน์

ผลิตภัณฑ์คาร์ทีเซียนของ["known" "unknown"]ตัวเองแล้วแต่ละองค์ประกอบเข้าร่วมกับพื้นที่และต่อท้ายด้วยsและขึ้นบรรทัดใหม่

ขอบคุณErikสำหรับการบันทึกหนึ่งไบต์

R , 52 51 50 ไบต์

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

ลองออนไลน์!

คำสั่งการแทนที่และการพิมพ์สั้น ๆ ที่น่าแปลกใจทำให้นี่เป็นคำตอบ R ที่แข่งขันได้จริงในความท้าทายสตริง !

แม้ว่ามันจะน่าเบื่อสุด ๆ น่าสนใจมากขึ้นในตอนนี้และด้วยการบันทึกไบต์ด้วยJ.Doe !

บันทึกอีกไบต์ด้วยคำตอบนี้โดย J.Doe!

Haskell , 60 58 53 51 ไบต์

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

ลองออนไลน์!

ให้ผลรายการของเส้นตามที่ได้รับอนุญาตเมื่อเร็ว ๆ นี้ ขอบคุณ@firefrorefiddle ที่ชี้ให้เห็น

-2 ไบต์ขอบคุณที่โคล

รุ่น 58 ไบต์:

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

ลองออนไลน์! ให้ผลลัพธ์สตริงเดี่ยว

C # (. NET Core) 54 ไบต์

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

ลองออนไลน์!

เรติน่า , 33 32 ไบต์

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

ลองออนไลน์! แก้ไข: บันทึก 1 ไบต์ขอบคุณ @ovs คำอธิบาย: นี่เป็นวิธีการที่ไม่สำคัญสำหรับการใช้ตัวยึดตำแหน่งknownยกเว้นที่นี่ฉันจะแทรกก่อนหน้าแต่ละช่องว่างหรือsซึ่งจะประหยัด3 4 ไบต์

PHP, 55 51 47 ไบต์

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

ลองออนไลน์

เรติน่า , 33 32 ไบต์

บันทึก 1 ไบต์โดยใช้วิธีการพิมพ์ระดับกลางจาก Leo

 ¶u

knowns
u
 un
:`s 
 
m`^
un

ลองออนไลน์!

คำอธิบาย

 ¶u

เปลี่ยนอินพุตที่ไม่มีอยู่ (เช่นว่างเปล่า) ให้เป็นสตริงบนบรรทัดที่สอง อันนั้นดูแปลก ๆ แต่ตัวละครเหล่านี้เป็นรหัสสำหรับสิ่งของที่อยู่ระหว่างสองอินสแตนซ์ของknown[s]ผลลัพธ์สองบรรทัดแรก พื้นที่และเลื่อนบรรทัดเป็นเพียงตัวเองและเป็นu un

knowns

ตอนนี้เราแทรกknownsทุกตำแหน่ง (เช่นที่จุดเริ่มต้นจุดสิ้นสุดและระหว่างอักขระทุกคู่)

u
 un

uเราถอดรหัส

:s 
 

จากนั้นเราก็กำจัดss ที่ด้านหน้าของช่องว่างนั่นคือในครึ่งแรกของแต่ละบรรทัดแล้วพิมพ์ผลลัพธ์

m`^
un

และในที่สุดเราก็เติมunทั้งสองบรรทัดและพิมพ์ผลลัพธ์อีกครั้ง

นี่เป็นการใช้วิธีเล็กน้อยในการใช้ตัวยึดแทนknownด้วยขนาด 4 ไบต์ แต่ไม่ใช่วิธีการที่Neil มีประสิทธิภาพมากขึ้นสำหรับวิธีการนั้น

ภาษาการเขียนโปรแกรมของเช็คสเปียร์ , 1021 1012 993 ไบต์

-19 ไบต์ขอบคุณ 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.

ลองออนไลน์!

Perl 6 , 45 ไบต์

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

ลองมัน

ขยาย

$_ = '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)

[X](…)ส่วนสร้าง

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

จากนั้นใช้X~กับมันรวมรายการด้านในเข้ากับ Str (เพราะตัว&infix:«~»ดำเนินการ) ซึ่งการทำเช่นนั้นจะเพิ่มช่องว่างระหว่างค่า

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

จากนั้นแต่ละคนจะเข้าร่วมกับ s

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

Haskell, 57 52 ไบต์

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

ลองออนไลน์!

APL (Dyalog) , 64 47 35 ไบต์

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

ลองออนไลน์!

อย่างไร?

k←'known'- kคือ"known"

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

∘.... ⍨- ผลิตภัณฑ์ด้านนอกด้วยตัวมันเอง

    {⍺,' ',⍵,'s'} - ด้วยฟังก์ชันที่จัดรูปแบบ args ดังนี้ {⍺} {⍵}s

, - ทุบโต๊ะผลิตภัณฑ์เป็นเวกเตอร์

⍪ - แยกเป็นคอลัมน์

Java 8, 56 55 ไบต์

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

-1 ขอบคุณไบต์@SuperChafouin

คำอธิบาย:

ลองที่นี่

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 ไบต์

ขอบคุณ @Justin Mariner สำหรับการเล่นกอล์ฟหนึ่งไบต์!

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

ลองออนไลน์!

Husk , 14 ไบต์

OΠṠemhw¨ṅW∫ḟωμ

ลองออนไลน์!

คำอธิบาย

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 (C64), 48 ไบต์

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

การสาธิตออนไลน์

การใช้งาน: sys49152

มันทำงานอย่างไร

เคล็ดลับที่นี่คือการใช้ "เคาน์เตอร์ห่วง" 8 ซ้ำที่บิต 7-1 ของค่าเริ่มต้นเป็น1สำหรับunknown(s)และ0สำหรับknown(s)ในการทำซ้ำ ตัวนับนี้ถูกเลื่อนไปทางซ้ายหลังจากการวนซ้ำแต่ละครั้ง (เลื่อนบิตซ้ายสุดไปยังแฟล็ก carry) และบิต0เริ่มต้น1เพื่อให้เรารู้ว่าเราเสร็จสิ้นเมื่อบิตสุดท้ายถูกเลื่อนออก ในการทำซ้ำครั้งแรกknownจะถูกพิมพ์เพราะเมื่อเรียกโปรแกรมแฟล็กการพกพาจะชัดเจน

ในแต่ละย้ำจุดสิ้นสุดของสตริงที่มีการสลับระหว่างและ<space>s<newline>

นี่คือรายการถอดแยกชิ้นส่วนที่แสดงความคิดเห็น:

         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 ไบต์

ข้อจำกัดความรับผิดชอบ : ฉันไม่ทราบว่าการขยายตัวรั้งนั้นเป็นไปได้ภายในตัว<...>ดำเนินการ (เรียนรู้จากคำตอบของ@ Grimy !) และการใช้เคล็ดลับการขยายอย่างชาญฉลาดจากคำตอบทุบตีที่น่าทึ่งของ@NahuelFouilleulฉันสามารถสร้างโซลูชันนี้ได้ ฉันจะลบสิ่งนี้อย่างมีความสุขตามคำขอของพวกเขา

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

ลองออนไลน์!

Perl 5 , 42 ไบต์

41 รหัสไบต์ + 1 -pสำหรับ

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

ลองออนไลน์!

Perl 5 , 45 ไบต์

พยายามหาทางเลือกอื่น แต่ไม่สามารถทำให้สั้นลง ... คิดว่ามันแตกต่างกันพอที่จะรับประกันการเพิ่ม

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

ลองออนไลน์!

Haskell, 71 66 56 54 ไบต์

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

ขอบคุณ@Leoสำหรับ -3 ไบต์!

_{หมายเหตุ: ในความคิดเห็นของคำถาม op บอกว่าการส่งคืนรายการสตริงนั้นไม่เป็นไร}

ลองที่นี่

เยลลี่ 15 ไบต์

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

ลองออนไลน์!

Ruby, 53 50 ไบต์

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

แบตช์ 66 ไบต์

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

คำตอบอื่น, 66 ไบต์ด้วย:

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

Haxe, 71 ไบต์

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

ลองออนไลน์!

C (gcc) , 70 66 ไบต์

ขอบคุณ @ l4m2 สำหรับ -4 ไบต์!

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

ลองออนไลน์!

PowerShell , 46 44 ไบต์

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

ลองออนไลน์!

(เกือบ) การแทนที่สตริงอย่างง่าย ใช้แนวทางของนีลในการตัดแต่งสองไบต์ ขอบคุณ Martin ที่ชี้ให้เห็นว่า

น่าเศร้าที่สั้นกว่าวิธี cross-product ที่น่าสนใจมากกว่าสาม ห้าสามไบต์:

PowerShell , 49 47 ไบต์

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

ลองออนไลน์!

T-SQL, 56 54 ไบต์

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

SQL รองรับตัวแบ่งบรรทัดภายในตัวอักษรของสตริงดังนั้นคล้ายกับภาษาอื่น ๆ ที่โพสต์แล้ว

แก้ไข : อีกต่อไปเล็กน้อย ( 82 ไบต์ ) แต่ฉลาดขึ้นอีกเล็กน้อย:

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

แก้ไข 2 : สุดโปรดของฉันโดยใช้ cross-self-join จากตารางที่ได้รับ ( 79 ไบต์ ):

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

แก้ไข 3 : เปลี่ยนอักขระแทนที่จาก'x'เป็น1ซึ่งให้ฉันลบเครื่องหมายคำพูดรอบ ๆ และบันทึก 2 ไบต์เนื่องจากREPLACEการแปลงโดยนัยเป็นสตริง

ReRegexขนาด 38 ไบต์

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

ลองออนไลน์!

Javascript 66 54 53 50 ไบต์

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

ประวัติศาสตร์

• บันทึก 12 ไบต์ด้วย @someone (การใช้ "un" ในสตริงหลักอย่างชัดเจน)
• บันทึก 1 ไบต์ขอบคุณ @ThePirateBay (แยก .. เข้าร่วมแทนการแทนที่)
• บันทึกแล้ว 3 ไบต์ด้วย @Neil (แทนที่ดีกว่า)