Znane są znane

45

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 więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).
AdmBorkBork
źródło
1
Czy ktoś może wyjaśnić, dlaczego ma tak wiele głosów negatywnych? Dla mnie jest to rozsądne wyzwanie i zachęca do wielu odpowiedzi w różnych językach.
ElPedro
47
@ElPedro Powodem wielu negatywnych opinii jest znana nieznana
Wondercricket
Czy możemy zwrócić macierz lub listę ciągów?
Adám
1
@ Adám Lista czterech ciągów znaków byłaby OK, ponieważ nadal zachowuje odstęp między słowami; ale jeśli nie robisz macierzy dla każdego znaku, w tym spacji, macierze nie są w porządku.
AdmBorkBork
1
Czy końcowe spacje są zamierzone?
user202729,

Odpowiedzi:

29

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

Pręt
źródło
1
Jeżeli pozwalają kbyć 'unknowns'można skorygować ze k[i/3:7]i zapisać dwa bajty.
xnor
27

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.

In action

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.
H.PWiz
źródło
Udało mi się znaleźć tylko 25: 2iunknown ␛rsYPw2x2YP2xj.lub niewielką wariację 2iunknown ␛rsYPw2x2YPⓋjlx(Ⓥ = Ctrl-V).
Lynn
@ Lynn Nice, próbowałem Ctrl-V, ale dostałem coś dłużej.
H.PWiz
23

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
Nahuel Fouilleul
źródło
3
dla tych, którzy zastanawiają się, co to za czary (jak ja): jest to rozszerzenie nawiasów klamrowych
bolov
… Jeszcze lepiej wyjaśnione na bash-hackers.org , i możesz wypróbować online! .
deser
W razie wątpliwości umieść całą odpowiedź w bloku kodu
Stan Strum,
przeredagowano, niepoprawne dane wejściowe na końcu
Nahuel Fouilleul
14

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
Emigna
źródło
2
“Š¢—‚“->„Š¢—‚
Erik the Outgolfer
@EriktheOutgolfer: O tak, tylko 2 słowa. Dzięki!
Emigna
Bahhh ... dlaczego nie spojrzałem pierwszy? Ta sama odpowiedź
Magic Octopus Urn
11

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.

Peter Taylor
źródło
8

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 !

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!

Giuseppe
źródło
6

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.

Laikoni
źródło
Twoja 60-bajtowa wersja jest w rzeczywistości 53-bajtową wersją, ponieważ można ją usunąć, unlinesponieważ „Lista czterech ciągów byłaby OK, ponieważ nadal zachowuje się odstęp między słowami;” (Komentarz do pierwotnego pytania).
firefrorefiddle
1
51 bajtów łączących twoje podejście z @ PeterTaylor's
cole
5

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.

Neil
źródło
32 bajty
ovs
2
Możesz to poprawić, drukując w połowie
Leo
2
@Leo używając tego, że nie potrzebujesz już tego |spodejścia: tio.run/##K0otycxL/P@fK1shu/jQtmyF0rzsYi6rhGyu7Lz88jyu3IQ4rtK8//…
Martin Ender
5

PHP, 55 51 47 bajtów

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

spróbuj online

Tytus
źródło
Czy potrzebujesz tagów otwierających dla wpisów php?
Josiah
@Josiah Potrzebuję czegoś, aby wydrukować wynik; <?=jest najkrótszą opcją.
Tytus,
5

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 .

Martin Ender
źródło
5

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!

JosiahRyanW
źródło
Usuwasz spacje po kilku operatorach wielu słów, takich jakthe sum of
Jo King,
Naprawdę? Huh, to wiele najkrótszych reprezentacji liczb, które muszę przeliczyć. Dzięki.
JosiahRyanW
4

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
Brad Gilbert b2gills
źródło
41 bajtów
Jo King,
4

Haskell, 57 52 bajtów

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

Wypróbuj online!

nimi
źródło
49 bajtów z alternatywnym wyjściem listy
cole
@cole: format wyjściowy jest bardzo ścisły, więc uważam, że lista ciągów znaków jest niepoprawna.
nimi
druga odpowiedź haskell to robi, wydaje się, że OP zaakceptował ten format.
cole
4

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

Uriel
źródło
33 bajty (+ naprawianie złego formatu wyjściowego)
dzaima
1
@dzaima 31
Kritixi Lithos
4

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)
Kevin Cruijssen
źródło
Okej, muszę zapytać ... dlaczego \r? ^^ '
Olivier Grégoire
@ OlivierGrégoire Woops ..; p
Kevin Cruijssen
1
Możesz wygrać jeden bajt za pomocąv->" s\n uns\nun s\nun uns".replaceAll(" |s","known$0")
Arnaud
4

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!

Steadybox
źródło
Myślę, że może to być o jeden bajt mniej, jeśli użyjesz %1$si pozbędziesz się i: Wypróbuj online!
Justin Mariner
3

Ł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
Lew
źródło
3

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
Felix Palmen
źródło
3

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!

Dom Hastings
źródło
3

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.

Addison
źródło
To jest świetne i nawet tego nie rozumiem, ale część z drugiej strony fmapmożna skrócić do map(' ':):)
Leo
1
@Leo Dzięki! Haha, nie jestem nawet pewien, czy już to rozumiem
addison
Nie musisz nadawać tej funkcji nazwy, abyś mógł ją upuścić f=.
nimi
3

Galaretka , 15 bajtów

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

Wypróbuj online!

Erik the Outgolfer
źródło
:( Wersja skompresowana ma 29 bajtów
caird coinheringaahing
3

Rubin, 53 50 bajtów

$><<"a as
a unas
una as
una unas".gsub(?a,"known")
dkudriavtsev
źródło
Zamień \nna dosłowny znak nowej linii.
Wartość tuszu
@ValueInk Gotowe.
dkudriavtsev
2

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
Neil
źródło
Oczywiście, zagnieżdżone pętle, nie myślałem o ... dobrej robocie!
schnaader
2

Haxe, 71 bajtów

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

Wypróbuj online!

Aurel Bílý
źródło
2

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!

gastropner
źródło
1
Na odwrótf(i){for(i=8;i--;)printf("unknown%s"+(i>4|i==2)*2,i%2?" ":"s\n");}
l4m2
Zaproponuj L"ੳ "+i%2zamiasti%2?" ":"s\n"
ceilingcat
2

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!

AdmBorkBork
źródło
Podejście Neila oszczędza 2 bajty .
Martin Ender
@MartinEnder Racja, dobra rozmowa. Dzięki!
AdmBorkBork
2

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.

BradC
źródło
1

ReRegex , 38 bajtów

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

Wypróbuj online!

ATaco
źródło
Po raz pierwszy widzę ten język, ale a/known / z/s\n/aazaunazunaazunaunazwydaje się, że działa przez 36 bajtów.
ktoś
1

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 ())
Brian H.
źródło
1
Myślę, że krótsze byłoby dodanie un w samym ciągu
ktoś
masz całkowitą rację, szkoda, że ​​tak bardzo stępia to rozwiązanie.
Brian H.,
1
Czy potrzebne jest miejsce po przecinku?
ktoś
4
Użycie split..join zamiast replaceoszczędza jeden bajt.
2
Miałem na myśli usunięcie 0s i użycie .replace(/ |s/g,'known$&')(co teraz oszczędza tylko 3 bajty).
Neil