Il y a des connus connus


45

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 donc toutes les règles de golf habituelles s’appliquent et le code le plus court (en octets) gagne.

1
Quelqu'un peut-il expliquer pourquoi cela a eu tant de votes négatifs? Pour moi, le défi est raisonnable et a encouragé diverses réponses dans un mélange de langues.
ElPedro

47
@ElPedro La raison derrière les nombreux votes négatifs est une inconnue connue
Wondercricket

Pouvons-nous retourner une matrice ou une liste de chaînes?
Adám

1
@ Adám Une liste de quatre chaînes serait OK, car cela préserve encore l'espace entre les mots; mais, à moins que vous ne fassiez une matrice de chaque caractère, espaces compris, les matrices ne sont pas acceptables.
AdmBorkBork

1
Les espaces de fin sont-ils intentionnels?
user202729

Réponses:


29

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


1
Si vous laissez kêtre 'unknowns', vous pouvez corriger avec k[i/3:7]et enregistrer deux octets.
xnor

27

Vim 28 25 octets

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

2iunknown ␛rsY3P2xw.+.jw.

En action

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.

J'ai seulement réussi à trouver un autre 25: 2iunknown ␛rsYPw2x2YP2xj.ou une légère variation 2iunknown ␛rsYPw2x2YPⓋjlx(= Ctrl-V).
Lynn

@ Lynn Nice, j'ai essayé Ctrl-V mais j'ai quelque chose de plus long.
H.PWiz

23

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

3
pour ceux qui se demandent quel genre de sorcellerie est-ce (comme moi): il s'agit de bash expansion brace
bolov

Encore mieux expliqué sur bash-hackers.org , et vous pouvez l' essayer en ligne! .
Dessert

En cas de doute, mettez la réponse entière dans un bloc de code
Stan Strum

reformulé, la saisie invalide à la fin
Nahuel Fouilleul

14

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

2
“Š¢—‚“->„Š¢—‚
Erik the Outgolfer

@EriktheOutgolfer: Oh oui, seulement 2 mots. Merci!
Emigna

Bahhh ... pourquoi je n'ai pas regardé en premier? Même réponse.
Magic Octopus Urn

11

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.


8

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 !

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!


6

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.


Votre version à 60 octets est en fait une version à 53 octets, car vous pouvez la supprimer unlinescar "Une liste de quatre chaînes serait OK, car cela préservera tout de même l'espace entre les mots;" (Commentaire à la question initiale).
firefrorefiddle

1
51 octets combinant votre approche avec @ PeterTaylor's
cole


5

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.



2
Vous pouvez améliorer cela en imprimant à mi
Leo

2
@Leo à l' aide que vous ne même pas besoin de l' |sapproche plus: tio.run/##K0otycxL/P@fK1shu/jQtmyF0rzsYi6rhGyu7Lz88jyu3IQ4rtK8//...
Martin Ender

5

PHP, 55 51 47 octets

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

essayez-le en ligne


Avez-vous besoin de balises d'ouverture pour les entrées php?
Josiah

@ Josias j'ai besoin de quelque chose pour imprimer le résultat; <?=est l'option la plus courte.
Titus

5

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 .


5

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!


Vous pouvez supprimer les espaces après des opérateurs multi-mots tels quethe sum of
Jo King

Vraiment? Euh, c'est beaucoup de représentations de nombres les plus courtes que je dois recalculer. Merci.
JosiahRyanW

4

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


4

Haskell, 57 52 octets

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

Essayez-le en ligne!


49 octets avec une autre sortie de liste
cole

@cole: le format de sortie est très strict, donc je pense qu'une liste de chaînes n'est pas valide.
nimi

L'autre réponse haskell le fait, semble que l'OP a accepté ce format.
Cole

4

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


33 octets (+ correction du format de sortie incorrect)
dzaima

1
@dzaima 31
Kritixi Lithos

4

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)

Ok, je dois demander ... pourquoi \r? ^^ '
Olivier Grégoire

@ OlivierGrégoire Woops ..; p
Kevin Cruijssen

1
Vous pouvez gagner un octet avecv->" s\n uns\nun s\nun uns".replaceAll(" |s","known$0")
Arnaud


3

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

3

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

3

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!


3

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.


C'est génial et je ne peux même pas le comprendre, mais la partie de votre seconde fmappeut être réduite à map(' ':):)
Leo

1
@Leo Merci! Haha, je ne suis même pas sûr de comprendre maintenant
addison

Pas besoin de donner un nom à la fonction, vous pouvez donc laisser tomber le fichier f=.
nimi



2

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

Bien sûr, les boucles imbriquées, n'y ont pas pensé… bon travail!
schnaader


2

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!


1
À l' inversef(i){for(i=8;i--;)printf("unknown%s"+(i>4|i==2)*2,i%2?" ":"s\n");}
l4m2

Suggérez au L"ੳ "+i%2lieu dei%2?" ":"s\n"
ceilingcat

2

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!



@MartinEnder Bon, bon appel. Merci!
AdmBorkBork

2

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.



1

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

1
Je pense qu'il serait plus court d'ajouter un dans la chaîne elle
quelqu'un

vous avez tout à fait raison, mais il est dommage que cette solution soit si absurde.
Brian H.

1
L'espace après la virgule est-il nécessaire?
quelqu'un

4
Utiliser split..join au lieu d' replaceenregistrer un octet.

2
Je voulais dire en supprimant le 0s et en utilisant .replace(/ |s/g,'known$&')(qui enregistre maintenant que 3 octets).
Neil
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.