Były Sekretarz Obrony USA, Donald Rumsfeld, słynnie spopularyzował frazę „znane znane”. Tutaj podzielimy jego uwagi na czteroliniową zwrotkę.

W szczególności wyślij ten tekst:

known knowns
known unknowns
unknown knowns
unknown unknowns

Wielkość liter nie ma znaczenia (na przykład Known unKnownsjest w porządku), a pojedyncza nowa linia jest akceptowalna, ale żadne inne zmiany formatowania są niedozwolone. Oznacza to pojedynczą spację między słowami i LF(59 bajtów) lub CR/LF(62 bajty) między wierszami.

Zasady

• Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je drukować.
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

Python 2 , 54 52 bajty

^{-2 bajty dzięki xnor}

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

Wypróbuj online!

Wyniki z /i %będą [[2, 2], [2, 0], [0, 2], [0, 0]]indeksami początkowymi, usuwającymi unkiedy 2, zachowując ciąg niezmieniony kiedy0

Vim 28 25 bajtów

To jest moja pierwsza odpowiedź Vima, wszelkie wskazówki dotyczące gry w golfa są mile widziane.

2iunknown ␛rsY3P2xw.+.jw.

Dziękuję Lynn za napisanie skryptu Pythona do stworzenia tej fantastycznej animacji.

Może to również być uruchomione przez V Wypróbuj online!

Również 25:

2iknown ␛rsY3pwiun␛+.+.w.

bash, 36 bajtów

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

inne rozwiązania

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

jeśli wiodący znak nowej linii i dodatkowe miejsce zostały zaakceptowane 31 bajtów:

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

05AB1E , 13 12 bajtów

Zapisano 1 bajt dzięki Erikowi Outgolferowi (unikaj zamykania łańcucha)

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

Wypróbuj online!

Wyjaśnienie

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

CJam ( 26 25 bajtów)

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

Demo online

Kartezjański produkt ["known" "unknown"]sam z siebie, a następnie każdy element łączy się spacją i sufiksem oraz nowym sznakiem.

Dzięki Erik za jednobajtowe oszczędności.

R , 52 51 50 bajtów

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

Wypróbuj online!

Zaskakująco krótkie polecenia zastępowania i drukowania sprawiają, że jest to naprawdę konkurencyjna odpowiedź R w wyzwaniu strunowym !

Nawet jeśli to jest super nudne. Teraz jest nieco bardziej interesujący i dzięki bajtowi zapisanemu dzięki J.Doe !

Zapisano kolejny bajt dzięki tej odpowiedzi, również autorstwa J.Doe!

Haskell , 60 58 53 51 bajtów

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

Wypróbuj online!

Daje listę linii, co ostatnio było dozwolone. Dzięki @firefrorefiddle za wskazanie.

-2 bajty dzięki Cole .

Wersja 58-bajtowa:

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

Wypróbuj online! Daje pojedynczy ciąg.

C # (.NET Core) , 54 bajty

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

Wypróbuj online!

Retina , 33 32 bajty

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

Wypróbuj online! Edycja: Zapisano 1 bajt dzięki @ovs. Objaśnienie: Jest to prawie trywialne podejście do używania symbolu zastępczego known, z wyjątkiem tego, że po prostu wstawiam go przed każdą spacją lub s, co oszczędza 3 4 bajty.

PHP, 55 51 47 bajtów

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

spróbuj online

Retina , 33 32 bajty

Zaoszczędzono 1 bajt przy użyciu pośredniego podejścia do drukowania od Leo.

 ¶u

knowns
u
 un
:`s 
 
m`^
un

Wypróbuj online!

Wyjaśnienie

 ¶u

Zamienia nieistniejące (tj. Puste) dane wejściowe na ciąg znaków w drugim wierszu. Ten wydaje się dość dziwny, ale te znaki są kodami rzeczy, które przechodzą między dwoma wystąpieniami known[s]w pierwszych dwóch wierszach wyniku. Przestrzeń i wysuwu wiersza są tylko siebie i ujest un.

knowns

Teraz wstawiamy knownsna każdej pozycji (tj. Na początku, na końcu i między każdą parą znaków).

u
 un

Dekodujemy u.

:s 
 

Następnie pozbywamy się sprzed spacjami, tj. W pierwszej połowie każdej linii, i wypisujemy wynik.

