O ex-secretário de Defesa dos EUA, Donald Rumsfeld, famosa popularizou a frase "knowns conhecidos." Aqui vamos destilar seus comentários em uma estrofe de quatro linhas.

Especificamente, imprima este texto:

known knowns
known unknowns
unknown knowns
unknown unknowns

Letras maiúsculas não importam (por exemplo, Known unKnownsé bom), e uma única nova linha à direita é aceitável, mas nenhuma outra alteração de formatação é permitida. Isso significa um espaço único entre as palavras e LF(59 bytes) ou CR/LF(62 bytes) entre as linhas.

Regras

• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Python 2 , 54 52 bytes

^{-2 bytes graças ao xnor}

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

Experimente online!

Os resultados de /e %serão [[2, 2], [2, 0], [0, 2], [0, 0]]os índices iniciais, removendo o unwhen 2, mantendo a string inalterada quando0

Vim 28 25 bytes

Esta é a minha primeira resposta Vim, todas as dicas de golfe são bem-vindas.

2iunknown ␛rsY3P2xw.+.jw.

Obrigado Lynn por escrever o script python para fazer essa animação fantástica.

Isso também pode ser executado pelo V Experimente Online!

Também 25:

2iknown ␛rsY3pwiun␛+.+.w.

bash, 36 bytes

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

outras soluções

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

se nova linha inicial e espaço extra foram aceitos 31 bytes:

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

05AB1E , 13 12 bytes

Economizou 1 byte graças a Erik, o Outgolfer (evite fechar a corda)

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

Experimente online!

Explicação

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

CJam ( 26 25 bytes)

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

Demonstração online

Produto cartesiano de ["known" "unknown"]si mesmo, então cada elemento se juntava ao espaço e com o sufixo se uma nova linha.

Agradecemos a Erik pela economia de um byte.

R , 52 51 50 bytes

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

Experimente online!

Os comandos surpreendentemente curtos de substituição e impressão fazem desta uma resposta R realmente competitiva em um desafio de string !

Mesmo que seja super chato. Um pouco mais interessante agora, e com um byte salvo graças ao J.Doe !

Salvo outro byte, graças a esta resposta, também por J.Doe!

Haskell , 60 58 53 51 bytes

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

Experimente online!

Rende uma lista de linhas como foi permitido recentemente. Obrigado a @firefrorefiddle por apontar.

-2 bytes graças a cole .

Versão de 58 bytes:

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

Experimente online! Rende uma única sequência.

C # (.NET Core) , 54 bytes

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

Experimente online!

Retina , 33 32 bytes

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

Experimente online! Editar: salvou 1 byte graças a @ovs. Explicação: Essa é quase a abordagem trivial do uso de um espaço reservado para known, exceto aqui, basta inseri-lo antes de cada espaço ou s, o que economiza 3 4 bytes.

PHP, 55 51 47 bytes

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

experimente online

Retina , 33 32 bytes

Economizou 1 byte usando uma abordagem de impressão intermediária da Leo.

 ¶u

knowns
u
 un
:`s 
 
m`^
un

Experimente online!

Explicação

 ¶u

Transforma a entrada inexistente (ou seja, vazia) na string na segunda linha. Essa parece bastante estranha, mas esses caracteres são códigos para as coisas que vão entre duas instâncias das known[s]duas primeiras linhas do resultado. Espaço e avanço de linha são apenas eles mesmos e usão un.

knowns

Agora inserimos knownsem todas as posições (ou seja, no começo, no final e entre cada par de caracteres).

u
 un

Decodificamos o u.

:s 
 

Então nos livramos dos ss na frente dos espaços, ou seja, aqueles na primeira metade de cada linha, e imprimimos o resultado.

