अमेरिका के पूर्व रक्षा सचिव, डोनाल्ड रम्सफेल्ड, ने "प्रसिद्ध ज्ञात" वाक्यांश को लोकप्रिय बनाया। यहाँ हम उनकी टिप्पणी को चार-पंक्ति वाले छंद में प्रसारित करने जा रहे हैं।

विशेष रूप से, इस पाठ का आउटपुट:

known knowns
known unknowns
unknown knowns
unknown unknowns

कैपिटलाइज़ेशन मायने नहीं रखता (उदाहरण के लिए, Known unKnownsठीक है), और एक एकल अनुगामी न्यूलाइन स्वीकार्य है, लेकिन कोई अन्य स्वरूपण परिवर्तनों की अनुमति नहीं है। इसका मतलब है कि शब्दों के बीच एक एकल स्थान, और या तो LF(59 बाइट्स) या CR/LF(62 बाइट्स) लाइनों के बीच।

नियम

या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
मानक खामियों को मना किया जाता है।
यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

code-golf string kolmogorov-complexity code-golf sequence binary base-conversion binary-matrix code-golf string classification code-golf tips python code-golf combinatorics binary subsequence restricted-time code-golf number number-theory code-golf math number complex-numbers code-golf string code-golf string code-golf string random game king-of-the-hill python code-golf number sequence code-golf number sequence code-golf code-golf math number array-manipulation code-golf array-manipulation decision-problem code-golf string code-golf sequence integer

— AdmBorkBork
स्रोत

1

क्या कोई समझा सकता है कि इसे इतने सारे डाउनवोट क्यों मिले हैं? मेरे लिए यह एक उचित चुनौती है और भाषाओं के मिश्रण में विभिन्न उत्तरों को प्रोत्साहित किया है।

— एलपेड्रो

47

@ElPedro कई डाउनवोट के पीछे का कारण एक ज्ञात अज्ञात है

— Wondercricket

क्या हम एक मैट्रिक्स या स्ट्रिंग्स की एक सूची लौटा सकते हैं?

— आदम

1

@ Adám चार तार की एक सूची ठीक होगी, क्योंकि यह अभी भी शब्दों के बीच की जगह को संरक्षित कर रही है; लेकिन, जब तक आप रिक्त स्थान सहित हर वर्ण का मैट्रिक्स नहीं कर रहे हैं, मेट्रिक्स ठीक नहीं हैं।

— AdmBorkBork

1

क्या अनुगामी रिक्त स्थान जानबूझकर हैं?

— यूजर 202729

29

पायथन 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

28 25 बाइट्स विम

यह मेरा पहला विम उत्तर है, किसी भी गोल्फिंग टिप्स का स्वागत है।

2iunknown ␛rsY3P2xw.+.jw.

उस शानदार एनीमेशन को बनाने के लिए अजगर स्क्रिप्ट लिखने के लिए लिन का शुक्रिया ।

यह भी V Try it Online द्वारा चलाया जा सकता है !

25 भी:

2iknown ␛rsY3pwiun␛+.+.w.

— H.PWiz
स्रोत

मैं केवल एक और 25: 2iunknown ␛rsYPw2x2YP2xj.या थोड़ी भिन्नता 2iunknown ␛rsYPw2x2YPⓋjlx(-= Ctrl-V) खोजने में कामयाब रहा ।

— लिन 12

@ लीन नाइस, मैंने 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

यह सोचकर कि यह किस तरह का जादू है (अपने आप की तरह): यह बैश ब्रेस का विस्तार है

— bolov

... और भी बेहतर bash-hackers.org पर समझाया गया है , और आप इसे ऑनलाइन आज़मा सकते हैं ! ।

— डेसर्ट

यदि संदेह है, तो पूरे उत्तर को एक कोड ब्लॉक में रखें

— स्टेन स्ट्रम

reworded, अंत में अमान्य इनपुट

— नहुएल फोइउलुल

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

“Š¢—‚“->„Š¢—‚

— आउटगॉल्फ

@EriktheOutgolfer: ओह, हाँ, केवल 2 शब्द। धन्यवाद!

— एमिग्ना

बाह ... मैं पहले क्यों नहीं देखा? एक ही जवाब।

— मैजिक ऑक्टोपस Urn

11

CJam ( 26 25 बाइट्स)

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

ऑनलाइन डेमो

["known" "unknown"]खुद के साथ कार्टेशियन उत्पाद , फिर प्रत्येक तत्व अंतरिक्ष के साथ जुड़ गया sऔर एक नई रेखा के साथ प्रत्यय लगा ।

