L'ex segretario alla Difesa degli Stati Uniti, Donald Rumsfeld, rese famosa la frase "conosciuti". Qui andremo a distillare le sue osservazioni in una strofa a quattro righe.

In particolare, genera questo testo:

known knowns
known unknowns
unknown knowns
unknown unknowns

Le maiuscole non contano (ad esempio, Known unKnownsva bene) e una singola riga finale è accettabile, ma non sono consentite altre modifiche alla formattazione. Ciò significa un singolo spazio tra le parole e LF(59 byte) o CR/LF(62 byte) tra le righe.

Regole

• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Python 2 , 54 52 byte

^{-2 byte grazie a xnor}

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

Provalo online!

I risultati di /e %saranno [[2, 2], [2, 0], [0, 2], [0, 0]]gli indici di partenza, rimuovendo il unquando 2, mantenendo inalterata la stringa quando0

Vim 28 25 byte

Questa è la mia prima risposta Vim, tutti i consigli sul golf sono i benvenuti.

2iunknown ␛rsY3P2xw.+.jw.

Grazie Lynn per aver scritto la sceneggiatura di Python per realizzare quella fantastica animazione.

Questo può anche essere gestito da V Provalo online!

Anche 25:

2iknown ␛rsY3pwiun␛+.+.w.

bash, 36 byte

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

altre soluzioni

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 la nuova riga iniziale e lo spazio extra fossero accettati 31 byte:

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

05AB1E , 13 12 byte

Salvato 1 byte grazie a Erik the Outgolfer (evitare di chiudere la stringa)

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

Provalo online!

Spiegazione

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

Demo online

Prodotto cartesiano di ["known" "unknown"]se stesso, quindi ogni elemento unito con lo spazio e suffisso se una nuova riga.

Grazie a Erik per il salvataggio di un byte.

R , 52 51 50 byte

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

Provalo online!

I comandi di sostituzione e stampa sorprendentemente brevi rendono questa una risposta R realmente competitiva in una sfida con le stringhe !

Anche se è super noioso. Leggermente più interessante ora e con un byte salvato grazie a J.Doe !

Ho salvato un altro byte grazie a questa risposta, anche di J.Doe!

Haskell , 60 58 53 51 byte

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

Provalo online!

Produce un elenco di righe come è stato consentito di recente. Grazie a @firefrorefiddle per la segnalazione .

-2 byte grazie a Cole .

Versione a 58 byte:

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

Provalo online! Produce una singola stringa.

C # (.NET Core) , 54 byte

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

Provalo online!

Retina , 33 32 byte

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

Provalo online! Modifica: salvato 1 byte grazie a @ovs. Spiegazione: Questo è quasi l'approccio banale dell'utilizzo di un segnaposto per known, tranne che qui lo inserisco semplicemente prima di ogni spazio o s, che consente di risparmiare 3 4 byte.

PHP, 55 51 47 byte

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

provalo online

Retina , 33 32 byte

Salvato 1 byte utilizzando un approccio di stampa intermedio da Leo.

 ¶u

knowns
u
 un
:`s 
 
m`^
un

Provalo online!

Spiegazione

 ¶u

Trasforma l'input inesistente (cioè vuoto) nella stringa sulla seconda riga. Quello sembra piuttosto strano, ma questi personaggi sono codici per le cose che vanno tra due istanze delle known[s]prime due righe del risultato. Spazio e linefeed sono solo se stessi ed uè un.

knowns

