Колишній міністр оборони США Дональд Рамсфельд знаменито популяризував фразу "відомі ноунс". Тут ми збираємося перебрати його зауваження в чотирирядкову строфу.

Зокрема, виведіть цей текст:

known knowns
known unknowns
unknown knowns
unknown unknowns

Велика література не має значення (наприклад, Known unKnownsце нормально), і один нижній новий рядок є прийнятним, але інші зміни форматування не допускаються. Це означає єдиний пробіл між словами та LF(59 байт) або CR/LF(62 байти) між рядками.

Правила

• Прийнятна або повна програма, або функція. Якщо функція, ви можете повернути вихід, а не надрукувати його.
• Стандартні лазівки заборонені.
• Це код-гольф, тому діють усі звичайні правила гольфу, і найкоротший код (у байтах) виграє.

Python 2 , 54 52 байти

^{-2 байти завдяки xnor}

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

Спробуйте в Інтернеті!

Результати з /і %будуть, [[2, 2], [2, 0], [0, 2], [0, 0]]що будуть початковими індексами, видаляючи unколи 2, зберігаючи рядок без змін, коли0

Vim 28 25 байт

Це моя перша відповідь Vim, будь-які поради щодо гольфу вітаються.

2iunknown ␛rsY3P2xw.+.jw.

Дякую Лінн, що написала сценарій python, щоб зробити цю фантастичну анімацію.

Цим також можна керувати V Try it Online!

Також 25:

2iknown ␛rsY3pwiun␛+.+.w.

баш, 36 байт

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

інші рішення

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

якщо у ведучому рядку та додатковому просторі було прийнято 31 байт:

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

05AB1E , 13 12 байт

Збережено 1 байт завдяки Erik the Outgolfer (уникайте закриття рядка)

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

Спробуйте в Інтернеті!

Пояснення

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

CJam ( 26 25 байт)

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

Демонстрація в Інтернеті

Декартовий добуток ["known" "unknown"]із самим собою, потім кожен елемент з'єднується з простором і суфіксом з новою sлінією.

Завдяки Еріку за однобайтну економію.

R , 52 51 50 байт

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

Спробуйте в Інтернеті!

Напрочуд короткі команди підстановки та друку роблять це фактично конкурентоспроможною відповіддю R у строгому виклику!

Навіть якщо це супер нудно. Трохи цікавіше зараз, і з байтом збережено завдяки J.Doe !

Збережено ще один байт завдяки цій відповіді, також J.Doe!

Haskell , 60 58 53 51 байт

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

Спробуйте в Інтернеті!

Дає список рядків, як це було недавно дозволено. Дякуємо @firefrorefiddle за те, що вказали .

-2 байти завдяки коулу .

58-байтна версія:

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

Спробуйте в Інтернеті! Виходить один рядок.

C # (.NET Core) , 54 байти

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

Спробуйте в Інтернеті!

Сітківка , 33 32 байти

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

Спробуйте в Інтернеті! Редагувати: Збережено 1 байт завдяки @ovs. Пояснення: Це майже тривіальний підхід використання заповнювача для known, за винятком того, що тут я просто вставляю його перед кожним пробілом або s, що зберігає 3 4 байти.

PHP, 55 51 47 байт

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

спробуйте в Інтернеті

Сітківка , 33 32 байти

Збережено 1 байт за допомогою проміжного підходу друку від Leo.

 ¶u

knowns
u
 un
:`s 
 
m`^
un

Спробуйте в Інтернеті!

Пояснення

 ¶u

Перетворює неіснуючий (тобто порожній) вхід у рядок другого рядка. Це здається досить дивним, але ці символи - це коди для речей, які проходять між двома екземплярами known[s]у перших двох рядках результату. Космос та виведення на ринок - це лише вони та uє un.

knowns

Тепер ми вставляємо knownsв кожну позицію (тобто на початку, в кінці та між кожною парою символів).

u
 un

Розшифруємо u.

:s 
 

Потім ми позбавляємось ss перед пробілами, тобто тими, що знаходяться в першій половині кожного рядка, і друкуємо результат.

