Der frühere US-Verteidigungsminister Donald Rumsfeld ist berühmt den Ausdruck "bekannte Bekannte" bekannt gemacht. Hier werden wir seine Bemerkungen in einer vierzeiligen Strophe zusammenfassen.

Speziell diesen Text ausgeben:

known knowns
known unknowns
unknown knowns
unknown unknowns

Die Known unKnownsGroß- und Kleinschreibung spielt keine Rolle (z. B. ist in Ordnung), und eine einzelne nachgestellte Zeile ist zulässig, andere Formatierungsänderungen sind jedoch nicht zulässig. Das bedeutet ein einzelnes Leerzeichen zwischen den Wörtern und entweder LF(59 Byte) oderCR/LF (62 Byte) zwischen den Zeilen.

Regeln

• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Standard-Schlupflöcher sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Python 2 , 54 52 Bytes

^{-2 Bytes dank xnor}

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

Probieren Sie es online!

Das Ergebnis von /und %ist, [[2, 2], [2, 0], [0, 2], [0, 0]]dass es sich um die Startindizes handelt, wobei das unWann entfernt 2wird und die Zeichenfolge unverändert bleibt, wenn0

Vim 28 25 Bytes

Dies ist meine erste Antwort von Vim. Golftipps sind willkommen.

2iunknown ␛rsY3P2xw.+.jw.

Vielen Dank an Lynn für das Schreiben des Python-Skripts , um diese fantastische Animation zu erstellen.

Dies kann auch von V Try it Online ausgeführt werden!

Auch 25:

2iknown ␛rsY3pwiun␛+.+.w.

Bash, 36 Bytes

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

andere Lösungen

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

Wenn führende Zeilenumbrüche und zusätzlicher Speicherplatz 31 Byte akzeptiert wurden:

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

05AB1E , 13 12 Bytes

Gespeichert 1 Byte dank Erik die Outgolfer (avoid Schluss string)

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

Probieren Sie es online!

Erläuterung

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

Online-Demo

Kartesisches Produkt von sich ["known" "unknown"]selbst, dann wird jedes Element mit dem Raum verbunden und mit seiner neuen Zeile versehen.

Vielen Dank an Erik für die Ein-Byte-Speicherung.

R , 52 51 50 Bytes

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

Probieren Sie es online!

Überraschend kurze Substitutions- und Druckbefehle machen dies zu einer wirklich wettbewerbsfähigen R-Antwort in einer String- Herausforderung!

Auch wenn es super langweilig ist. Etwas interessanter und mit einem Byte, das dank J.Doe gespeichert wurde !

Dank dieser Antwort ein weiteres Byte gespeichert, auch von J.Doe!

Haskell , 60 58 53 51 Bytes

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

Probieren Sie es online!

Gibt eine Liste von Zeilen aus, wie sie kürzlich zulässig waren. Vielen Dank an @firefrorefiddle für den Hinweis.

-2 bytes dank cole .

58-Byte-Version:

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

Probieren Sie es online! Ergibt eine einzelne Zeichenfolge.

C # (.NET Core) , 54 Byte

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

Probieren Sie es online!

Retina , 33 32 Bytes

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

Probieren Sie es online! Bearbeiten: 1 Byte dank @ovs gespeichert. Erläuterung: Dies ist fast der triviale Ansatz, einen Platzhalter für zu verwenden known, mit der Ausnahme, dass ich ihn hier einfach vor jedem Leerzeichen oder seinfüge, wodurch 3 bis 4 Bytes eingespart werden.

PHP, 55 51 47 Bytes

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

versuche es online

Retina , 33 32 Bytes

1 Byte mit einem Zwischendruckverfahren von Leo gespeichert.

 ¶u

knowns
u
 un
:`s 
 
m`^
un

Probieren Sie es online!

Erläuterung

 ¶u

Schaltet die nicht vorhandene (dh leere) Eingabe in die Zeichenfolge in der zweiten Zeile. Das scheint ziemlich seltsam, aber diese Zeichen sind Codes für das Material, das zwischen zwei Instanzen von known[s]in den ersten beiden Zeilen des Ergebnisses liegt. Leerzeichen und Zeilenvorschub sind nur sie selbst und sind ues auch un.

knowns

Jetzt fügen wir knownsan jeder Stelle (dh am Anfang, Ende und zwischen jedem Zeichenpaar) ein.

u
 un

Wir entschlüsseln die u.

:s 
 

Dann entfernen wir die ss vor Leerzeichen, dh die in der ersten Hälfte jeder Zeile, und geben das Ergebnis aus.