Ora inseriamo knownsin ogni posizione (cioè all'inizio, alla fine e tra ogni coppia di caratteri).

u
 un

Decodifichiamo il file u.

:s 
 

Quindi eliminiamo le ss davanti agli spazi, cioè quelli nella prima metà di ogni riga, e stampiamo il risultato.

m`^
un

E infine anteponiamo una entrambe le righe e stampiamo nuovamente il risultato.

Questo batte l'approccio banale di usare solo un segnaposto per known4 byte, ma non l'implementazione più efficiente di Neil di quell'approccio.

Shakespeare Programming Language , 1021 1012 993 byte

-19 byte grazie 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.

Provalo online!

Perl 6 , 45 byte

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

Provalo

allargato

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

Quindi usare X~su di esso costringe gli elenchi interni in uno Str (a causa &infix:«~»dell'operatore), che così facendo aggiunge uno spazio tra i valori.

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

Quindi ognuno è unito con un s

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

Haskell, 57 52 byte

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

Provalo online!

APL (Dyalog) , 64 47 35 byte

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

Provalo online!

Come?

k←'known'- kè"known"

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

∘.... ⍨- prodotto esterno con se stesso

    {⍺,' ',⍵,'s'} - con la funzione che formatta gli arg come {⍺} {⍵}s

, - distruggere la tabella dei prodotti in vettoriale

⍪ - separato per colonne

Java 8, 56 55 byte

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

-1 byte grazie a @SuperChafouin .

Spiegazione:

Provalo qui.

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

Grazie a @Justin Mariner per il golf a 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");}

Provalo online!

Buccia , 14 byte

OΠṠemhw¨ṅW∫ḟωμ

Provalo online!

Spiegazione

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 codice macchina (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

Demo online

Uso: sys49152

Come funziona

Il trucco qui è usare un "contatore di loop" per 8 iterazioni in cui i bit da 7 a 1 del valore iniziale sono 1per unknown(s)e 0per known(s)in una iterazione. Questo contatore viene spostato a sinistra dopo ogni iterazione (spostando il bit più a sinistra nella bandiera carry) e il bit 0è inizialmente 1quindi sappiamo che abbiamo finito una volta spostato l'ultimo bit. Nella prima iterazione, knownviene stampato perché quando si chiama il programma, il flag carry è chiaro.

In ogni iterazione, la fine della stringa viene commutata tra <space>e s<newline>.

Ecco la lista dei disassemblaggi commentata:

         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

Diniego : Non mi rendevo conto che l'espansione doppietta era possibile all'interno <...>dell'operatore (imparato grazie a @ Grimy 's risposta !) E il utilizzando il trucco di espansione intelligente da @ NahuelFouilleul ' s sorprendente risposta bash , sono stato in grado di costruire questa soluzione. Lo rimuoverò felicemente su una delle loro richieste.

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

Provalo online!

Perl 5 , 42 byte

41 byte codice + 1 per -p.

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

Provalo online!

Perl 5 , 45 byte

Ho provato a trovare un'alternativa, ma non potevo renderla più breve ... Ho pensato che fosse abbastanza diverso da giustificare l'aggiunta comunque.

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

Provalo online!

Haskell, 71 66 56 54 byte

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

Grazie a @Leo per -3 byte!

_{Nota: nei commenti della domanda, l'operatore ha affermato che la restituzione di un elenco di stringhe va bene}

Provalo qui.

Gelatina , 15 byte

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

Provalo online!

Rubino, 53 50 byte

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

Lotto, 66 byte

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

Risposta alternativa, anche 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")

Provalo online!

C (gcc) , 70 66 byte

Grazie a @ l4m2 per -4 byte!

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

Provalo online!

PowerShell , 46 44 byte

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

Provalo online!

(Quasi) semplice sostituzione della stringa. Utilizza l'approccio di Neil per tagliare due byte. Grazie a Martin per averlo sottolineato.

Purtroppo, è più breve del più interessante metodo tra prodotti di tre cinque tre byte:

PowerShell , 49 47 byte

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

Provalo online!

T-SQL, 56 54 byte

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

SQL supporta le interruzioni di riga all'interno dei valori letterali delle stringhe, quindi simili ad alcune altre lingue già pubblicate.

EDIT : leggermente più lungo ( 82 byte ), ma un po 'più intelligente:

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 : Il mio preferito finora, usando un cross-self-join da una tabella derivata ( 79 byte ):

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

EDIT 3 : cambiato il carattere sostitutivo da 'x'a 1, il che mi consente di rimuovere le virgolette attorno a esso e di salvare 2 byte, poiché REPLACEesegue una conversione implicita in stringa.

ReRegex , 38 byte

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

Provalo online!

Javascript 66 54 53 50 byte

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

Storia

• salvato 12 byte grazie a @someone (utilizzo esplicito di "un" nella stringa principale)
• salvato 1 byte grazie a @ThePirateBay (split..join invece di sostituire)
• salvato 3 byte grazie a @Neil (meglio sostituire ())