Cựu Bộ trưởng Quốc phòng Hoa Kỳ, Donald Rumsfeld, nổi tiếng phổ biến cụm từ "được biết đến". Ở đây chúng tôi sẽ chắt lọc nhận xét của ông vào một khổ thơ bốn dòng.

Cụ thể, xuất văn bản này:

known knowns
known unknowns
unknown knowns
unknown unknowns

Viết hoa không thành vấn đề (ví dụ: Known unKnownsvẫn ổn) và một dòng mới duy nhất được chấp nhận, nhưng không được phép thay đổi định dạng khác. Điều đó có nghĩa là một khoảng trắng giữa các từ và LF(59 byte) hoặc CR/LF(62 byte) giữa các dòng.

Quy tắc

• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Python 2 , 54 52 byte

^{-2 byte nhờ xnor}

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

Hãy thử trực tuyến!

Các kết quả từ /và %sẽ là [[2, 2], [2, 0], [0, 2], [0, 0]]các chỉ mục bắt đầu, loại bỏ thời unđiểm 2, giữ cho chuỗi không bị thay đổi khi0

Vim 28 25 byte

Đây là câu trả lời Vim đầu tiên của tôi, bất kỳ lời khuyên chơi golf nào đều được chào đón.

2iunknown ␛rsY3P2xw.+.jw.

Cảm ơn bạn Lynn đã viết kịch bản python để làm cho hoạt hình tuyệt vời đó.

Điều này cũng có thể được điều hành bởi V Hãy thử trực tuyến!

Cũng 25:

2iknown ␛rsY3pwiun␛+.+.w.

bash, 36 byte

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

giải pháp khác

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

nếu dòng mới hàng đầu và không gian thêm được chấp nhận 31 byte:

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

05AB1E , 13 12 byte

Đã lưu 1 byte nhờ Erik the Outgolfer (tránh đóng chuỗi)

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

Hãy thử trực tuyến!

Giải trình

„Š¢—‚           # 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}%

Bản demo trực tuyến

Sản phẩm của Cartesian ["known" "unknown"]với chính nó, sau đó mỗi phần tử được nối với không gian và được thêm vào svà một dòng mới.

Cảm ơn Erik vì đã tiết kiệm một byte.

R , 52 51 50 byte

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

Hãy thử trực tuyến!

Đáng ngạc nhiên là các lệnh in và thay thế ngắn làm cho câu trả lời R thực sự cạnh tranh trong một thách thức chuỗi !

Ngay cả khi nó siêu nhàm chán. Bây giờ thú vị hơn một chút và với một byte được lưu nhờ vào J.Doe !

Đã lưu một byte khác nhờ câu trả lời này, cũng bởi J.Doe!

Haskell , 60 58 53 51 byte

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

Hãy thử trực tuyến!

Mang lại một danh sách các dòng như được cho phép gần đây. Cảm ơn @firefrorefiddle đã chỉ ra.

-2 byte nhờ cole .

Phiên bản 58 byte:

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

Hãy thử trực tuyến! Mang lại một chuỗi duy nhất.

C # (.NET Core) , 54 byte

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

Hãy thử trực tuyến!

Võng mạc , 33 32 byte

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

Hãy thử trực tuyến! Chỉnh sửa: Đã lưu 1 byte nhờ @ovs. Giải thích: Đây gần như là cách tiếp cận tầm thường của việc sử dụng trình giữ chỗ known, ngoại trừ ở đây tôi chỉ cần chèn nó trước mỗi không gian hoặc s, giúp tiết kiệm 3 4 byte.

PHP, 55 51 47 byte

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

thử trực tuyến

Võng mạc , 33 32 byte

Đã lưu 1 byte bằng cách sử dụng phương pháp in trung gian từ Leo.

 ¶u

knowns
u
 un
:`s 
 
m`^
un

Hãy thử trực tuyến!

Giải trình

 ¶u

Biến đầu vào không tồn tại (tức là trống) thành chuỗi trên dòng thứ hai. Cái đó có vẻ khá kỳ lạ, nhưng những ký tự này là mã cho những thứ nằm giữa hai trường hợp known[s]trên hai dòng đầu tiên của kết quả. Không gian và linefeed chỉ là chính họ và ulà un.

knowns

Bây giờ chúng tôi chèn knownsvào mọi vị trí (tức là ở đầu, cuối và giữa mỗi cặp ký tự).

u
 un

Chúng tôi giải mã u.

:s 
 

Sau đó, chúng tôi loại bỏ các ss ở phía trước khoảng trắng, tức là những người ở nửa đầu của mỗi dòng và in kết quả.