m`^
un

unZum Schluss stellen wir beide Zeilen voran und drucken das Ergebnis erneut.

Dies übertrifft den trivialen Ansatz, nur einen Platzhalter für known4 Bytes zu verwenden, jedoch nicht Neils effizientere Implementierung dieses Ansatzes.

Shakespeare Programming Language , 1021 1012 993 Bytes

-19 Bytes dank 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.

Probieren Sie es online!

Perl 6 , 45 Bytes

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

Versuch es

Erweitert

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

Das [X](…)Teil erzeugt

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

Dann mit X~auf sie die inneren Listen zu einer Str (wegen der coerces &infix:«~»Operator), der dabei einen Raum zwischen den Werten hinzufügt.

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

Dann wird jeder mit einem verbunden s

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

Haskell, 57 52 Bytes

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

Probieren Sie es online!

APL (Dyalog) , 64 47 35 Bytes

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

Probieren Sie es online!

Wie?

k←'known'- kist"known"

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

∘.... ⍨- äußeres Produkt mit sich selbst

    {⍺,' ',⍵,'s'} - mit der Funktion, die die Argumente als formatiert {⍺} {⍵}s

, - Die Produkttabelle in Vektor zerschlagen

⍪ - In Spalten trennen

Java 8, 56 55 Bytes

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

-1 Byte dank @SuperChafouin .

Erläuterung:

Probieren Sie es hier aus.

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

Vielen Dank an @Justin Mariner für das Golfen mit einem Byte!

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

Probieren Sie es online!

Schale , 14 Bytes

OΠṠemhw¨ṅW∫ḟωμ

Probieren Sie es online!

Erläuterung

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 Maschinencode (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

Online-Demo

Verwendungszweck: sys49152

Wie es funktioniert

Der Trick besteht hier darin, einen "Schleifenzähler" für 8 Iterationen zu verwenden, wobei die Bits 7 bis 1 des Anfangswerts 1für unknown(s)und 0für known(s)eine Iteration sind. Dieser Zähler wird nach jeder Iteration nach links verschoben (wobei das Bit ganz links in das Übertragsflag verschoben wird ), und das Bit 0ist anfangs 1so, dass wir wissen, dass wir fertig sind, sobald das letzte Bit herausgeschoben wurde. In der ersten Iteration knownwird gedruckt, weil beim Aufrufen des Programms das Übertragsflag gelöscht wird.

In jeder Iteration wird das Ende der Zeichenfolge zwischen <space>und umgeschaltet s<newline>.

Hier ist die kommentierte Auflistung der Demontage:

         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 : Ich war nicht klar , dass die Verstrebung Expansion innerhalb der möglich war , <...>Operator (gelernt dank @ Grimy ‚s Antwort !) Und die clevere Erweiterung Trick von @ mit NahuelFouilleul ‘ s erstaunlich bash Antwort , ich war in der Lage , diese Lösung zu bauen. Ich werde dies auf Anfrage gerne entfernen.

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

Probieren Sie es online!

Perl 5 , 42 Bytes

41 Byte Code + 1 für -p.

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

Probieren Sie es online!

Perl 5 , 45 Bytes

Ich habe versucht, eine Alternative zu finden, konnte sie aber nicht kürzer machen ... Ich dachte, sie war anders genug, um es trotzdem zu rechtfertigen, sie hinzuzufügen.

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

Probieren Sie es online!

Haskell, 71 66 56 54 Bytes

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

Danke an @Leo für -3 Bytes!

_{Hinweis: In den Kommentaren der Frage besagte der Befehl, dass das Zurückgeben einer Liste von Zeichenfolgen in Ordnung ist}

Probieren Sie es hier aus.

Gelee , 15 Bytes

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

Probieren Sie es online!

Ruby, 53 50 Bytes

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

Batch, 66 Bytes

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

Alternative Antwort, auch 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")

Probieren Sie es online!

C (gcc) , 70 66 Bytes

Danke an @ l4m2 für -4 Bytes!

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

Probieren Sie es online!

PowerShell , 46 44 Bytes

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

Probieren Sie es online!

(Fast) einfacher Stringwechsel. Verwendet Neils Ansatz zum Trimmen von zwei Bytes. Vielen Dank an Martin für den Hinweis.

Leider ist es drei mal fünf mal drei Bytes kürzer als die interessantere produktübergreifende Methode :

PowerShell , 49 47 Bytes

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

Probieren Sie es online!

T-SQL, 56 54 Bytes

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

SQL unterstützt Zeilenumbrüche in Zeichenfolgenliteralen und ähnelt damit einigen anderen bereits veröffentlichten Sprachen.

EDIT : Etwas länger ( 82 Bytes ), aber etwas schlauer:

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

BEARBEITEN 2 : Mein Favorit bisher, mit einem Cross-Self-Join aus einer abgeleiteten Tabelle ( 79 Bytes ):

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

EDIT 3 : Das Ersetzungszeichen wurde von 'x'in geändert 1, wodurch ich die Anführungszeichen entfernen und 2 Bytes sparen kann, da REPLACEeine implizite Konvertierung in einen String erfolgt.

ReRegex , 38 Bytes

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

Probieren Sie es online!

Javascript 66 54 53 50 Bytes

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

Geschichte

• 12 Bytes dank @someone eingespart (explizite Verwendung von "un" im Hauptstring)
• 1 Byte gespart dank @ThePirateBay (split..join statt replace)
• 3 Bytes gespart dank @Neil (besser ersetzen ())