El ex secretario de Defensa estadounidense, Donald Rumsfeld, famoso popularizó la frase "conocidos conocidos". Aquí vamos a destilar sus comentarios en una estrofa de cuatro líneas.

Específicamente, envíe este texto:

known knowns
known unknowns
unknown knowns
unknown unknowns

La capitalización no importa (por ejemplo, Known unKnownsestá bien), y una nueva línea final es aceptable, pero no se permiten otros cambios de formato. Eso significa un espacio único entre las palabras, y LF(59 bytes) o CR/LF(62 bytes) entre las líneas.

Reglas

• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf y gana el código más corto (en bytes).

Python 2 , 54 52 bytes

^{-2 bytes gracias a xnor}

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

Pruébalo en línea!

Los resultados de /y %serán [[2, 2], [2, 0], [0, 2], [0, 0]]los índices iniciales, eliminando el uncuándo 2, manteniendo la cadena inalterada cuando0

Vim 28 25 bytes

Esta es mi primera respuesta de Vim, cualquier consejo de golf es bienvenido.

2iunknown ␛rsY3P2xw.+.jw.

Gracias Lynn por escribir el script de Python para hacer esa animación fantástica.

Esto también puede ser ejecutado por V ¡ Pruébelo en línea!

También 25:

2iknown ␛rsY3pwiun␛+.+.w.

bash, 36 bytes

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

otras soluciones

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

si la nueva línea inicial y el espacio adicional se aceptaran 31 bytes:

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

05AB1E , 13 12 bytes

Guardado 1 byte gracias a Erik the Outgolfer (evita cerrar cadena)

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

Pruébalo en línea!

Explicación

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

Demostración en línea

Producto cartesiano de ["known" "unknown"]sí mismo, luego cada elemento se unió con espacio y sufijo con suna nueva línea.

Gracias a Erik por un ahorro de un byte.

R , 52 51 50 bytes

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

Pruébalo en línea!

Sorprendentemente cortos comandos de sustitución e impresión hacen de esta una respuesta R realmente competitiva en un desafío de cadena

Incluso si es súper aburrido. Un poco más interesante ahora, y con un byte guardado gracias a J.Doe !

¡Ahorré otro byte gracias a esta respuesta, también de J.Doe!

Haskell , 60 58 53 51 bytes

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

Pruébalo en línea!

Produce una lista de líneas como se permitió recientemente. Gracias a @firefrorefiddle por señalarlo.

-2 bytes gracias a cole .

Versión de 58 bytes:

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

Pruébalo en línea! Produce una sola cuerda.

C # (.NET Core) , 54 bytes

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

Pruébalo en línea!

Retina , 33 32 bytes

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

Pruébalo en línea! Editar: Guardado 1 byte gracias a @ovs. Explicación: Este es casi el enfoque trivial de usar un marcador de posición known, excepto que aquí simplemente lo inserto antes de cada espacio o s, lo que ahorra 3 4 bytes.

PHP, 55 51 47 bytes

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

pruébalo en línea

Retina , 33 32 bytes

Se guardó 1 byte con un enfoque de impresión intermedio de Leo.

 ¶u

knowns
u
 un
:`s 
 
m`^
un

Pruébalo en línea!

Explicación

 ¶u

Convierte la entrada inexistente (es decir, vacía) en la cadena en la segunda línea. Ese parece bastante extraño, pero estos personajes son códigos para las cosas que van entre dos instancias known[s]en las dos primeras líneas del resultado. El espacio y el salto de línea son solo ellos mismos y lo uson un.

knowns

Ahora insertamos knownsen cada posición (es decir, al principio, al final y entre cada par de caracteres).

u
 un

Decodificamos el u.

:s 
 

Luego nos deshacemos de la ss delante de los espacios, es decir, los de la primera mitad de cada línea, e imprimimos el resultado.