m`^
un

E finalmente anexamos as unduas linhas e imprimimos o resultado novamente.

Isso supera a abordagem trivial de apenas usar um espaço reservado knownpor 4 bytes, mas não a implementação mais eficiente de Neil dessa abordagem.

Linguagem de programação de Shakespeare , 1021 1012 993 bytes

-19 bytes graças a 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.

Experimente online!

Perl 6 , 45 bytes

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

Tente

Expandido

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

A [X](…)peça gera

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

Em seguida, usá X~-lo coage as listas internas em um Str (por causa do &infix:«~»operador), o que adiciona um espaço entre os valores.

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

Em seguida, cada um é unido a um s

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

Haskell, 57 52 bytes

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

Experimente online!

APL (Dyalog) , 64 47 35 bytes

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

Experimente online!

Quão?

k←'known'- ké"known"

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

∘.... ⍨- produto externo consigo mesmo

    {⍺,' ',⍵,'s'} - com a função que formata os argumentos como {⍺} {⍵}s

, - esmagar a tabela do produto em vetor

⍪ - separado para colunas

Java 8, 56 55 bytes

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

-1 byte graças a @SuperChafouin .

Explicação:

Experimente aqui.

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 bytes

Obrigado a Justin Mariner por jogar um byte!

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

Experimente online!

Casca , 14 bytes

OΠṠemhw¨ṅW∫ḟωμ

Experimente online!

Explicação

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

Código da máquina 6502 (C64), 48 bytes

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

Demonstração online

Uso: sys49152

Como funciona

O truque aqui é usar um "contador de loop" para 8 iterações em que os bits 7 a 1 do valor inicial são 1para unknown(s)e 0para known(s)em uma iteração. Esse contador é deslocado para a esquerda após cada iteração (colocando o bit mais à esquerda no sinalizador de transporte) e o bit 0é inicialmente, 1para que saibamos que terminamos assim que o último bit foi deslocado. Na primeira iteração, knowné impresso porque, ao chamar o programa, o sinalizador de transporte fica limpo.

Em cada iteração, o final da sequência é alternado entre <space>e s<newline>.

Aqui está a lista de desmontagem comentada:

         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 bytes

Disclaimer : Eu não percebi que a expansão cinta era possível dentro do <...>operador (aprendi graças a @ Grimy 's resposta !) Eo usando o truque de expansão inteligente de @ NahuelFouilleul ' s resposta festa incrível , eu era capaz de construir esta solução. É com satisfação que removerei isso a qualquer um dos pedidos deles.

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

Experimente online!

Perl 5 , 42 bytes

Código de 41 bytes + 1 para -p.

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

Experimente online!

Perl 5 , 45 bytes

Tentou encontrar uma alternativa, mas não conseguiu reduzi-la ... Pensei que fosse diferente o suficiente para justificar a adição de qualquer maneira.

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

Experimente online!

Haskell, 71 66 56 54 bytes

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

Graças a @Leo por -3 bytes!

_{Nota: Nos comentários da pergunta, o op disse que retornar uma lista de strings é bom}

Experimente aqui.

Gelatina , 15 bytes

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

Experimente online!

Ruby, 53 50 bytes

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

Lote, 66 bytes

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

Resposta alternativa, também 66 bytes:

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

Haxe, 71 bytes

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

Experimente online!

C (gcc) , 70 66 bytes

Obrigado a @ l4m2 por -4 bytes!

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

Experimente online!

PowerShell , 46 44 bytes

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

Experimente online!

(Quase) simples substituição de string. Usa a abordagem de Neil para aparar dois bytes. Obrigado a Martin por apontar isso.

Infelizmente, é mais curto que o método de produto cruzado mais interessante em três cinco três bytes:

PowerShell , 49 47 bytes

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

Experimente online!

T-SQL, 56 54 bytes

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

O SQL suporta quebras de linha dentro de literais de seqüência de caracteres, tão semelhantes a outros idiomas já publicados.

EDIT : ligeiramente mais longo ( 82 bytes ), mas um pouco mais inteligente:

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 : Meu favorito até agora, usando uma junção cruzada de uma tabela derivada ( 79 bytes ):

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

EDIT 3 : Alterou o caractere de substituição de 'x'para 1, o que me permite remover as aspas e salvar 2 bytes, pois REPLACEfaz uma conversão implícita em string.

ReRegex , 38 bytes

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

Experimente online!

Javascript 66 54 53 50 bytes

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

História

• economizou 12 bytes graças a @someone (uso explícito de "un" na string principal)
• economizou 1 byte graças a @ThePirateBay (split..join em vez de substituir)
• economizou 3 bytes graças a @Neil (melhor substituir ())