एक-बाइट की बचत के लिए एरिक को धन्यवाद ।

— पीटर टेलर
स्रोत

8

आर , 52 51 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आश्चर्यजनक रूप से छोटे प्रतिस्थापन और प्रिंट कमांड इसे एक कड़ी चुनौती में वास्तव में प्रतिस्पर्धी आर उत्तर बनाते हैं !

~~भले ही यह सुपर बोरिंग हो।~~ अब और अधिक दिलचस्प है, और एक बाइट के साथ जे । धन्यवाद के लिए धन्यवाद !

इस उत्तर के लिए एक और बाइट धन्यवाद , जे। बोवे द्वारा सहेजा गया!

— ग्यूसेप
स्रोत

6

हास्केल , 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क्योंकि "चार तारों की एक सूची ठीक होगी, क्योंकि यह अभी भी शब्दों के बीच की जगह को संरक्षित कर रहा है;" (मूल प्रश्न पर टिप्पणी)।

— फायरफ्रॉएडफ़िल्ड

1

51 बाइट्स

— कोल

5

सी # (.NET कोर) , 54 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— कोई व्यक्ति
स्रोत

5

रेटिना , 33 32 बाइट्स


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

इसे ऑनलाइन आज़माएं! संपादित करें: @ovs के लिए 1 बाइट धन्यवाद सहेजा गया। स्पष्टीकरण: यह एक प्लेसहोल्डर का उपयोग करने का लगभग तुच्छ दृष्टिकोण है known, सिवाय इसके कि मैं बस इसे प्रत्येक स्थान से पहले सम्मिलित करता हूं या s, जो 3 4 बाइट्स बचाता है ।

— नील
स्रोत

32 बाइट्स

— ओट्स

2

आप इसे आधे

— लियो

2

@Leo का उपयोग करते हुए आपको |sकिसी भी दृष्टिकोण की आवश्यकता नहीं है : tio.run/##K0otycxL/P@fK1shu/jQtmyF0rzsYi6rhGyu7Lu88jyu3IQ4rtK8//……

— मार्टिन

5

PHP, 55 51 47 बाइट्स

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

इसे ऑनलाइन आज़माएं

— टाइटस
स्रोत

क्या आपको php प्रविष्टियों के लिए टैग खोलने की आवश्यकता है?

— जोसिया

@ जोशिया मुझे परिणाम प्रिंट करने के लिए कुछ चाहिए; <?=सबसे छोटा विकल्प है।

— टाइटस

5

रेटिना , 33 32 बाइट्स

लियो से एक मध्यवर्ती मुद्रण दृष्टिकोण का उपयोग करके 1 बाइट को बचाया।


 ¶u

knowns
u
 un
:`s 
 
m`^
un

इसे ऑनलाइन आज़माएं!

व्याख्या

¶u

गैर-मौजूद (यानी खाली) इनपुट को दूसरी पंक्ति में स्ट्रिंग में बदल देता है। यह एक बहुत अजीब लगता है, लेकिन ये पात्र उस सामान के लिए कोड हैं जोknown[s] परिणाम के पहले दो पंक्तियों पर दो उदाहरणों के बीच जाता है । अंतरिक्ष और लाइनफीड बस खुद हैं और uहै un।


knowns

अब हम knownsहर पोजीशन (यानी शुरुआत, अंत और हर जोड़े के बीच में) को सम्मिलित करते हैं ।

u
 un

हम डिकोड करते हैं u।

:s

फिर हम sरिक्त स्थान के सामने एस से छुटकारा पाते हैं , अर्थात प्रत्येक पंक्ति के पहले छमाही में, और परिणाम प्रिंट करते हैं।