m`^
un

Y finalmente anteponemos unambas líneas e imprimimos el resultado nuevamente.

Esto supera el enfoque trivial de solo usar un marcador de posición knownpor 4 bytes, pero no la implementación más eficiente de ese enfoque por parte de Neil .

Lenguaje de programación Shakespeare , 1021 1012 993 bytes

-19 bytes gracias 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.

Pruébalo en línea!

Perl 6 , 45 bytes

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

Intentalo

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)

La [X](…)parte genera

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

Luego, usarlo X~coacciona las listas internas en un Str (debido al &infix:«~»operador), que al hacerlo agrega un espacio entre los valores.

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

Entonces cada uno se une con un s

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

Haskell, 57 52 bytes

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

Pruébalo en línea!

APL (Dyalog) , 64 47 35 bytes

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

Pruébalo en línea!

¿Cómo?

k←'known'- kes"known"

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

∘.... ⍨- producto externo consigo mismo

    {⍺,' ',⍵,'s'} - con la función que formatea los argumentos como {⍺} {⍵}s

, - aplastar la tabla de productos en vector

⍪ - separado a columnas

Java 8, 56 55 bytes

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

-1 byte gracias a @SuperChafouin .

Explicación:

Pruébalo aquí

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

¡Gracias a @Justin Mariner por jugar al golf un byte!

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

Pruébalo en línea!

Casco , 14 bytes

OΠṠemhw¨ṅW∫ḟωμ

Pruébalo en línea!

Explicación

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 código máquina (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

Demostración en línea

Uso: sys49152

Cómo funciona

El truco aquí es usar un "contador de bucles" para 8 iteraciones donde los bits 7 a 1 del valor inicial son 1para unknown(s)y 0para known(s)en una iteración. Este contador se desplaza hacia la izquierda después de cada iteración (desplazando el bit más a la izquierda hacia el indicador de acarreo) y el bit 0es inicialmente, 1por lo que sabemos que hemos terminado una vez que se desplazó el último bit. En la primera iteración, knownse imprime porque al llamar al programa, el indicador de acarreo está claro.

En cada iteración, el final de la cadena se alterna entre <space>y s<newline>.

Aquí está el listado de desmontaje comentado:

         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

Descargo de responsabilidad : no me di cuenta de que era posible la expansión de llaves dentro del <...>operador (¡aprendí gracias a la respuesta de @ Grimy !) Y al usar el ingenioso truco de expansión de la sorprendente respuesta de @ NahuelFouilleul , pude construir esta solución. Felizmente eliminaré esto a cualquiera de sus solicitudes.

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

Pruébalo en línea!

Perl 5 , 42 bytes

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

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

Pruébalo en línea!

Perl 5 , 45 bytes

Intenté encontrar una alternativa, pero no pude hacerlo más corto ... Pensé que era lo suficientemente diferente como para justificar la adición de todos modos.

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

Pruébalo en línea!

Haskell, 71 66 56 54 bytes

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

¡Gracias a @Leo por -3 bytes!

_{Nota: En los comentarios de la pregunta, el operador dijo que devolver una lista de cadenas está bien}

Pruébalo aquí

Jalea , 15 bytes

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

Pruébalo en línea!

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

Respuesta alternativa, también 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")

Pruébalo en línea!

C (gcc) , 70 66 bytes

¡Gracias a @ l4m2 por -4 bytes!

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

Pruébalo en línea!

PowerShell , 46 44 bytes

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

Pruébalo en línea!

(Casi) simple reemplazo de cadena. Utiliza el enfoque de Neil para recortar dos bytes. Gracias a Martin por señalar eso.

Lamentablemente, es más corto que el método de productos cruzados más interesante en tres cinco tres bytes:

PowerShell , 49 47 bytes

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

Pruébalo en línea!

T-SQL, 56 54 bytes

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

SQL admite saltos de línea dentro de literales de cadena, de manera similar a algunos otros idiomas ya publicados.

EDITAR : Ligeramente más largo ( 82 bytes ), pero un poco más 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 : Mi favorito hasta ahora, usando una unión cruzada de una tabla derivada ( 79 bytes ):

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

EDITAR 3 : Cambió el carácter de reemplazo de 'x'a 1, lo que me permite eliminar las comillas a su alrededor y guardar 2 bytes, ya que REPLACEhace una conversión implícita a cadena.

ReRegex , 38 bytes

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

Pruébalo en línea!

Javascript 66 54 53 50 bytes

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

Historia

• guardado 12 bytes gracias a @someone (uso explícito de "un" en la cadena principal)
• guardado 1 byte gracias a @ThePirateBay (dividir ... unirse en lugar de reemplazar)
• guardado 3 bytes gracias a @Neil (mejor reemplazar ())