Eski ABD Savunma Sekreteri Donald Rumsfeld, "bilinen known" ifadesini meşhur etti. Burada sözlerini dört hatlı bir stanza dağıtacağız.

Özellikle, bu metni çıktısı alın:

known knowns
known unknowns
unknown knowns
unknown unknowns

Büyük harf kullanımı önemli değil (örneğin, Known unKnownsiyi) ve tek bir izleyen yeni satır kabul edilebilir, ancak başka hiçbir biçimlendirme değişikliğine izin verilmez. Bu, kelimeler arasında tek bir boşluk ve satırlar arasında LF(59 bayt) veya CR/LF(62 bayt) anlamına gelir .

kurallar

• Tam bir program veya bir işlev kabul edilebilir. Bir işlev varsa, çıktıyı yazdırmak yerine geri gönderebilirsiniz.
• Standart boşluklar yasaktır.
• Bu kod-golf olduğundan, tüm normal golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

Python 2 , 54 52 bayt

^{Xnor sayesinde -2 bayt}

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

Çevrimiçi deneyin!

Elde edilen sonuçlar /ve %olacak [[2, 2], [2, 0], [0, 2], [0, 0]]biçimde başlangıç endeksleri olmak çıkarmadan olacak unzaman 2zaman değiştirilmemiş dize tutarak,0

Vim 28 25 bayt

Bu benim ilk Vim cevabım, herhangi bir golf ipucu bekliyoruz.

2iunknown ␛rsY3P2xw.+.jw.

Bu harika animasyonu yapmak için python betiğini yazdığınız için Lynn'e teşekkür ederiz .

Bu ayrıca V tarafından da çalıştırılabilir Çevrimiçi Deneyin!

Ayrıca 25:

2iknown ␛rsY3pwiun␛+.+.w.

bash, 36 bayt

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

diğer çözümler

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

Lider newline ve fazladan boşluk 31 bayt kabul edildi ise:

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

05AB1E , 13 12 bayt

Outgolfer Erik sayesinde 1 bayt kurtarıldı (dizgiyi kapatmaktan kaçının)

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

Çevrimiçi deneyin!

açıklama

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

CJam ( 26 25 bayt)

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

Çevrimiçi demo

Kartezyenin ["known" "unknown"]kendisi ile ürünü , daha sonra her eleman boşlukla birleştirildi sve yeni bir satırla sonlandırıldı .

Bir baytlık tasarruf için Erik'e teşekkürler .

R , 52 5150 bayt

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

Çevrimiçi deneyin!

Şaşırtıcı bir şekilde kısa ikame ve baskı komutları, dizge yarışmasında bunu gerçekten rekabetçi bir R cevabı haline getirir !

Süper sıkıcı olsa bile. Şimdi biraz daha ilginç ve J.Doe sayesinde kurtarılan bir byte ile !

Bu cevap sayesinde bir başka byte daha kaydedildi , ayrıca J.Doe!

Haskell , 60 58 53 51 bayt

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

Çevrimiçi deneyin!

Son zamanlarda izin verilen şekilde bir satır listesi verir. İşaret için @firefrorefiddle teşekkürler .

Cole sayesinde -2 bayt .

58 bayt sürümü:

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

Çevrimiçi deneyin! Tek bir dize verir.

C # (.NET Core) , 54 bayt

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

Çevrimiçi deneyin!

Retina , 33 32 bayt

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

Çevrimiçi deneyin! Düzenleme: @ovs sayesinde 1 bayt kaydedildi. Açıklama: Bu neredeyse bir yer tutucu kullanmanın önemsiz yaklaşımıdır, knownburada sadece her alandan önce ekliyorum, ya da 3 4 bayt stasarruf sağlıyor .

PHP, 55 51 47 bayt

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

çevrimiçi dene

Retina , 33 32 bayt

Leo'dan bir ara baskı yaklaşımı kullanarak 1 bayt kurtarıldı.

 ¶u

knowns
u
 un
:`s 
 
m`^
un

Çevrimiçi deneyin!

açıklama

 ¶u

Var olmayan (yani boş) girişi, ikinci satırdaki dizgiye döndürür. Bu oldukça garip görünüyor, ancak bu karakterler sonucun ilk iki satırındaki iki durum arasındaki eşyanın kodları known[s]. Uzay ve satır besleme sadece kendilerini ve uolduğunu un.

knowns

Şimdi knownsher pozisyona yerleştiriyoruz (örneğin, başlangıcına, sonuna ve her karakter çifti arasına).

u
 un

Çözüyoruz u.

:s 
 

Sonra sboşluklardan önündeki boşluklardan kurtuluruz , yani her satırın ilk yarısında olanlar ve sonucu yazdırırız.