m`^
un

और अंत में हम unदोनों लाइनों के लिए प्रस्तुत करते हैं और परिणाम को फिर से प्रिंट करते हैं।

यह केवल 4 बाइट्स के लिए प्लेसहोल्डर का उपयोग करने के तुच्छ दृष्टिकोण को knownहराता है, लेकिन नील के उस दृष्टिकोण का अधिक कुशल कार्यान्वयन नहीं है।

— मार्टिन एंडर
स्रोत

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

— जो किंग

वास्तव में? हुह, यह बहुत छोटा-सा प्रतिनिधित्व है, मुझे संख्याओं को फिर से समझना है। धन्यवाद।

— जोशियान्वेन

4

पर्ल 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~करने से आंतरिक सूचियों को एक स्ट्रेटर ( &infix:«~»ऑपरेटर के कारण) में परिवर्तित किया जाता है , जो ऐसा करने से मूल्यों के बीच एक स्थान जुड़ जाता है।

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

फिर प्रत्येक को एक के साथ जोड़ा जाता है s

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

— ब्रैड गिल्बर्ट b2gills
स्रोत

41 बाइट्स

— जो किंग

4

हास्केल, 57 52 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— nimi
स्रोत

सूची के वैकल्पिक उत्पादन के साथ 49 बाइट्स

— कोल

@ कोल: आउटपुट स्वरूप बहुत सख्त है, इसलिए मुझे लगता है कि मान्य नहीं में तार की एक सूची।

— नीमी

अन्य हैस्केल उत्तर करता है, ऐसा लगता है कि ओपी ने उस प्रारूप को ठीक किया।

— कोल

4

एपीएल (डायलॉग) , 64 47 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कैसे?

k←'known'- kहै"known"

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

∘.... ⍨- खुद के साथ बाहरी उत्पाद

{⍺,' ',⍵,'s'} - फ़ंक्शन के साथ जो कि आर्ग्स को प्रारूपित करता है {⍺} {⍵}s

, - वेक्टर में उत्पाद तालिका तोड़

⍪ - कॉलम के लिए अलग

— Uriel
स्रोत

33 बाइट्स (खराब आउटपुट फॉर्मेट को फिक्स करना)

— द्वीमा सिप

1

@ दाजिमा 31

— कृति लिथोस

4

जावा 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? ^ ^ '

— ओलिवियर ग्रेजायर

@ ओलिवियरग्रेयर वूप्स ..; पी

— केविन क्रूज़सेन

1

आप एक बाइट जीत सकते हैंv->" s\n uns\nun s\nun uns".replaceAll(" |s","known$0")

— अरनौद

4

सी (जीसीसी), 79 78 76 बाइट्स

एक बाइट गोल्फिंग के लिए @ जस्टिन मेरिनर को धन्यवाद!

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>।

यहाँ टिप्पणी की disassembly सूची है:

         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

पर्ल 5 , 33 बाइट्स

डिस्क्लेमर : मुझे महसूस नहीं हुआ कि <...>ऑपरेटर के भीतर ब्रेस विस्तार संभव था (@ ग्रैमी के जवाब के लिए धन्यवाद सीखा !) और @ NahuelFouilleul के अद्भुत बैश उत्तर से चतुर विस्तार ट्रिक का उपयोग करके , मैं इस समाधान का निर्माण करने में सक्षम था। मैं खुशी से उनके अनुरोध पर इसे हटा दूंगा।

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

इसे ऑनलाइन आज़माएं!

पर्ल 5 , 42 बाइट्स

41 बाइट्स कोड + 1 के लिए -p।

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

इसे ऑनलाइन आज़माएं!

पर्ल 5 , 45 बाइट्स

एक विकल्प के साथ आने की कोशिश की, लेकिन यह कम नहीं कर सका ... सोचा कि यह वैसे भी काफी हद तक वारंट जोड़ रहा था।

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

इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स
स्रोत

3

हास्केल, 71 66 56 54 बाइट्स

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

-3 बाइट्स के लिए @Leo को धन्यवाद !

_{नोट: प्रश्न की टिप्पणियों में, ऑप ने कहा कि तार की सूची को वापस करना ठीक है}

इसे यहाँ आज़माएँ।

— एडिसन
स्रोत

यह बहुत अच्छा है और मैं इसे समझ भी नहीं पा रहा हूं, लेकिन आपके दूसरे भाग के हिस्से को fmapछोटा किया जा सकता है map(' ':):)

— लियो

1

@Leo धन्यवाद! हाहा, मुझे यकीन भी नहीं है कि मैं इसे अब भी समझता हूं

— एडिसन

फ़ंक्शन को कोई नाम देने की आवश्यकता नहीं है, इसलिए आप ड्रॉप कर सकते हैं f=।

— निमि

3

जेली , 15 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— आउटग्रॉफर को एरिक करें
स्रोत

:( संपीड़ित संस्करण 29 बाइट्स है

— caird coinheringaahing

3

रूबी, 53 50 बाइट्स

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

— dkudriavtsev
स्रोत

\nएक शाब्दिक न्यूलाइन के साथ बदलें ।

— मूल्य इंक

@ValueInk किया।

— dkudriavtsev

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

हेक्से, 71 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— ऑरेल बेली
स्रोत

2

सी (जीसीसी) , 70 66 बाइट्स

-4 बाइट्स के लिए @ l4m2 के लिए धन्यवाद!

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"

— छत

2

पॉवरशेल , 46 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

(लगभग) सरल स्ट्रिंग प्रतिस्थापन। दो बाइट ट्रिम करने के लिए नील के दृष्टिकोण का उपयोग करता है । मार्टिन की ओर इशारा करते हुए धन्यवाद।

अफसोस की बात है, यह ~~तीन~~ ~~पांच~~ तीन बाइट्स द्वारा अधिक दिलचस्प क्रॉस-उत्पाद विधि से छोटा है :

पॉवरशेल , 49 47 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— AdmBorkBork
स्रोत

नील का दृष्टिकोण 2 बाइट्स बचाता है ।

— मार्टिन एंडर

@MartinEnder राइट, अच्छी कॉल। धन्यवाद!

— AdmBorkBork

2

टी-एसक्यूएल, 56 54 बाइट्स

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

एसआर स्ट्रिंग स्ट्रिंगल के अंदर लाइन ब्रेक का समर्थन करता है, इसलिए पहले से ही पोस्ट की गई कुछ अन्य भाषाओं के समान है।

संपादित करें : थोड़ा लंबा ( 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, जो मुझे इसके चारों ओर के उद्धरण हटाने और REPLACEस्ट्रिंग को एक अंतर्निहित रूपांतरण करने के बाद से 2 बाइट्स को बचाने देता है ।

— BradC
स्रोत

1

ReRegex , 38 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Ataco
स्रोत

मैं पहली बार इस भाषा को देख रहा हूं, लेकिन a/known / z/s\n/aazaunazunaazunaunaz36 बाइट्स के लिए काम करता हूं ।

— कोई 3

1

जावास्क्रिप्ट 66 54 53 50 बाइट्स

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

इतिहास

@someone के लिए 12 बाइट्स सहेजे गए (मुख्य स्ट्रिंग में "संयुक्त राष्ट्र का स्पष्ट उपयोग")
1 बाइट @ @PirateBay के लिए धन्यवाद (विभाजन की जगह बदलें)
@Neil (बेहतर प्रतिस्थापन ()) के लिए 3 बाइट्स धन्यवाद बचाया

— ब्रायन एच।
स्रोत

1

मुझे लगता है कि यह स्ट्रिंग में संयुक्त राष्ट्र में जोड़ने के लिए छोटा होगा

— कोई

आप पूरी तरह से सही हैं, शर्म की बात है कि यह समाधान को इतना नीचे गिरा देता है।

— ब्रायन एच।

1

क्या अल्पविराम के बाद की जगह की आवश्यकता है?

— कोई

4

का उपयोग करते हुए split..join के बजाय replaceएक बाइट बचाता है।

2

मेरा मतलब था एस को हटाने 0और उपयोग करने से .replace(/ |s/g,'known$&')(जो अब केवल 3 बाइट बचाता है)।

— नील

जानी पहचानी बातें हैं

नियम

पायथन 2 , 54 52 बाइट्स

28 25 बाइट्स विम

बैश, 36 बाइट्स

05AB1E , 13 12 बाइट्स

CJam ( 26 25 बाइट्स)

आर , 52 51 50 बाइट्स

हास्केल , 60 58 53 51 बाइट्स

सी # (.NET कोर) , 54 बाइट्स

रेटिना , 33 32 बाइट्स

PHP, 55 51 47 बाइट्स

रेटिना , 33 32 बाइट्स

व्याख्या

शेक्सपियर प्रोग्रामिंग लैंग्वेज , 1021 1012 993 बाइट्स

पर्ल 6 , 45 बाइट्स

विस्तारित

हास्केल, 57 52 बाइट्स

एपीएल (डायलॉग) , 64 47 35 बाइट्स

जावा 8, 56 55 बाइट्स

सी (जीसीसी), 79 78 76 बाइट्स

भूसी , 14 बाइट्स

व्याख्या

6502 मशीन कोड (C64), 48 बाइट्स

यह काम किस प्रकार करता है

पर्ल 5 , 33 बाइट्स

पर्ल 5 , 42 बाइट्स

पर्ल 5 , 45 बाइट्स

हास्केल, 71 66 56 54 बाइट्स

जेली , 15 बाइट्स

रूबी, 53 50 बाइट्स

बैच, 66 बाइट्स

हेक्से, 71 बाइट्स

सी (जीसीसी) , 70 66 बाइट्स

पॉवरशेल , 46 44 बाइट्स

पॉवरशेल , 49 47 बाइट्स

टी-एसक्यूएल, 56 54 बाइट्स

ReRegex , 38 बाइट्स

जावास्क्रिप्ट 66 54 53 50 बाइट्स

इतिहास