도널드 럼스펠드 전 미 국방 장관은 "알려진 기지"라는 문구를 유명하게 만들었다 . 여기서 우리는 그의 말을 4 줄의 스탠자로 증류 할 것입니다.

구체적으로 다음 텍스트를 출력하십시오.

known knowns
known unknowns
unknown knowns
unknown unknowns

대문자는 중요하지 않으며 (예를 들어, Known unKnowns괜찮음) 단일 후행 줄 바꿈은 허용되지만 다른 형식 변경은 허용되지 않습니다. 이는 단어 사이의 단일 공백과 행 사이의 LF(59 바이트) 또는 CR/LF(62 바이트)를 의미합니다.

규칙

• 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

파이썬 2 , 54 52 바이트

^{xnor 덕분에 -2 바이트}

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

Vim 28 25 바이트

이것은 나의 첫번째 Vim 답변이며, 골프 팁은 환영합니다.

2iunknown ␛rsY3P2xw.+.jw.

환상적인 애니메이션을 만들기 위해 Python 스크립트 를 작성 해준 Lynn 에게 감사합니다 .

이것은 V Try it Online으로 도 실행할 수 있습니다 !

또한 25 :

2iknown ␛rsY3pwiun␛+.+.w.

bash, 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 바이트

Outgolfer Erik 덕분에 1 바이트 절약 (닫는 문자열을 피하십시오)

„Š¢—‚#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개행 문자로 연결됩니다.

1 바이트 절약을위한 Erik 에게 감사합니다 .

R , 52 51 50 바이트

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

온라인으로 사용해보십시오!

놀랍게도 짧은 대체 및 인쇄 명령 은 문자열 도전 에서 실제로 경쟁력있는 R 답변을 만듭니다 !

매우 지루한 경우에도 마찬가지입니다. J.Doe 덕분에 약간 더 재미 있고 바이트가 절약 되었습니다 !

이 답변 덕분에 또 다른 바이트 를 절약했으며 J.Doe!

하스켈 , 60 58 53 51 바이트

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

온라인으로 사용해보십시오!

최근에 허용 된 줄 목록을 나타냅니다. 지적 해 주신 @firefrorefiddle 에게 감사드립니다 .

cole 덕분에 -2 바이트 .

58 바이트 버전 :

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

온라인으로 사용해보십시오! 단일 문자열을 나타냅니다.

C # (. NET 코어) , 54 바이트

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

온라인으로 사용해보십시오!

레티 나 , 33 32 바이트

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

온라인으로 사용해보십시오! 편집 : @ovs 덕분에 1 바이트가 절약되었습니다. 설명 : 이것은 known각 공간 앞에 또는를 삽입하여 3 4 바이트 s를 절약 한다는 점을 제외하고는에 대한 자리 표시자를 사용하는 거의 사소한 접근 방식입니다 .

PHP, 55 51 47 바이트

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

온라인으로 사용해보십시오

레티 나 , 33 32 바이트

Leo의 중간 인쇄 방식을 사용하여 1 바이트를 절약했습니다.

 ¶u

knowns
u
 un
:`s 
 
m`^
un

온라인으로 사용해보십시오!

설명

 ¶u

존재하지 않는 (즉, 비어있는) 입력을 두 번째 줄의 문자열로 바꿉니다. 그 문자는 꽤 이상해 보이지만이 문자는 결과의 첫 두 줄에있는 두 인스턴스 사이 에있는 코드입니다 known[s]. 공간과 줄 바꿈은 그 자체 u입니다 un.

knowns

이제 knowns모든 위치 (즉, 시작, 끝 및 모든 문자 쌍 사이)에 삽입합니다.

u
 un

우리는를 해독합니다 u.

:s 
 

그런 다음 s공백 앞에서 s를 제거 합니다. 즉, 각 줄의 첫 번째 절반 에있는 s를 제거 하고 결과를 인쇄합니다.

m`^
un

마지막 un으로 두 줄을 모두 추가 하고 결과를 다시 인쇄합니다.

이것은 자리 표시자를 4 바이트 만 사용하는 사소한 접근 방식 을 능가 known하지만 Neil의 더 효율적인 접근 방식은 아닙니다 .

셰익스피어 프로그래밍 언어 , 1021 1012 993 바이트

Joe King 덕분에 -19 바이트!

,.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.

온라인으로 사용해보십시오!

펄 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

하스켈, 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'} -인수를 다음과 같이 형식화하는 기능 {⍺} {⍵}s

, -제품 테이블을 벡터로 분쇄

⍪ -열로 분리

자바 8, 56 55 바이트

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

@SuperChafouin 덕분에 -1 바이트 .

설명:

여기에서 시도하십시오.

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 바이트

1 바이트 골프를위한 @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");}

온라인으로 사용해보십시오!

껍질 , 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

작동 원리

여기 트릭 초기 값의 1 비트 7은 8 번 반복하는 "루프 카운터"를 사용하는 것이다 1위해 unknown(s)및 0위해 known(s)하나의 반복이다. 이 카운터는 각 반복 후에 왼쪽으로 이동하고 (가장 왼쪽 비트를 캐리 플래그로 이동) 비트 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

펄 5 , 33 바이트

면책 조항 : 나는 중괄호 확장이 내 가능 몰랐어요 <...>(@ 덕분에 배운 운영자 검댕으로 더럽혀진 의 대답을 !)와 @의 영리한 확장 트릭을 사용하여 NahuelFouilleul 의 놀라운 bash는 대답을 ,이 솔루션을 구축 할 수 있었다. 나는 그들의 요청 중 하나를 기쁘게 생각합니다.

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

온라인으로 사용해보십시오!

펄 5 , 42 바이트

41 바이트 코드 + 1 -p.

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

온라인으로 사용해보십시오!

펄 5 , 45 바이트

대안을 생각해 보았지만 더 짧게 만들 수는 없었습니다.

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

온라인으로 사용해보십시오!

하스켈, 71 66 56 54 바이트

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

-3 바이트의 @Leo 에게 감사 합니다!

_{참고 : 질문의 의견에서 op는 문자열 목록을 반환하는 것이 좋습니다}

여기에서 시도하십시오.

젤리 , 15 바이트

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

온라인으로 사용해보십시오!

루비, 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 바이트

-4 바이트에 대한 @ l4m2 덕분에!

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$&'

온라인으로 사용해보십시오!

(거의) 간단한 문자열 교체. Neil의 접근 방식 을 사용 하여 2 바이트를 자릅니다. 지적 해 주신 Martin에게 감사합니다.

안타깝게도이 방법은 3 개의 5 3 바이트만큼 더 흥미로운 교차 곱 방법보다 짧습니다 .

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 : 파생 테이블에서 크로스 셀프 조인 ( 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

온라인으로 사용해보십시오!

자바 스크립트 66 54 53 50 바이트

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

역사

• @someone 덕분에 12 바이트를 절약했습니다 (메인 문자열에서 "un"을 명시 적으로 사용함)
• @ThePirateBay 덕분에 1 바이트를 절약했습니다 (바꾸기 대신 split..join)
• @Neil 덕분에 3 바이트를 절약했습니다 (더 나은 replace ())