m`^
un

I w końcu przechodzimy undo obu linii i ponownie drukujemy wynik.

To przewyższa trywialne podejście polegające na użyciu symbolu zastępczego knownprzez 4 bajty, ale nie na bardziej efektywnej implementacji tego podejścia przez Neila .

Język programowania Szekspira , 1021 1012 993 bajtów

-19 bajtów dzięki Joe Kingowi!

,.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.

Wypróbuj online!

Perl 6 , 45 bajtów

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

Spróbuj

Rozszerzony

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

[X](…)Część generuje

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

Następnie użycie X~na nim wymusza wewnętrzne listy na Str (z powodu &infix:«~»operatora), co powoduje dodanie odstępu między wartościami.

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

Następnie do każdego dołącza się s

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

Haskell, 57 52 bajtów

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

Wypróbuj online!

APL (Dyalog) , 64 47 35 bajtów

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

Wypróbuj online!

W jaki sposób?

k←'known'- kjest"known"

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

∘.... ⍨- produkt zewnętrzny ze sobą

    {⍺,' ',⍵,'s'} - z funkcją, która formatuje argumenty jako {⍺} {⍵}s

, - rozbić tabelę produktów na wektor

⍪ - oddzielne od kolumn

Java 8, 56 55 bajtów

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

-1 bajt dzięki @SuperChafouin .

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów

Dzięki @Justin Mariner za grę w golfa jeden bajt!

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

Wypróbuj online!

Łuska , 14 bajtów

OΠṠemhw¨ṅW∫ḟωμ

Wypróbuj online!

Wyjaśnienie

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

Kod maszynowy 6502 (C64), 48 bajtów

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

Stosowanie: sys49152

Jak to działa

Sztuczka polega na użyciu „licznika pętli” dla 8 iteracji, w których bity od 7 do 1 wartości początkowej są 1dla unknown(s)i 0dla known(s)jednej iteracji. Ten licznik jest przesuwany w lewo po każdej iteracji (przesunięcie najbardziej wysuniętego w lewo bitu do flagi przenoszenia), a bit 0jest początkowo, 1więc wiemy, że skończyliśmy, gdy ostatni bit został przesunięty. W pierwszej iteracjiknown jest drukowana, ponieważ podczas wywoływania programu flaga przenoszenia jest czysta.

W każdej iteracji koniec łańcucha jest przełączany między <space>i s<newline>.

Oto skomentowana lista dezasemblacji:

         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 bajtów

Disclaimer : Nie wiedziałem, że ekspansja klamra było możliwe w ramach <...>operatora (nauczył dzięki @ Grimy „s odpowiedź !) I za pomocą sprytnego rozszerzenia trick @ NahuelFouilleul ” s niesamowite bash odpowiedź , byłem w stanie zbudować takie rozwiązanie. Z przyjemnością usunę to na ich prośbę.

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

Wypróbuj online!

Perl 5 , 42 bajtów

41 bajtów kodu + 1 dla -p.

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

Wypróbuj online!

Perl 5 , 45 bajtów

Próbowałem wymyślić alternatywę, ale nie mogłem jej skrócić ... Myślałem, że jest na tyle inny, że i tak uzasadnia dodanie.

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

Wypróbuj online!

Haskell, 71 66 56 54 bajtów

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

Dzięki @Leo za -3 bajty!

_{Uwaga: w komentarzach do pytania operator stwierdził, że zwracanie listy ciągów jest w porządku}

Wypróbuj tutaj.

Galaretka , 15 bajtów

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

Wypróbuj online!

Rubin, 53 50 bajtów

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

Partia, 66 bajtów

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

Alternatywna odpowiedź, również 66 bajtów:

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

Haxe, 71 bajtów

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

Wypróbuj online!

C (gcc) , 70 66 bajtów

Dzięki @ l4m2 za -4 bajty!

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

Wypróbuj online!

PowerShell , 46 44 bajtów

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

Wypróbuj online!

(Prawie) prosta zamiana łańcucha. Wykorzystuje podejście Neila do przycinania dwóch bajtów. Dzięki Martinowi za zwrócenie na to uwagi.

Niestety jest krótszy niż bardziej interesująca metoda krzyżowania produktów o trzy pięć trzy bajty:

PowerShell , 49 47 bajtów

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

Wypróbuj online!

T-SQL, 56 54 bajtów

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

SQL obsługuje podział wierszy wewnątrz literałów łańcuchowych, tak podobny do niektórych innych już opublikowanych języków.

EDYCJA : Nieco dłuższa ( 82 bajty ), ale nieco sprytniejsza:

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

EDYCJA 2 : Mój ulubiony do tej pory, używając łączenia krzyżowego z tabeli pochodnej ( 79 bajtów ):

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

EDYCJA 3 : Zmieniłem znak zastępujący z 'x'na 1, co pozwala mi usunąć otaczające go cudzysłowy i zapisać 2 bajty, ponieważ REPLACEdokonuje niejawnej konwersji na ciąg.

ReRegex , 38 bajtów

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

Wypróbuj online!

JavaScript 66 54 53 50 bajtów

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

Historia

• zapisano 12 bajtów dzięki @someone (jawne użycie „un” w głównym ciągu)
• zapisano 1 bajt dzięki @ThePirateBay (split..join zamiast replace)
• zapisane 3 bajty dzięki @Neil (lepiej replace ())