L'ancien secrétaire américain à la Défense, Donald Rumsfeld, a popularisé l'expression "connu, connu". Nous allons ici distiller ses remarques dans une strophe de quatre lignes.

Plus précisément, affichez ce texte:

known knowns
known unknowns
unknown knowns
unknown unknowns

La capitalisation n'a pas d'importance (par exemple, ça Known unKnownsva), et une nouvelle nouvelle ligne est acceptable, mais aucune autre modification de mise en forme n'est autorisée. Cela signifie un seul espace entre les mots et LF(59 octets) ou CR/LF(62 octets) entre les lignes.

Règles

• Un programme complet ou une fonction sont acceptables. Si une fonction est utilisée, vous pouvez renvoyer le résultat plutôt que de l’imprimer.
• Les failles standard sont interdites.
• Il s’agit du code-golf, donc toutes les règles de golf habituelles s’appliquent et le code le plus court (en octets) gagne.

Python 2 , 54 52 octets

^{-2 octets grâce à xnor}

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

Essayez-le en ligne!

Les résultats de /et %seront [[2, 2], [2, 0], [0, 2], [0, 0]]les index de départ, en supprimant les éléments unwhen 2, en conservant la chaîne inchangée lorsque0

Vim 28 25 octets

Ceci est ma première réponse à Vim, tout conseil de golf est le bienvenu.

2iunknown ␛rsY3P2xw.+.jw.

Merci Lynn d’ avoir écrit le script Python pour réaliser cette animation fantastique.

Cela peut également être géré par V Essayez-le en ligne!

Aussi 25:

2iknown ␛rsY3pwiun␛+.+.w.

bash, 36 octets

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

d'autres solutions

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 les espaces de début de ligne et les espaces supplémentaires ont été acceptés, 31 octets:

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

05AB1E , 13 12 octets

Enregistré 1 octet grâce à Erik the Outgolfer (éviter de fermer la chaîne)

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

Essayez-le en ligne!

Explication

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

CJam ( 26 à 25 octets)

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

Démo en ligne

Produit cartésien de ["known" "unknown"]avec lui-même, puis chaque élément joint à un espace et suffixe avec sune nouvelle ligne.

Merci à Erik pour une sauvegarde d'un octet.

R , 52 51 50 octets

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

Essayez-le en ligne!

Une substitution étonnamment courte et des commandes d'impression en font une réponse R réellement compétitive dans un défi de chaînes !

Même si c'est super ennuyeux. Légèrement plus intéressant maintenant, et avec un octet sauvegardé grâce à J.Doe !

J'ai sauvé un autre octet grâce à cette réponse, également de J.Doe!

Haskell , 60 58 53 51 octets

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

Essayez-le en ligne!

Donne une liste de lignes comme cela a été récemment autorisé. Merci à @firefrorefiddle pour l'avoir signalé.

-2 octets grâce à Cole .

Version de 58 octets:

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

Essayez-le en ligne! Donne une seule chaîne.

C # (.NET Core) , 54 octets

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

Essayez-le en ligne!

Retina , 33 32 octets

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

Essayez-le en ligne! Edit: 1 octet enregistré grâce à @ovs. Explication: C’est une approche presque triviale qui consiste à utiliser un espace réservé pour known, sauf que je l’insère simplement avant chaque espace ou s, ce qui permet d’économiser 3 à 4 octets.

PHP, 55 51 47 octets

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

essayez-le en ligne

Retina , 33 32 octets

Enregistré 1 octet en utilisant une approche d'impression intermédiaire de Leo.

 ¶u

knowns
u
 un
:`s 
 
m`^
un

Essayez-le en ligne!

Explication

 ¶u

Met l'entrée non-existante (c'est-à-dire vide) dans la chaîne sur la deuxième ligne. Celui-ci semble assez étrange, mais ces caractères sont des codes pour le contenu qui se situe entre deux occurrences des known[s]deux premières lignes du résultat. L'espace et le saut de ligne ne sont eux-mêmes et usont un.

knowns