m`^
un

Và cuối cùng chúng tôi chuẩn bị uncho cả hai dòng và in lại kết quả.

Điều này đánh bại cách tiếp cận tầm thường của việc chỉ sử dụng một trình giữ chỗ cho known4 byte, nhưng không thực hiện phương pháp đó hiệu quả hơn của Neil .

Ngôn ngữ lập trình Shakespeare , 1021 1012 993 byte

-19 byte nhờ 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.

Hãy thử trực tuyến!

Perl 6 , 45 byte

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

Thử nó

Mở rộng

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

Phần [X](…)tạo ra

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

Sau đó, sử dụng X~trên nó ép các danh sách bên trong thành một Str (vì &infix:«~»toán tử), làm như vậy sẽ thêm khoảng trắng giữa các giá trị.

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

Sau đó, mỗi cái được nối với một s

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

Haskell, 57 52 byte

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

Hãy thử trực tuyến!

APL (Dyalog) , 64 47 35 byte

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

Hãy thử trực tuyến!

Làm sao?

k←'known'- klà"known"

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

∘.... ⍨- sản phẩm bên ngoài với chính nó

    {⍺,' ',⍵,'s'} - với chức năng định dạng các đối số là {⍺} {⍵}s

, - đập bảng sản phẩm vào vector

⍪ - riêng biệt với các cột

Java 8, 56 55 byte

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

-1 byte nhờ @SuperChafouin .

Giải trình:

Hãy thử nó ở đây.

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

Cảm ơn @Justin Mariner đã chơi golf một byte!

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

Hãy thử trực tuyến!

Husk , 14 byte

OΠṠemhw¨ṅW∫ḟωμ

Hãy thử trực tuyến!

Giải trình

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

Mã máy 6502 (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

Bản demo trực tuyến

Sử dụng: sys49152

Làm thế nào nó hoạt động

Mẹo ở đây là sử dụng "bộ đếm vòng lặp" cho 8 lần lặp trong đó các bit 7 đến 1 của giá trị ban đầu là 1cho unknown(s)và 0cho known(s)trong một lần lặp. Bộ đếm này được dịch chuyển sang trái sau mỗi lần lặp (chuyển bit ngoài cùng bên trái sang cờ mang theo) và bit 0ban đầu 1để chúng ta biết rằng chúng ta đã kết thúc khi bit cuối cùng được chuyển ra. Trong lần lặp đầu tiên, knownđược in vì khi gọi chương trình, cờ mang sẽ rõ ràng.

Trong mỗi lần lặp, phần cuối của chuỗi được chuyển đổi giữa <space>và s<newline>.

Dưới đây là danh sách tháo gỡ nhận xét:

         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 : Tôi không nhận ra rằng việc mở rộng cú đúp là có thể trong <...>điều hành (học nhờ @ cáu bẩn 's câu trả lời !) Và sử dụng các thủ thuật mở rộng thông minh từ @ NahuelFouilleul ' s câu trả lời bash tuyệt vời , tôi đã có thể để xây dựng giải pháp này. Tôi sẽ vui vẻ loại bỏ điều này theo yêu cầu của họ.

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

Hãy thử trực tuyến!

Perl 5 , 42 byte

Mã 41 byte + 1 cho -p.

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

Hãy thử trực tuyến!

Perl 5 , 45 byte

Đã cố gắng đưa ra một giải pháp thay thế, nhưng không thể làm cho nó ngắn hơn ... Nghĩ rằng nó đủ khác biệt để đảm bảo thêm vào.

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

Hãy thử trực tuyến!

Haskell, 71 66 56 54 byte

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

Cảm ơn @Leo cho -3 byte!

_{Lưu ý: Trong các bình luận của câu hỏi, op nói rằng trả về một danh sách các chuỗi là được}

Hãy thử nó ở đây.

Thạch , 15 byte

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

Hãy thử trực tuyến!

Ruby, 53 50 byte

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

Mẻ, 66 byte

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

Câu trả lời thay thế, cũng là 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")

Hãy thử trực tuyến!

C (gcc) , 70 66 byte

Cảm ơn @ l4m2 cho -4 byte!

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

Hãy thử trực tuyến!

PowerShell , 46 44 byte

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

Hãy thử trực tuyến!

(Hầu hết) thay thế chuỗi đơn giản. Sử dụng phương pháp của Neil để cắt hai byte. Cảm ơn Martin đã chỉ ra rằng.

Đáng buồn thay, nó ngắn hơn phương thức sản phẩm chéo thú vị hơn bởi ba năm ba byte:

PowerShell , 49 47 byte

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

Hãy thử trực tuyến!

T-SQL, 56 54 byte

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

SQL hỗ trợ ngắt dòng bên trong chuỗi ký tự, tương tự như một số ngôn ngữ khác đã được đăng.

EDIT : Hơi dài hơn một chút ( 82 byte ), nhưng thông minh hơn một chút:

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 : Yêu thích của tôi cho đến nay, bằng cách sử dụng tự tham gia chéo từ bảng dẫn xuất ( 79 byte ):

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

EDIT 3 : Đã thay đổi ký tự thay thế từ 'x'thành 1, cho phép tôi loại bỏ các trích dẫn xung quanh nó và lưu 2 byte, do REPLACEthực hiện chuyển đổi ngầm định thành chuỗi.

ReRegex , 38 byte

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

Hãy thử trực tuyến!

Javascript 66 54 53 50 byte

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

Lịch sử

• đã lưu 12 byte nhờ @someone (sử dụng rõ ràng "un" trong chuỗi chính)
• đã lưu 1 byte nhờ @ThePirateBay (split..join thay vì thay thế)
• đã lưu 3 byte nhờ @Neil (tốt hơn thay thế ())