m`^
un

Sonunda uniki çizgiyi de hazırlıyoruz ve sonucu tekrar yazdırıyoruz.

Bu , yalnızca yer tutucu kullanmak için 4 byte önemsiz yaklaşımı yener known, ancak Neil'in bu yaklaşımı daha etkili bir şekilde uygulamaması .

Shakespeare Programlama Dili , 1021 1012 993 bayt

Joe King sayesinde -19 bayt!

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

Çevrimiçi deneyin!

Perl 6 , 45 bayt

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

Dene

Expanded

$_ = '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](…)parçası üretir

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

Daha sonra X~üzerinde kullanmak , iç listeleri bir Str'ye ( &infix:«~»operatör nedeniyle ) zorlar , bu da değerler arasına boşluk ekler.

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

Sonra her biri bir s

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

Haskell, 57 52 bayt

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

Çevrimiçi deneyin!

APL (Dyalog) , 64 47 35 bayt

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

Çevrimiçi deneyin!

Nasıl?

k←'known'- kolduğu"known"

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

∘.... ⍨- kendisi ile dış ürün

    {⍺,' ',⍵,'s'} - Argümanları biçimlendiren fonksiyon ile {⍺} {⍵}s

, - ürün tablosunu vektöre parçalayın

⍪ - sütunlara ayrı

Java 8, 56 55 bayt

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

@ SuperChafouin sayesinde -1 bayt .

Açıklama:

Burada dene.

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 bayt

Bir bayt golf oynadığı için @Justin Mariner'a teşekkürler!

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

Çevrimiçi deneyin!

Kabuğu , 14 bayt

OΠṠemhw¨ṅW∫ḟωμ

Çevrimiçi deneyin!

açıklama

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 makine kodu (C64), 48 bayt

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

Çevrimiçi demo

Kullanımı: sys49152

Nasıl çalışır

Hüner burada başlangıç değerinin 1 bit 7, 8 tekrarlamalar için bir "döngü sayacı" kullanmaktır 1için unknown(s)ve 0için known(s)bir tekrarında. Bu sayaç her yinelemeden sonra sola kaydırılır (en soldaki bit taşıma bayrağına kaydırılır) ve bit 0başlangıçta biter, 1böylece son bit çıkarıldıktan sonra bittiğimizi biliriz. İlk yinelemede knownyazdırılır çünkü programı çağırırken taşıma bayrağı temizdir.

Her tekrarında, dize sonu arasında geçiş yapar <space>ve s<newline>.

İşte yorum sökme listesi:

         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 bayt

Yasal Uyarı : O bağ genişleme içinde mümkün olduğunu fark etmedi <...>(@ sayesinde öğrenilen operatör Grimy 'ın cevabı !) Ve @ gelen zeki genişletme hile kullanarak NahuelFouilleul ' ın inanılmaz bash cevap , bu çözümü oluşturmak başardı. Her iki isteğinde de bunu mutlu bir şekilde kaldıracağım.

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

Çevrimiçi deneyin!

Perl 5 , 42 bayt

İçin 41 bayt kodu + 1 -p.

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

Çevrimiçi deneyin!

Perl 5 , 45 bayt

Bir alternatif bulmaya çalıştım, ancak daha kısa hale getiremedi ... Yine de eklemeyi garanti edecek kadar farklı olduğunu düşündüm.

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

Çevrimiçi deneyin!

Haskell, 71 66 56 54 bayt

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

-3 bayt için @Leo'ya teşekkürler !

_{Not: Sorunun yorumunda, operasyon dizeleri listesini döndürmenin tamam olduğunu söyledi}

Burada dene.

Jöle , 15 bayt

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

Çevrimiçi deneyin!

Ruby, 53 50 bayt

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

Toplu iş, 66 bayt

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

Alternatif cevap, ayrıca 66 bayt:

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

Haxe, 71 bayt

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

Çevrimiçi deneyin!

C (gcc) , 70 66 bayt

-4 baytlık @ l4m2'ye teşekkürler!

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

Çevrimiçi deneyin!

PowerShell , 46 44 bayt

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

Çevrimiçi deneyin!

(Neredeyse) basit dize değiştirme. Neil'in iki bayt kesim yaklaşımını kullanır . Bunu işaret ettiği için Martin'e teşekkür ederim.

Ne yazık ki, daha ilginç olan çapraz ürün yönteminden üç beş üç bayt daha kısa :

PowerShell , 49 47 bayt

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

Çevrimiçi deneyin!

T-SQL, 56 54 bayt

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

SQL, dize değişmezleri içindeki satır sonlarını destekler, bu nedenle zaten yayınlanmış diğer dillere benzer.

EDIT : Biraz daha uzun ( 82 byte ), fakat biraz daha zeki:

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 : Şimdiye kadarki favorim, türetilmiş bir tablodan çapraz birleştirme kullanarak ( 79 bayt ):

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

DÜZENLEME 3 : yedek karakterini değiştirdi 'x'etmek 1beri beni etrafında ve 2 byte tasarruf tırnak kaldırmak sağlayan, REPLACEdizeye bir örtük dönüştürme yapar.

ReRegex , 38 bayt

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

Çevrimiçi deneyin!

Javascript 66 54 53 50 bayt

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

Tarih

• @someone (ana dizgede "un" un açık kullanımı) sayesinde 12 bayt kaydedildi
• @ThePirateBay sayesinde 1 bayt kurtarıldı (split yerine ...
• @Neil sayesinde 3 byte kurtarıldı (daha iyi