Есть известные известные

45

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

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

known knowns
known unknowns
unknown knowns
unknown unknowns

Использование заглавных букв не имеет значения (например, Known unKnownsэто нормально), и допускается одиночный завершающий перевод строки, но другие изменения форматирования не допускаются. Это означает один пробел между словами и либо LF(59 байт), либо CR/LF(62 байт) между строками.

правила

  • Либо полная программа или функция приемлемы. Если функция, вы можете вернуть вывод, а не распечатать его.
  • Стандартные лазейки запрещены.
  • Это поэтому применяются все обычные правила игры в гольф, и выигрывает самый короткий код (в байтах).
AdmBorkBork
источник
1
Кто-нибудь может объяснить, почему так много отрицательных отзывов? Для меня это разумный вызов, и он поощряет различные ответы на разных языках.
ElPedro
47
@ElPedro Причиной многих отрицательных голосов является известный неизвестный
Wondercricket
Можем ли мы вернуть матрицу или список строк?
Адам
1
@ Adám Список из четырех строк будет в порядке, так как он по-прежнему сохраняет пробел между словами; но, если вы не делаете матрицу каждого символа, включая пробелы, матрицы не в порядке.
AdmBorkBork
1
Являются ли замыкающие пробелы преднамеренными?
user202729

Ответы:

29

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

прут
источник
1
Если вы позволите kбыть 'unknowns', вы можете исправить с k[i/3:7]и сохранить два байта.
xnor
27

Vim 28 25 байт

Это мой первый ответ Vim, любые советы по игре в гольф приветствуются.

2iunknown ␛rsY3P2xw.+.jw.

В бою

Спасибо, Линн, за написание скрипта на python для создания этой фантастической анимации.

Это также может быть запущено V Попробуй онлайн!

Также 25:

2iknown ␛rsY3pwiun␛+.+.w.
H.PWiz
источник
Мне удалось найти только 25: 2iunknown ␛rsYPw2x2YP2xj.или небольшое изменение 2iunknown ␛rsYPw2x2YPⓋjlx(Ⓥ = Ctrl-V).
Линн
@ Линн Хорошо, я попробовал Ctrl-V, но получил что-то дольше.
H.PWiz
23

Баш, 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
Науэль Фуйе
источник
3
для тех, кто интересуется, что это за колдовство (как и я): это расширение bash
brace
… Еще лучше объяснено на bash-hackers.org , и вы можете попробовать это онлайн! ,
десерт
Если сомневаетесь, поместите весь ответ в блок кода
Стэн Струм,
перефразировано, неверный ввод в конце
Науэль Фуий
14

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
Emigna
источник
2
“Š¢—‚“->„Š¢—‚
Эрик Outgolfer
@EriktheOutgolfer: О да, только 2 слова. Спасибо!
Emigna
Баххх ... почему я не посмотрел первым? Тот же ответ.
Волшебная урна осьминога
11

CJam ( 26 25 байт)

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

Онлайн демо

Декартово произведение ["known" "unknown"]само с собой, тогда каждый элемент соединяется с пробелом и суффиксом и переводом sстроки.

Спасибо Эрику за однобайтовую экономию.

Питер Тейлор
источник
8

R , 52 51 50 байт

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

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

Удивительно короткие команды подстановки и печати делают это действительно конкурентоспособным ответом R в испытании!

Даже если это супер скучно. Слегка интереснее, теперь с сохраненным байтом благодаря J. Doe !

Благодаря этому ответу сохранен еще один байт , также от J.Doe!

Giuseppe
источник
6

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]

Попробуйте онлайн! Возвращает одну строку.

Laikoni
источник
Ваша 60-байтовая версия на самом деле является 53-байтовой версией, потому что вы можете удалить ее, unlinesпотому что «список из четырех строк будет в порядке, так как он по-прежнему сохраняет пробел между словами»; (Комментарий к оригинальному вопросу).
firefrorefiddle
1
51 байт, объединяющий ваш подход с @ PeterTaylor's
Коул
5

Сетчатка , 33 32 байта


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

Попробуйте онлайн! Редактировать: 1 байт сохранен благодаря @ovs. Пояснение: Это почти тривиальный подход использования заполнителя для known, за исключением того, что здесь я просто вставляю его перед каждым пробелом или s, что экономит 3 4 байта.

Нил
источник
32 байта
овс
2
Вы можете улучшить это, наполовину печатая
Лев
2
@ Лео, используя этот подход, вам больше не нужен |sподход: tio.run/##K0otycxL/P@fK1shu/jQtmyF0rzsYi6rhGyu7Lz88jyu3IQ4rtK8//…
Мартин Эндер,
5

