Бывший министр обороны США Дональд Рамсфелд, как известно, популяризировал фразу «известные известные». Здесь мы собираемся перевести его замечания в строфу из четырех строк.

В частности, выведите этот текст:

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 Попробуй онлайн!

Также 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 байт благодаря Эрику Искателю (избегайте закрывающей строки)

„Š¢—‚#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 байт с использованием промежуточного метода печати от Лео.

 ¶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~on приводит его внутренние списки в 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 (Dyalog) , 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

Haxe, 71 байт

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

Попробуйте онлайн!

С (ССЗ) , 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 поддерживает разрывы строк внутри строковых литералов, поэтому они похожи на некоторые другие уже опубликованные языки.

РЕДАКТИРОВАТЬ : немного длиннее ( 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

РЕДАКТИРОВАТЬ 2 : Мой любимый до сих пор, используя перекрестное самостоятельное соединение из производной таблицы ( 79 байт ):

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

РЕДАКТИРОВАТЬ 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 (split..jin вместо replace)
• благодаря @Neil удалось сэкономить 3 байта (лучше заменить ())