m`^
un

І, нарешті, ми додаємо unобидва рядки і знову друкуємо результат.

Це перевищує тривіальний підхід просто використання заповнювача на known4 байти, але це не більш ефективна реалізація цього підходу Нілом .

Мова програмування Шекспіра , 1021 1012 993 байт

-19 байт завдяки Джо Кінгу!

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

Спробуйте в Інтернеті!

Perl 6 , 45 байт

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

Спробуй це

Розширено

$_ = '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](…)частина генерує

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

Потім за допомогою X~примусує внутрішні списки до Str (через &infix:«~»оператора), що робить це додаванням пробілу між значеннями.

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

Потім кожен з’єднується з s

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

Haskell, 57 52 байти

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

Спробуйте в Інтернеті!

APL (Діалог) , 64 47 35 байт

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

Спробуйте в Інтернеті!

Як?

k←'known'- kє"known"

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

∘.... ⍨- зовнішній виріб із самим собою

    {⍺,' ',⍵,'s'} - з функцією, яка форматує аргументи як {⍺} {⍵}s

, - розбити таблицю продуктів у вектор

⍪ - окремо до стовпців

Java 8, 56 55 байт

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

-1 байт завдяки @SuperChafouin .

Пояснення:

Спробуйте тут.

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 байт

Дякуємо @Justin Mariner за те, що ти граєш на один байт!

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

Спробуйте в Інтернеті!

Лушпиння , 14 байт

OΠṠemhw¨ṅW∫ḟωμ

Спробуйте в Інтернеті!

Пояснення

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 код машини (C64), 48 байт

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

Демонстрація в Інтернеті

Використання: sys49152

Як це працює

Трюк тут полягає у використанні "лічильника циклу" для 8 ітерацій, де біти 7 до 1 початкового значення є 1для unknown(s)і 0за known(s)одну ітерацію. Цей лічильник зміщується вліво після кожної ітерації (зміщення лівого біта в прапор переносу) і біт 0спочатку, 1тому ми знаємо, що ми закінчили, коли останній біт був зміщений. У першій ітерації надрукується, knownоскільки при виклику програми прапор переносу чіткий.

У кожній ітерації кінець рядка перемикається між <space>і s<newline>.

Ось коментований список розбирання:

         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 байти

Відмова від відповідальності : я не розумію , що в фігурних дужках було можливо в межах <...>оператора (дізнався завдяки @ брудному «s відповідь !) І використовуючи хитру штуку розширення від @ NahuelFouilleul » s дивовижний Баш відповідь , я був в змозі побудувати це рішення. Я із задоволенням видалю це за будь-якого їх запиту.

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

Спробуйте в Інтернеті!

Perl 5 , 42 байти

41 байт код + 1 для -p.

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

Спробуйте в Інтернеті!

Perl 5 , 45 байт

Спробував придумати альтернативу, але не зміг би її скоротити ... Думав, що вона досить інша, щоб вимагати додавання в будь-якому випадку.

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

Спробуйте в Інтернеті!

Haskell, 71 66 56 54 байт

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

Дякую @Leo за -3 байти!

_{Примітка. У коментарях до запитання, оп, сказав, що повернення списку рядків добре}

Спробуйте тут.

Желе , 15 байт

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

Спробуйте в Інтернеті!

Рубі, 53 50 байт

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

Пакет, 66 байт

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

Альтернативна відповідь, також 66 байт:

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

Хакс, 71 байт

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

Спробуйте в Інтернеті!

C (gcc) , 70 66 байт

Завдяки @ l4m2 за -4 байти!

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

Спробуйте в Інтернеті!

PowerShell , 46 44 байт

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

Спробуйте в Інтернеті!

(Майже) проста заміна рядків. Використовує підхід Ніла, щоб обрізати два байти. Дякую Мартіну за те, що вказав на це.

На жаль, він коротший, ніж цікавіший метод крос-продукту на три п’ять три байти:

PowerShell , 49 47 байт

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

Спробуйте в Інтернеті!

T-SQL, 56 54 байти

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

SQL підтримує розриви рядків всередині рядкових літералів, настільки подібні до деяких інших мов, які вже розміщені.

EDIT : Трохи довший ( 82 байти ), але трохи розумніший:

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 : Мої улюблені досі, використовуючи перехресне самоз'єднання з похідної таблиці ( 79 байт ):

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

EDIT 3 : Змінено символ заміни з 'x'на 1, що дозволяє мені видалити лапки навколо нього і зберегти 2 байти, оскільки REPLACEце неявне перетворення в рядок.

ReRegex , 38 байт

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

Спробуйте в Інтернеті!

Javascript 66 54 53 50 байт

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

Історія

• збережено 12 байт завдяки @someone (явне використання "un" в основній рядку)
• збережено 1 байт завдяки @ThePirateBay (розділити .. приєднатися замість заміни)
• збережено 3 байти завдяки @Neil (краще замінити ())