PHP, 55 51 47 байт

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

попробуйте это онлайн

Titus
источник
Вам нужны открывающие теги для записей php?
Иосия
@ Джосия Мне нужно что-то, чтобы напечатать результат; <?=это самый короткий вариант.
Тит
5

Сетчатка , 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 байта, но не в более эффективной реализации Нейлом этого подхода.

Мартин Эндер
источник
5

Язык программирования Шекспира , 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.

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

JosiahRyanW
источник
Вы можете удалить пробелы после некоторых операторов из нескольких слов, таких какthe sum of
Джо Кинг
В самом деле? Да, это много кратчайших представлений чисел, которые я должен пересчитать. Благодарю.
JosiahRyanW
4

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
Брэд Гилберт b2gills
источник
41 байт
Джо Кинг,
4

Haskell, 57 52 байта

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

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

Ними
источник
49 байтов с альтернативным выводом списка
Коул
@cole: формат вывода очень строгий, поэтому я думаю, что список строк недействителен.
Ними
другой ответ на Haskell делает это, кажется, что OP одобрил этот формат.
Коул
4

APL (Dyalog) , 64 47 35 байт

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

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

Как?

k←'known'- kэто"known"

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

∘.... - внешний продукт с собой

    {⍺,' ',⍵,'s'} - с функцией, которая форматирует аргументы как {⍺} {⍵}s

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

- отдельно от столбцов

Уриэль
источник
33 байта (+ исправление
неверного
1
@dzaima 31
Kritixi Lithos
4

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)
Кевин Круйссен
источник
Хорошо, я должен спросить ... почему \r? ^^ '
Оливье Грегуар,
@ OlivierGrégoire Woops ..; p
Кевин Круйссен,
1
Вы можете выиграть один байт сv->" s\n uns\nun s\nun uns".replaceAll(" |s","known$0")
Арно
4

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");}

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

Steadybox
источник
Я думаю, что это может быть на один байт меньше, если вы используете %1$sи избавитесь от i: попробуйте онлайн!
Джастин Маринер,
3

Шелуха , 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
Лео
источник
3

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
Феликс Палмен
источник
3

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

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

Дом Гастингс
источник
3

Haskell, 71 66 56 54 байта

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

Спасибо @Leo за -3 байта!

Примечание: в комментариях к вопросу оп сказал, что возвращение списка строк в порядке

Попробуй это здесь.

аддисон
источник
Это замечательно, и я даже не могу этого понять, но часть, начиная с вашего второго, fmapможет быть сокращена до map(' ':):)
Лев
1
@ Лео Спасибо! Ха - ха, я даже не уверен , что понимаю больше
аддисон
Не нужно давать имя функции, так что вы можете удалить f=.
nimi
3

Рубин, 53 50 байт

$><<"a as
a unas
una as
una unas".gsub(?a,"known")
dkudriavtsev
источник
Заменить \nбуквальным переводом строки.
Стоимость чернил
@ValueInk Готово.
Дкудрявцев
2

Пакетный, 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
Нил
источник
Конечно, вложенные циклы, не думали об этом ... хорошая работа!
шнаадер
2

С (ССЗ) , 70 66 байт

Спасибо @ l4m2 за -4 байта!

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

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

gastropner
источник
1
В обратном порядкеf(i){for(i=8;i--;)printf("unknown%s"+(i>4|i==2)*2,i%2?" ":"s\n");}
l4m2
Предлагаю L"ੳ "+i%2вместоi%2?" ":"s\n"
floorcat
2

PowerShell , 46 44 байта

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

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

(Почти) простая замена строки. Использует подход Нейла, чтобы урезать два байта. Спасибо Мартину за то, что указал на это.

К сожалению, он короче, чем более интересный метод кросс-произведения, на три пять три байта:

PowerShell , 49 47 байт

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

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

AdmBorkBork
источник
Подход Нила экономит 2 байта .
Мартин Эндер
@ MartinEnder Правильно, хороший звонок. Спасибо!
AdmBorkBork
2

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выполняет неявное преобразование в строку.

BradC
источник
1

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 байта (лучше заменить ())
Брайан Х.
источник
1
Я думаю, что было бы короче добавить un в самой строке
кто-то
Вы совершенно правы, позор, что это затуманивает решение, хотя сильно.
Брайан Х.
1
Нужно ли пробел после запятой?
кто-то
4
Использование split..join вместо replaceсохранения одного байта.
2
Я имел в виду удаление 0s и использование .replace(/ |s/g,'known$&')(которое теперь экономит только 3 байта).
Нил