Maintenant, nous insérons knownsà chaque position (c'est-à-dire au début, à la fin et entre chaque paire de caractères).

u
 un

Nous décodons le u.

:s 
 

Ensuite, on supprime les spoints situés devant les espaces, c'est-à-dire ceux situés dans la première moitié de chaque ligne, et on affiche le résultat.

m`^
un

Et finalement nous ajoutons unles deux lignes et imprimons à nouveau le résultat.

Cela bat l'approche triviale de simplement utiliser un espace réservé pour known4 octets, mais pas la mise en œuvre plus efficace de cette approche par Neil .

Shakespeare Programming Language , 1021 1012 993 octets

-19 octets grâce à 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.

Essayez-le en ligne!

Perl 6 , 45 octets

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

L'essayer

Étendu

$_ = '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](…)pièce génère

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

Ensuite, son utilisation X~convertit les listes internes en un Str (à cause de l' &infix:«~»opérateur), ce qui ajoute un espace entre les valeurs.

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

Puis chacun se joint à un s

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

Haskell, 57 52 octets

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

Essayez-le en ligne!

APL (Dyalog) , 64 47 35 octets

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

Essayez-le en ligne!

Comment?

k←'known'- kest"known"

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

∘.... ⍨- produit extérieur avec lui-même

    {⍺,' ',⍵,'s'} - avec la fonction qui formate les arguments comme {⍺} {⍵}s

, - briser la table de produits en vecteur

⍪ - séparé des colonnes

Java 8, 56 55 octets

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

-1 octet grâce à @SuperChafouin .

Explication:

Essayez ici.

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 octets

Merci à @Justin Mariner pour avoir joué un octet au golf!

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

Essayez-le en ligne!

Husk , 14 octets

OΠṠemhw¨ṅW∫ḟωμ

Essayez-le en ligne!

Explication

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 code machine (C64), 48 octets

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

Démo en ligne

Usage: sys49152

Comment ça marche

L'astuce consiste ici à utiliser un "compteur de boucle" pour 8 itérations où les bits 7 à 1 de la valeur initiale sont 1pour unknown(s)et 0pour known(s)une itération. Ce compteur est décalé vers la gauche après chaque itération (en déplaçant le bit le plus à gauche dans l'indicateur de report) et le bit 0est initialement 1indiqué pour que nous sachions que nous avons terminé une fois que le dernier bit a été décalé. À la première itération, knownest imprimé car lors de l’appel du programme, le drapeau de report est dégagé.

A chaque itération, la fin de la chaîne est basculée entre <space>et s<newline>.

Voici la liste de désassemblage commentée:

         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 octets

Avertissement : Je ne savais pas que l' expansion de hauban a été possible au sein de l' <...>opérateur (appris grâce à @ Grimy 's réponse !) Et en utilisant l'astuce d'expansion intelligente de @ NahuelFouilleul est bash étonnante réponse , je suis en mesure de construire cette solution. Je supprimerai volontiers ceci à l'une ou l'autre de leurs demandes.

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

Essayez-le en ligne!

Perl 5 , 42 octets

Code de 41 octets + 1 pour -p.

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

Essayez-le en ligne!

Perl 5 , 45 octets

J'ai essayé de trouver une alternative, mais je ne pouvais pas la raccourcir ... Je pensais que c'était assez différent pour justifier l'ajout de toute façon.

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

Essayez-le en ligne!

Haskell, 71 66 56 54 octets

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

Merci à @Leo pour -3 octets!

_{Remarque: dans les commentaires de la question, le responsable de l'opération a déclaré qu'il est acceptable de renvoyer une liste de chaînes.}

Essayez ici.

Gelée , 15 octets

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

Essayez-le en ligne!

Ruby, 53 50 octets

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

Lot, 66 octets

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

Réponse alternative, également 66 octets:

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

Haxe, 71 octets

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

Essayez-le en ligne!

C (gcc) , 70 à 66 octets

Merci à @ l4m2 pour -4 octets!

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

Essayez-le en ligne!

PowerShell , 46 44 octets

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

Essayez-le en ligne!

(Presque) remplacement de chaîne simple. Utilise l'approche de Neil pour couper deux octets. Merci à Martin pour l'avoir signalé.

Malheureusement, il est plus court que la méthode plus intéressante de produits croisés de trois cinq trois octets:

PowerShell , 49 à 47 octets

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

Essayez-le en ligne!

T-SQL, 56 54 octets

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

SQL prend en charge les sauts de ligne dans les littéraux de chaîne, si semblables à d'autres langues déjà publiées.

EDIT : légèrement plus long ( 82 octets ), mais un peu plus intelligent:

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 : Mon préféré jusqu'à présent, en utilisant une auto-jointure croisée à partir d'une table dérivée ( 79 octets ):

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

EDIT 3 : Changement du caractère de remplacement de 'x'à 1, ce qui me permet de supprimer les guillemets et de sauvegarder 2 octets, car REPLACEune conversion implicite en chaîne.

ReRegex , 38 octets

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

Essayez-le en ligne!

Javascript 66 54 53 50 octets

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

Histoire

• enregistré 12 octets grâce à @soneone (utilisation explicite de "un" dans la chaîne principale)
• enregistré 1 octet grâce à @ThePirateBay (split..join au lieu de remplacer)
• 3 octets sauvés grâce à @Neil (remplacez ())