हां लेकिन हां नहीं

Question

मेरे सहयोगी ने हाल ही में मुझे मजाक के रूप में जावास्क्रिप्ट का निम्नलिखित टुकड़ा भेजा:

let butScript = (nrOfButs) => {
    for(var i = 0; i < nrOfButs; i++){
        if(i % 3 == 0){
            console.log("Yeah")
        }
        if(i % 2 == 0){
            console.log("But")
        }
        if(i % 3 == 1){
            console.log("No")
        }
    }
}

चूंकि कोड काम के घंटों के दौरान लिखा गया था, यह स्पष्ट रूप से कंपनी के संसाधनों का एक बड़ा अपशिष्ट था। भविष्य में इसी तरह की घटनाओं को रोकने के लिए, हमें काम के घंटों को कम करना चाहिए। और चूंकि यह सामान्य ज्ञान है कि लिखने के लिए एक छोटा कार्यक्रम तेज है, हमें इस कोड को यथासंभव छोटा करना चाहिए!

इनपुट

एक एकल गैर-नकारात्मक पूर्णांक। आपको दोषपूर्ण इनपुट को संभालना नहीं चाहिए।

उत्पादन

आपके प्रोग्राम को उपरोक्त स्क्रिप्ट के समान आउटपुट का उत्पादन करना होगा। आपको प्रति पंक्ति एक शब्द का उत्पादन करना चाहिए, और शब्दों की संख्या मूल स्क्रिप्ट के अनुरूप होनी चाहिए।

अदृश्य होने के बाद से प्रत्येक पंक्ति के अंत में (लेकिन शुरुआत में नहीं) गैर-नईलाइन व्हॉट्सएप वर्णों को शामिल करना अनुमत है। आउटपुट के बहुत अंत में एक अतिरिक्त न्यूलाइन वर्ण स्वीकार्य है।

उदाहरण

Input: 0
Output:


Input: 1
Output:
Yeah
But

Input: 2
Output:
Yeah
But
No

Input: 10
Output:
Yeah
But
No
But
Yeah
But
No
Yeah
But
No
But
Yeah

Comments

क्या हम लाइनों की एक सूची वापस कर सकते हैं?

— जो किंग

यह इस तरह के एक मजाकिया चाप के साथ काम करने के लिए मनोरंजक होना चाहिए! : थोड़ा अधिक गंभीर नोट पर: nrOfButsचर बल्कि खराब नाम और भ्रामक है। वैसे भी साधारण सी चुनौती।

— अरनुलद

यदि अंतिम पंक्ति है, तो क्या हमें एक बोनस मिलता है "भगवान विश्वास नहीं कर सकता कि आपने सिर्फ इतना कहा है!"

— सियारन_मकरपति

@EriktheOutgolfer ifs गिर गर्त और वर्तमान लूप में जारी रखें यदि उनकी स्थिति संतुष्ट थी।

— dzaima

अभी तक सबसे अधिक ऑस्ट्रेलियाई कोडगोल्फ? इसके अलावा "नाह" होना चाहिए

— नॉट -

Answer 1

एक्सेल, 78 बाइट्स

सेल A1 में इनपुट मानता है, और Wordwrap फॉर्मेटिंग सेल के लिए चालू है। स्ट्रिंग के भीतर लाइन फीड जोड़ने के लिए Alt + Enter का उपयोग करें और व्हाट्सएप पर ध्यान दें। आरईपीटी फ़ंक्शन की सीमा के कारण केवल 3570 तक इनपुट संभालता है (सौभाग्य है कि एक सेल को लंबा होना है, हालांकि)।

=LEFT(REPT("Yeah
But
No      
But     
Yeah    
But
No           
",595),A1*9)

व्हॉट्सएप के लिए पीरियड्स के साथ रिप्रिंटिंग

=LEFT(REPT("Yeah
But
No......
But.....
Yeah....
But
No...........
",595),A1*9)

यह कैसे काम करता है: पैटर्न हर 6 संख्याओं को दोहराता है:

0 = Yeah and But      Yeah + linefeed + But + linefeed
1 = No                No + 6 whitespace + line feed
2 = But               But + 5 whitespace + linefeed
3 = Yeah              Yeah + 4 whitespace + linefeed
4 = But and No        But + linefeed + No + 3 whitespace
5 = Blank             8 whitespace + linefeed

इनमें से प्रत्येक को 9 वर्णों के साथ व्यक्त किया जा सकता है, इसलिए एक स्ट्रिंग 54 वर्णों (9 * 6) से बना है, फिर एक्सेल के रूप में बड़े रूप में दोहराया जाएगा। फिर यह आउटपुट के रूप में बाएं 9 * (इनपुट की संख्या) अक्षर लेता है।

"लेकिन और कोई नहीं" के लिए लाइनफ़ीड को रिक्त के बाद रखा जाता है ताकि # 6, # 12, (आदि) के लिए हाँ को दाईं ओर के बजाय बाईं ओर स्वरूपित किया जाए, और ताकि कोई भी रिक्त लाइनफ़ीड हर 6 वीं पंक्ति में न जोड़ा जाए उस आइटम के लिए।

Comments

मेरे पास इसे सत्यापित करने का कोई तरीका नहीं है, लेकिन आपका वर्णन सही प्रतीत होता है। क्या आप कुछ उदाहरण इनपुट / आउटपुट जोड़े जोड़ सकते हैं? अधिक हास्यास्पद भाषाओं में से एक, लेकिन फिर भी महान जवाब।

— अधिकतम

@Maxb अन्य भाषाओं को पीटने पर यह सब हास्यास्पद नहीं हो सकता।

— कीता

महान व्याख्या और बहुत अच्छी तकनीक। LibreOffice Calc में भी काम करता है लेकिन प्रारूपण के साथ कुछ खेलने की आवश्यकता हो सकती है। +1

— एलपेड्रो

Answer 2

जावास्क्रिप्ट (ईएस 6), 59 57 बाइट्स

f=n=>n?f(n-1)+[s=n&1?`But
`:'',`Yeah
`+s,s+`No
`][n%3]:''

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

कैसे?

हम एक पुनरावर्ती फ़ंक्शन का उपयोग करते हैं जो 0 से n - 1 के बजाय से 1 तक जाता है ।$n$$1$$0$$n-1$

परिणामस्वरूप, संदर्भ कोड की तुलना में परीक्षण बंद हैं :$1$

• अगर , आउटपुट "हाँ"$n\equiv1\pmod 3$
• अगर , आउटपुट "लेकिन"$n\equiv1\pmod 2$
• अगर , आउटपुट "नहीं"$n\equiv2\pmod 3$

यह हमें सरल मामले को संग्रहीत करने देता हमारे देखने वालों की पहली प्रविष्टि, हम जहां परिभाषित कर सकते हैं के रूप में : एक चर होल्डिंग या तो या एक खाली स्ट्रिंग।$n\equiv0\pmod 3$$s$"But\n"

दो अन्य प्रविष्टियों को क्रमशः "Yeah\n" + sऔर s + "No\n"क्रमशः परिभाषित किया गया है।

नोट: से तक पुनरावृत्ति करके , हम पहली प्रविष्टि में को भी परिभाषित कर सकते हैं , लेकिन इसमें दो अतिरिक्त कोष्ठक होंगे ।0 $n-1$$0$$s$

टिप्पणी की गई

f = n =>            // n = input
  n ?               // if n is not equal to 0:
    f(n - 1) +      //   prepend the result of a recursive call with n - 1
    [               //   define our lookup array:
      s = n & 1 ?   //     1st entry: if n is odd:
        `But\n`     //       set s to "But"
      :             //     else:
        '',         //       set s to an empty string
      `Yeah\n` + s, //     2nd entry: "Yeah" followed by s
      s + `No\n`    //     3rd entry: s followed by "No"
    ][n % 3]        //   append the correct entry for this iteration
  :                 // else:
    ''              //   return an empty string and stop recursion

Answer 3

LOLCODE , 257 बाइट्स

HAI 1.2
I HAS A B
GIMMEH B
B IS NOW A NUMBR
I HAS A C ITZ 0
IM IN YR L UPPIN YR C TIL BOTH SAEM B AN C
I HAS A D ITZ MOD OF C AN 3
D
WTF?
OMG 0
VISIBLE "Yeah"
OIC
MOD OF C AN 2
WTF?
OMG 0
VISIBLE "But"
OIC
D
WTF?
OMG 1
VISIBLE "No"
OIC
IM OUTTA YR L
KTHXBYE

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

Comments

यह भयानक लग रहा है (मैं इसे कोड करने के लिए नफरत करता हूँ!), लेकिन परीक्षण के मामले में 10 द 2 "नहीं" और 3 जी "लेकिन" फ़्लिप हो गया ... तो हाँ, लेकिन नहीं: डी

— seadoggie01

वूप्स, मुझे लगा कि मैं वहां ऑप्टिमाइज़ कर सकता हूं। यह एक ट्रिकी पैटर्न है। मैंने अब इसे ठीक कर दिया।

— जोशियाहैन

मुझे यह

— पढने

क्या VISIBLE "But"कार्यक्रम में पतलून की कमी का उल्लेख है?

— JDL

Answer 4

व्हॉट्सएप , 315 304 300 277 276 बाइट्स

-11 बाइट्स के लिए @ जोकिंग के लिए धन्यवाद (8 से 7 तक इस्तेमाल किए गए लेबल की मात्रा को कम करना), और -24 अधिक बाइट्स (प्रोग्राम के सामान्य प्रवाह को बदलना और प्रक्रिया में 7 से 5 तक इस्तेमाल किए गए लेबल की मात्रा को कम करना)।

[S S S N
_Push_0][T  N
T   T   _Read_STDIN_as_integer][N
S S N
_Create_Label_LOOP][S S S N
_Push_0][T  T   T   _Retrieve][N
T   S S N
_If_negative_jump_to_Label_PRINT][S S S N
_Push_0][T  T   T   _Retrieve][S S S T  T   N
_Push_3][T  S T T   _Modulo][S S S T    S N
_Push_2][T  S S T   _Subtract][N
T   T   T   N
_If_negative_jump_to_Label_SKIP_NO][S S T   T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   T   N
_Push_7_o][S S T    T   T   S T S N
_Push_-26_N][N
S S T   N
_Create_Label_SKIP_NO][S S S N
_Push_0][T  T   T   _Retrieve][S S S T  S N
_Push_2][T  S T T   _Modulo][N
T   S S S N
_If_0_jump_to_Label_SKIP_BUT][S S T T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   S S N
_Push_12_t][S S S T T   S T N
_Push_13_u][S S T   T   S S T   T   S N
_Push_-38_B][N
S S S S N
_Create_Label_RETURN_FROM_BUT][S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T   T   T   _Retrieve][S S S T  N
_Push_1][T  S S T   _Subtract][T    T   S _Store][T T   T   _Retrieve][S S S T  T   N
_Push_3][T  S T T   _Modulo][N
T   S S T   N
_If_0_jump_to_Label_YEAH][N
S N
N
_Jump_to_Label_LOOP][N
S S S T N
_Create_Label_YEAH][S S T   T   S T T   T   T   S N
_Push_-94_\n][S S S N
_Push_0_h][S S T    T   T   T   N
_Push_-7_a][S S T   T   T   N
_Push_-3_e][S S T   T   T   T   T   N
_Push_-15_Y][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT][S S S T    T   S T S S S N
_Push_104][T    S S S _Add][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

पत्र S(स्थान), T(टैब), और N(नई-पंक्ति) केवल हाइलाइटिंग के रूप में जोड़े गए।
[..._some_action]केवल स्पष्टीकरण के रूप में जोड़ा गया।

इसे ऑनलाइन आज़माएं (कच्चे स्थान, टैब और नई-लाइनों के साथ ही)।

व्हॉट्सएप निश्चित रूप से इस चुनौती के लिए सही भाषा नहीं है .. व्हॉट्सएप में दोनों लूप्स और अगर-स्टेटमेंट्स लेबल के साथ दिए गए हैं और लेबल के लिए कूदते हैं, और चूंकि वे if-ifif-अन्यथा मामले नहीं हैं, लेकिन कई if- केस हैं, तो इसका मतलब है कि मैं प्रत्येक के बाद वापस कूदना होगा, अगर यह काफी लंबा है तो इसका मतलब है कि मुझे कुछ प्रिंटों को छोड़ने के लिए चेक को थोड़ा संशोधित करना होगा (धन्यवाद @JoKing )।

छद्म कोड में स्पष्टीकरण:

Read STDIN as integer, and store it in the heap
Start LOOP:
  Integer i = retrieve integer from heap
  If(i is negative):
    Call function PRINT
  If(i modulo-3 is NOT 2):
    Jump to Label SKIP_NO
  Push "\noN" to the stack
  Label: SKIP_NO
  If(i modulo-2 is 0):
    Jump to Label SKIP_BUT
  Push "\ntuB" to the stack
  Label: SKIP_BUT
  i = i - 1
  Replace i in the heap with this updated value
  If(i modulo-3 is 0):
    Call function YEAH
  Go to next iteration of LOOP

function YEAH:
  Push "\nhaeY" to the stack
  Go to next iteration of LOOP

function PRINT:
  Print top of the stack as character to STDOUT
  Go to next iteration of LOOP (which will enter the if and then
                                comes back to this PRINT again)

अतिरिक्त स्पष्टीकरण:

सामान्य तौर पर, यह 0 से नीचे इनपुट से लूप करता है, एक नई रेखा और शब्द को उलट देता है (इसलिए क्रम में "\ noN", "\ ntuB", "\ nhaeY" के बजाय "यस \ n", "बट \ n" "," नहीं \ n ")। और इनपुट 0 से नीचे जाने के बाद और सभी अक्षर स्टैक पर हैं, यह उन वर्णों को रिवर्स में प्रिंट करेगा (इसलिए सही आउटपुट)।

हालाँकि गहराई में अधिक: हालाँकि हमें रेंज में शब्दों को प्रिंट करने की आवश्यकता है (input, 0], लेकिन यह [input, 0)इसके बजाय रेंज में लूप करेगा । इस वजह से, हम if(i%3 == 2)"\ noN" के लिए चेक का उपयोग कर सकते हैं (या वास्तव में, if(i%3 != 2)"\ noN" के पुश को छोड़ दें), और हम if(i%2 != 1)"\ ntuB" के लिए चेक का उपयोग करते हैं (या वास्तव में, if(i%2 == 0)"\ ntuB" के पुश को छोड़ दें) )। इन दो जांचों के बाद ही हम पुनरावृत्ति iको कम करते हैं 1. और फिर if(i%3 == 0)"\ nhaeY" को आगे बढ़ाने के लिए चेक करते हैं , जैसा कि चुनौती विवरण में JS उदाहरण कोड के समान है। एक लेबल पर जाने के बजाय यदि चेक नहीं है, तो स्किप करना और यदि आई-चेक से 23 बाइट्स बचते हैं, तो लेबल से वापस लौटना।

इसके अलावा, श्वेत रिक्ति में चरित्र मूल्यों ढेर में अपने यूनिकोड मूल्यों के रूप में (यानी जमा हो जाती है 10नई लाइनों के लिए, 65के लिए 'ए', 97'एक', आदि के लिए)। चूंकि मुझे पहले से ही पात्रों को प्रिंट करने के लिए स्टैक पर लूप की आवश्यकता है, इसलिए मैं वर्णों के रूप में प्रिंट करने से पहले, संख्या मूल्यों में एक निरंतर जोड़कर बाइट-काउंट को कम करने के लिए अपने व्हाट्सएप टिप का उपयोग करने में सक्षम हूं ।
यह स्थिरांक 104इस मामले में है, जो कि इस जावा प्रोग्राम के साथ उत्पन्न होता है, जिसका उपयोग मैंने पहले एक और व्हॉट्सएप के जवाब के लिए किया था । यही कारण है कि इस कोड का हिस्सा:

[S S T  T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   T   N
_Push_7_o][S S T    T   T   S T S N
_Push_-26_N]

-94नईलाइन के लिए मान हैं , 7'ओ' के लिए, और -26'एन' के लिए। वजह से लगातार जोड़ने 104इच्छा सही ढंग से हमारे यूनिकोड मान देना 10, 111, और 78क्रमशः इन पात्रों के लिए।

Comments

मैं निश्चित रूप से एक व्हॉट्सएप जवाब की उम्मीद नहीं करता था। बहुत बढ़िया!

— अधिकतम

@ मोमक्स थैंक्स! दुर्भाग्य से यह 8 लेबल की आवश्यकता के कारण अपेक्षा से काफी लंबा है .. लेकिन मुझे पहले से ही खुशी है कि यह काम कर रहा है। :)

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

यदि स्थिति गलत है तो क्या आप अगले बयान के लिए लंघन द्वारा लेबल को आधा नहीं कर सकते हैं? जैसेif i modulo-3 != 1 jump to next if else push NO

— Jo King

@JoKing आह रुको, मुझे आपके छद्म कोड का एक हिस्सा गलत लगा। सच iहोने से पहले पुनर्प्राप्त न करने के बारे में मेरा पहला मुद्दा if(i is 0) call PRINTहै, लेकिन आपके अन्य iइसे घटाने और प्रिंट करने से पहले जाँच कर रहे हैं । वास्तव में बहुत सुंदर। इसे लागू करना जारी रखेंगे।

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

ठीक है, यदि आप लूप की शुरुआत में कूदते हैं, तो यह इफ स्टेटमेंट को फिर से चलाएगा और सीधे प्रिंट फ़ंक्शन पर वापस कूद जाएगा। शायद यह एक बाइट बचाता है यदि आप लूप लेबल को खाली लेबल पर बदलते हैं

— जो किंग

Answer 5

पायथन 3 , 85 82 बाइट्स

def f(n):
 for i in range(n):yield from['Yeah'][i%3:]+['But'][i%2:]+['No'][i%3^1:]

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

---

पायथन 3 , 79 76 बाइट्स

पोर्ट ऑफ़ केटा का एक्सेल उत्तर ।

lambda n:(f"""Yeah
But
No      
But     
Yeah    
But
No{'':11}
"""*n)[:9*n]

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

Answer 6

पर्ल 6 , 63 50 बाइट्स

{<<"Yeah But"No But Yeah"But No">>[^$_ X%6].words}

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

अनाम कोड ब्लॉक जो एक नंबर लेता है और लाइनों की एक सूची देता है

स्पष्टीकरण:

{                                                }   # Anonymous code block
 <<"Yeah But"No But Yeah"But No">>  # Create the list of strings:
                                     # Yeah But
                                     # No
                                     # But
                                     # Yeah
                                     # But No
                                  [       ]  # Index into this list
                                   ^$_  # The range from 0 to n-1
                                       X%6  # All modulo 6
                                           .words  # Convert the list to a string 
                                                   # Which joins by spaces
                                                   # And split by whitespace

Answer 7

सी (जीसीसी) , 75 बाइट्स

f(o,_){for(_=0;o-_;_++%3-1||puts("No"))_%3||puts("Yeah"),1&_||puts("But");}

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

---

C (gcc) , 60 + 11 = 71 बाइट्स (उपयोग करना -D$=||puts()

f(o,_){for(_=0;o-_;_++%3-1 $"No"))_%3 $"Yeah"),1&_ $"But");}

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

Answer 8

05AB1E (विरासत) , 27 25 24 बाइट्स

केविन क्रूज़सेन को 1 बाइट धन्यवाद दिया ।

F”¥æ€³€¸”#N3ÖNÈN3%‚‚˜Ï`»

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

व्याख्या

F                          # for N in [0 ... input] do:
 ”¥æ€³€¸”#                 # push ['Yeah', 'But', 'No']
          N3Ö              # push N % 3 == 0
             NÈ            # push N % 2 == 0
               N3%         # push N % 3
                  ‚‚˜      # add the 3 numbers to a list
                     Ï     # keep only the strings whose corresponding value  
                           # in the int list is true (1)
                      `»   # push strings separately to stack and join stack on newlines

Comments

डांग, आपने मुझे इसके लिए हराया .. एक जवाब पोस्ट करने के बारे में था। तुम्हारा वैसे भी कम है, इसलिए मुझ से +1 .. का अच्छा उपयोग ×, के बारे में सोचा नहीं था!

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

वाह, मुझे इस पर एक स्पष्टीकरण अच्छा लगेगा। CJam में मेरा व्यक्तिगत सर्वश्रेष्ठ 44 बाइट्स था।

— अधिकतम

@ maxb: मैं निश्चित रूप से एक स्पष्टीकरण जोड़ूंगा। मैं सिर्फ यह देखने के लिए जाँच कर रहा हूं कि क्या मैं इसे पहले कुछ और नीचे गिरा सकता हूं?)

— एमिग्ना

Θअब आप वह उपयोग हटा सकते हैं जिसका आप अब उपयोग नहीं कर रहे हैं ×, क्योंकि Ïयह केवल केवल 1s पर दिखेगा , इसलिए यह 2(और 0निश्चित रूप से) अनदेखा करता है ।

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

@ केविनक्रूजसेन: धन्यवाद! यकीन नहीं होता कि मैं कैसे चूक गया: P

— एमिग्ना

Answer 9

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

lambda n:'\n'.join((["Yeah\nBut","No","But","Yeah","But\nNo"]*n)[:n-n/6])

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

Answer 10

पायथन 2 , 97 95 92 90 83 81 बाइट्स

lambda n:[w for i in range(n)for w in'Yeah','But','No'if('N'in w)==i%(3-(w<'N'))]

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

_{-2 बाइट्स, ओव्स के लिए धन्यवाद}

---

पायथन 3 , 92 90 85 83 बाइट्स

lambda n:[w for i in range(n)for w in['Yeah','But','No']if('N'in w)==i%(3-(w<'N'))]

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

_{-4 बाइट्स, ओव्स के लिए धन्यवाद}

-4 बाइट्स, जो किंग के लिए धन्यवाद

Comments

दोनों को मिलाकर 86 बाइट्स और लाइनों की एक सूची के रूप में वापसी

— जो किंग

@JoKing धन्यवाद, मुझे नहीं पता था कि मैं इसे लिखने के बजाय मुद्रण के बजाय वापस आ सकता हूं।

— TFeld

82 बाइट्स : len(w)<3-> 'N'in w, 81 बाइट्स : len(w)%2->(w<'N')

— ovs

Answer 11

कैनवस , 27 बाइट्स

｛╷⌐３％‽YeahＰ｝２％‽ButＰ｝３％╷‽NoＰ

यहाँ कोशिश करो!

Answer 12

ग्रूवी (फ़ंक्शन), 79 बाइट्स

शुरू में अपना जवाब प्रस्तुत करने के बाद से, मैंने यहां कुछ ऐतिहासिक चर्चाओं के माध्यम से देखा है कि एक उपयुक्त उत्तर क्या है। चूंकि यह आमतौर पर जावा (रिटर्न प्रकार और पैरामीटर घोषणाओं सहित) में एक विधि प्रदान करने के लिए स्वीकार किया जाता है, यहां एक छोटा, ग्रूवी, विधि है जो विधि वापसी मूल्य का जवाब है। उपयोग का defमतलब है कि वापसी प्रकार का अनुमान है।

def a(int n){n?a(--n)+(n%3?'':'Yeah\n')+(n%2?'':'But\n')+(n%3==1?'No\n':''):''}

नीचे दिए गए मूल उत्तर के विपरीत, जो 0 से n-1 तक लूप करता है, यह खुद को n से 1 तक कॉल करता है, लेकिन पुनरावर्ती कॉल में शेष पंक्ति के लिए इनपुट को घटाता है।

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

ग्रूवी (कार्यक्रम), 87 बाइट्स

ग्रूवी स्क्रिप्ट को कुछ सामान्य आयातों की आवश्यकता नहीं होती है, इसलिए यह System.out.पहले घोषित किए बिना जावा के एसटीडीयूएस के उत्तर को प्रिंट करने वाला कार्यक्रम हो सकता है print। यह कुछ सामान्य उपयोगिता विधियाँ भी प्रदान करता है, जैसे कि यह toLong()हमें इनपुट तर्क को यथोचित रूप से पार्स करने की अनुमति देता है।

अनिवार्य रूप से जावा 10 का उत्तर है, लेकिन ग्रूवी के छोटे लूप सिंटैक्स का लाभ उठाते हुए और सत्य कथन का मूल्यांकन करने की क्षमता।

args[0].toLong().times{print((it%3?'':'Yeah\n')+(it%2?'':'But\n')+(it%3==1?'No\n':''))}

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

Comments

PPCG में आपका स्वागत है! शानदार पहला जवाब! मैंने खुद किसी ग्रूवी को कोड नहीं किया है, लेकिन क्या मैं सुझाव दे सकता हूं कि आपका कोड TIO पर चल रहा है ? इस तरह, यह दूसरों द्वारा मान्य किया जा सकता है, और सभी द्वारा आनंद लिया जा सकता है।

— अधिकतम

@ मोमक्स थैंक्स! मैंने एक जोड़ा है :)

— archangel.mjj

अच्छा पहला उत्तर और पीपीसीजी में भी आपका स्वागत है।

— एलपेड्रो

Answer 13

रेटिना 0.8.2 , 45 बाइट्स

.+
$*
1
$`Yeah¶$`But¶$`11No¶
+`11B
B
111

A`1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
$*

इनपुट को unary में कनवर्ट करें।

1
$`Yeah¶$`But¶$`11No¶

प्रत्येक पूर्णांक के लिए 0...n-1, पाठ की तीन पंक्तियों को उत्पन्न करें, प्रत्येक शब्द के लिए एक, प्रत्येक को i 1इसके पहले एस के अलावा No, जिसके लिए दो अतिरिक्त 1s हैं ताकि हम गणना करें (i+2)%3==0जो कि के बराबर है i%3==1।

+`11B
B

1S से पहले Bs के जोड़े निकालें ।

111

1तीनों के समूहों में हर जगह निकालें ।

A`1

सभी पंक्तियों को हटा दें जो अभी भी हैं 1।

Comments

ओह, अब जब मैं 11No¶गणना करने के लिए देख रहा हूं (i+2)%3==0(इसलिए सभी तीनों अगर-के लिए चेक हैं ==0) तो यह बहुत स्पष्ट दिखता है, लेकिन मैंने खुद के बारे में नहीं सोचा होगा, इसलिए यह वास्तव में काफी सरल है। +1 मुझसे, अच्छा जवाब!

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

Answer 14

जावा 10, 100 99 बाइट्स

n->{for(int i=0;i<n;)System.out.print((i%3<1?"Yeah\n":"")+(i%2<1?"But\n":"")+(++i%3>1?"No\n":""));}

-1 बाइट @ ओलिवियरग्रेगायर के लिए धन्यवाद ।

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

स्पष्टीकरण:

n->{                   // Method with integer parameter and no return-type
  for(int i=0;i<n;)    //  Loop `i` in the range [0, `n`)
    System.out.print(  //   Print to STDOUT:
      (i%3<1?          //    If `i` is divisible by 3:
        "Yeah\n"       //     Print "Yeah" with newline
      :"")+(i%2<1?     //    If `i` is even:
        "But\n"        //     Print "But" with newline
      :"")+(++i%3>1?   //    If `i` modulo-3 is 1:
        "No\n"         //     Print "No" with newline
      :                //    If none of the above three if's applied to the current `i`:
       ""));}          //     Print nothing for the current `i`

Comments

++i%3>1संभावना है कि आप एक बाइट बचा लेंगे

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

@ ओलिविएरग्रेयर आह, बिल्कुल। धन्यवाद!

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

Answer 15

पॉवर्सशेल, 75 74 72 67 66 बाइट्स

-1 बाइट धन्यवाद TessellatingHeckler

param($n)(" Yeah
But No But Yeah But
No "*$n-split' ')[1..$n]-ne''

टेस्ट स्क्रिप्ट और स्पष्टीकरण:

$f = {

param($n)(" Yeah
But No But Yeah But
No "*$n-split' ')[1..$n]-ne''

# 1. repeat the string $n times
# 2. split by space
# 3. get elements from 1 to $n
# some elements are multiline strings, some elements are $null:
# ($null,"Yeah`nBut","But","No","But","Yeah","But`nNo",$null,...)
# 4. remove $null elements from result array

}

# Output results
@(
    0,1,2,10
) | % {
    &$f $_
    "======"
}

# Advanced test
@(
    ,(0,'')
    ,(1,'Yeah But')
    ,(2,'Yeah But No')
    ,(3,'Yeah But No But')
    ,(4,'Yeah But No But Yeah')
    ,(5,'Yeah But No But Yeah But No')
    ,(6,'Yeah But No But Yeah But No')
    ,(7,'Yeah But No But Yeah But No Yeah But')
    ,(8,'Yeah But No But Yeah But No Yeah But No')
    ,(9,'Yeah But No But Yeah But No Yeah But No But')
    ,(10,'Yeah But No But Yeah But No Yeah But No But Yeah')
    ,(20,'Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No')
) | % {
    $n,$e = $_
    $r = &$f $n
    $r = $r-split"`n"       # simplify test string
    "$($e-eq$r): $n : $r"
}

आउटपुट:

======
Yeah
But
======
Yeah
But
No
======
Yeah
But
No
But
Yeah
But
No
Yeah
But
No
But
Yeah
======
True: 0 :
True: 1 : Yeah But
True: 2 : Yeah But No
True: 3 : Yeah But No But
True: 4 : Yeah But No But Yeah
True: 5 : Yeah But No But Yeah But No
True: 6 : Yeah But No But Yeah But No
True: 7 : Yeah But No But Yeah But No Yeah But
True: 8 : Yeah But No But Yeah But No Yeah But No
True: 9 : Yeah But No But Yeah But No Yeah But No But
True: 10 : Yeah But No But Yeah But No Yeah But No But Yeah
True: 20 : Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No

सीधी स्क्रिप्ट, 72 बाइट्स:

$args|?{$_}|%{0..--$_|%{@('Yeah')[$_%3]
@('But')[$_%2]
@{1='No'}[$_%3]}}

Comments

बहुत बढ़िया जवाब! क्या उत्तर में कुछ आउटपुट जोड़ना संभव होगा, क्योंकि इसमें ऑनलाइन दुभाषिया शामिल नहीं है?

— अधिकतम

उत्तर स्क्रिप्टब्लॉक वापस नहीं आता है ======। यह Yeah,But,Noकेवल तार उत्पन्न करता है । परीक्षण स्क्रिप्ट केवल परिणामों के आसान पढ़ने के लिए एक विभाजक दिखाती है।

— माज़ी

यह हैशटेबल उपयोग चतुर है। मुझे याद रखने की जरूरत है।

— AdmBorkBork

@maxb - 67 बाइट के जवाब के लिए

— TessellatingHeckler

@ mazzy मैं आपका सुधार कर सकता हूं, लेकिन फिर भी 67 को हरा नहीं सकता (दो \ n को वास्तविक नई लाइनों के साथ बदलें)(" Yeah\nBut No But Yeah But\nNo "*($j="$args")|% s*t 32)[1..$j]-ne''

— TessellatingHeckler

Answer 16

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

f n=[1..n]>>=(3?1)"Yeah"<>(2?1)"But"<>(3?2)"No"
(a?b)c n=[c|n`mod`a==b]

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

व्याख्या

बहुत आसान है, और के [1..n]बजाय का उपयोग करके दो बाइट्स बचा लिया [0..n-1]और समायोजित: ऑपरेटर (?)परीक्षण चार तर्क लेता है, एक खाली सूची या एक स्ट्रिंग के रूप में प्रदान की स्ट्रिंग वापस अगर परिणाम सही है।

चौथे तर्क पर अंकुश लगाकर, (?)हम (<>)प्रत्येक फ़ंक्शन के परिणामों का उपयोग कर सकते हैं , अर्थात:

(3?1)"Yeah" <> (2?1)"But" <> (3?2)"No" ≡ \i-> (3?1)"Yeah" i ++ (2?1)"But" i ++ (3?2)"No" i

Answer 17

C # (विजुअल C # इंटरएक्टिव कंपाइलर) , 105 99 94 96 89bytes

i=>{for(int x=0;x<i;)Write((x%3<1?"Yeah\n":"")+(x%2<1?"But\n":"")+(x++%3==1?"No\n":""));}

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

Comments

इस तरह प्रक्षेप को हटाने से 7 बाइट्स की बचत होती है।

— एमिग्ना

@Eignign टिप के लिए धन्यवाद, जवाब बदल दिया

— auhmaan

x++%3==1?हो सकता है ++x%3>1?। किसी और ने सिर्फ मेरे जावा उत्तर के लिए इसे इत्तला दे दी, लेकिन वही आपके C # उत्तर पर लागू होता है। :)

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

Answer 18

पिप , 37 35 33 बाइट्स

"But 
Yeah
No
"<>5@:^[t2io02x]@<a

(नोट के बाद के स्थान पर ध्यान दें But।) इनपुट को कमांड-लाइन तर्क के रूप में लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

यह स्पष्टीकरण पिछले संस्करण के लिए है - चैंज के लिए नीचे देखें

जो किंग के पर्ल 6 जवाब से प्रेरित है । हम इस सूची का निर्माण करते हैं:

[
 "Yeah
 But
 ";
 "No
 ";
 "But
 ";
 "Yeah
 ";
 "But
 No
 ";
 ""
]

और aचक्रीय अनुक्रमण का उपयोग करके इसके पहले तत्वों का उत्पादन करते हैं ।

[t2io02x]R,3["But""Yeah""No"].n@<:a
                                     i is 0; o is 1; t is 10; x is ""; n is newline;
                                     a is 1st cmdline arg (implicit)
[       ]                            Construct this list of scalars:
 t                                    10
  2                                   2
   i                                  0
    o                                 1
     02                               02
       x                              <empty string>
         R                           Treating each of these as a string, we're going to
                                     replace:
          ,3                          0, 1, and 2 (respectively)
                                     with the corresponding values from this list:
            ["But""Yeah""No"].n       These strings, each with a newline appended
                                     We now have constructed the list shown above
                               @<:a  Take the first a elements from this list, with
                                     cyclical indexing (the : is for parsing reasons)
                                     Concatenate them together and print (implicit)

अद्यतन: मुझे एहसास हुआ कि मुझे 0/1/2 को तार में बदलने के लिए प्रतिस्थापित करने की आवश्यकता नहीं है - मैं उन संख्याओं को सीधे सूची में सूचीबद्ध करने के लिए उपयोग कर सकता हूं। ऐसा करने के लिए, हमें यह सुनिश्चित करना होगा कि बहु अंकों की संख्या उनके अंकों की सूची में विभाजित है (अन्यथा, हम अनुक्रमित 1 और 0 के बजाय सूचकांक 10 का चयन करेंगे)। सौभाग्य से, पिप में एक अनुक्रमणिका के रूप में एक मनमाने ढंग से नेस्टेड सूची का उपयोग करना अपेक्षित परिणाम की सूची (नेस्टेड) ​​देता है। 3 के इनपुट के लिए, हमें यह डेटा प्रगति (जहां _एक नई पंक्ति का प्रतिनिधित्व करता है) मिलती है :

"But _Yeah_No_"<>5                       ["But _"; "Yeah_"; "No_"]
                     [t2io02x]           [10; 2; 0; 1; 02; ""]
                              @<a        [10; 2; 0]
                    ^                    [[1; 0]; [2]; [0]]
                  @:                     [["Yeah_"; "But _"]; ["No_"]; ["But _"]]

पहले की तरह, अंतिम परिणाम एक साथ और स्वत: स्फूर्त है।

Answer 19

अटैच , 48 बाइट्स

Flat##{Mask[_%3'2'3=0'0'1,$Yeah'$But'$No]}=>Iota

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

व्याख्या

Flat##{Mask[_%3'2'3=0'0'1,$Yeah'$But'$No]}=>Iota   input: an integer
      {                                  }=>Iota   over each number from 0 to that integer exclusive
       Mask[             ,$Yeah'$But'$No]          select values from that array according to:
            _%3'2'3                                    whether or not the input mod 3, 2, 3
                   =0'0'1                              is 0, 0, 1
Flat##                                             flatten the intermediate results

Answer 20

सी (जीसीसी) , 77 71 74 72 69 बाइट्स

यहाँ पहले से ही एक बेहतर C उत्तर है लेकिन यह एक पुनरावर्ती है और मुझे सीधे होने में कुछ समय लगा इसलिए मैं इसे पोस्ट कर रहा हूं।

नीचे 69 बाइट्स के लिए @ceilingcat और @JonathanFrech दोनों को धन्यवाद

(मैं n-i + 1 के स्थान पर n- ~ -i का उपयोग करने के लिए कभी नहीं सोचता)

i;f(n){i=n&&n-i>=~n/6&&f(n,i++,puts(i%7%4?i%7%2?"But":"No":"Yeah"));}

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

Comments

@JonathanFrech अच्छा है, लेकिन शून्य के लिए काम नहीं करता है, या 5

— Cleblanc

@ अंकलचैन ओह, सॉरी। एहसास नहीं हुआ ... कम से कम हटाने jसे आपको दो बाइट्स मिले।

— जोनाथन फ्रेच

70 बाइट्स - @ सीलिंगकैट के एक सेव बाइट को शामिल करना।

— जोनाथन फ्रीच

n-~-iके बराबर है n-i+1- नहीं i<n+1- और इसलिए वास्तव में किसी भी बाइट को नहीं बचाता है ...

— जोनाथन फ्रीच

Answer 21

रूबी, ६ ९ 72 74 बाइट्स

->y{puts *(1..y).map{|i|[i%3==1&&:Yeah,i%2>0&&:But,i%3>1&&:No]-[!0]}}

बहुत सीधे-सीधे उत्तर, अभी कम, पुनरावर्ती विधि के लिए जाँच कर रहा है।

दो बाइट्स @BWO के लिए धन्यवाद बचाए गए :)

तार के बजाय प्रतीकों का उपयोग करके एक और तीन बाइट्स को बचाया

Answer 22

पायथन 3, 93 बाइट्स

[print("Yeah\n"*(i%3<1)+"But\n"*(i%2<1)+"No\n"*(i%3==1),end="")for i in range(int(input()))]

यह वास्तव में सबसे अच्छा समाधान नहीं है, लेकिन यह मेरी इस पर है।

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

Comments

यदि आपके पास पहले से ही एक अभिव्यक्ति है, तो आप एक सूची समझ में उपयोग कर सकते हैं, लेकिन आपकी सूची समझ केवल उस अभिव्यक्ति के दुष्प्रभाव को पैदा करने के लिए मौजूद है, लूप के लिए एक सादे को कम बाइट्स की आवश्यकता होती है।

— जोनाथन फ्रीच

Answer 23

आर, 65 बाइट्स

cat(c("yeah","but","no")[c(3,1:3,2,1,2)][1:scan()%%7+1],sep="\n")

इस तथ्य के कारण कि हम थोड़ा त्रुटिपूर्ण कार्यक्रम की नकल कर रहे हैं (यह हर चौथे को याद करता है "लेकिन" - इसका उपयोग करना चाहिए था %4 == 1और शर्तों के %4 == 3बजाय %3), हमें cबेस सात में एक अजीब कॉल का उपयोग करना होगा और काम करना होगा। फिर भी, यह LOLCODE से छोटा है ...

(मैं उम्मीद कर रहा था कि (३,१,२,३,२,१,२,२) या इसी तरह की क्रमपरिवर्तन lhकहीं डेटासेट में दिखाई दे सकती है लेकिन यह ऐसा नहीं दिखता है)

Answer 24

एसईडी -E ,179 150 बाइट्स

/^0/!s:$:g:
:l;y:abcdefg:bcdefga:
/[ae]/iYeah
/[bdf]/iBut
/[cg]/iNo
s:.$:-&:;:s;s:0-:-9:;ts;h
y:123456789:012345678:;G
s:.*(.)-.*\n(.*).-:\2\1:;tl;c\ 

सबसे कठिन हिस्सा सूची का निर्माण नहीं करना था बल्कि वास्तव में दशमलव संख्या को पार्स करना था।

2 बाइट्स बचाया जा सकता है, तो अंत में न्यू लाइन की आवश्यकता नहीं है: c\ → d।

अभी भी अनुकूलन की आवश्यकता है।

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

व्याख्या

/^0/!                            | if the input number doesn`t begin with a '0'…
     s:$:g:                      | …then append a 'g' to it and proceed
                                 |
:l;                              | loop label 'l':
   y:abcdefg:bcdefga:            | shift all occurences of [abcdef] 1 letter forward, and all 'g'-s to 'a'-s
                                 |
/[ae]/                           | if there`s an 'a' or 'e' in the input…
      iYeah                      | …output 'Yeah'
                                 |
/[bdf]/                          | if there`s a 'b' or 'd' or 'f' in the input…
       iBut                      | …output 'But'
                                 |
/[cg]/                           | if there`s a 'c' or 'g' in the input…
      iNo                        | …output 'No' 
                                 |
s:.$:-&:;                        | insert '-' before the last character
         :s;                     | loop label 's':
            s:0-:-9:;            | transform the next consecutive '0' in the end of the number to '9', if any
                     ts;         | loop to 's' if more consecutive zeroes are available
                        h        | copy the result to the temporary buffer
                                 |
y:123456789:012345678:;          | decrement all digits except '0' (N.B.: digits, not numbers)
                       G         | append the temporary buffer to the result
                                 |
s:.*(.)-.*\n(.*).-:\2\1:;        | cut and replace the digit left to the last consecutive 0 in the original
                                 | number pasted from the temporary buffer, then discard all other digits decremented
                         tl;     | …then loop to 'l' if the number is ≥0
                            c\   | insert a carriage return and exit

Comments

क्या आप कृपया कुछ स्पष्टीकरण जोड़ सकते हैं?

— user285259

@ user285259 किया।

— Hidefromkgb

Answer 25

क्लीन , 116 बाइट्स

import StdEnv,Data.List
r=cycle
$n=[e\\_<-[1..n]&a<-r["Yeah","",""]&b<-r["But",""]&c<-r["","No",""],e<-[a,b,c]|e>""]

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

Answer 26

एफ #, 108 106 बाइट्स

let v p=seq{for i=1 to p do
 if i%3=1 then yield"Yeah"
 if i%2=1 then yield"But"
 if i%3=2 then yield"No"}

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

-2 से बदल रहा है बाइट i=0 to p-1के लिए i=1 to pऔर modulos का समायोजन। इसके अलावा, बहुत सीधे-आगे।

Comments

मुझे TIO लिंक के लिए किसी प्रकार की बिल्ड एरर मिलती है, शायद टेस्टिंग कोड में कोई सिंटैक्स त्रुटि?

— अधिकतम

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

— सियारन_मकरपति

i=1 to p(स्वाभाविक रूप से, और स्वाभाविक रूप से समायोजन) के साथ 2 बाइट्स दाढ़ी । रिवर्स रेंज खाली हैं। :)

अच्छा! मैंने वह जोड़ा है। धन्यवाद! :)

— सियारन_मकरपेटी

Answer 27

PHP, 65 68 बाइट्स

while($i<$argn)echo["Yeah
"][$i%3],["But
"][$i%2],["No
"][~-$i++%3];

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

Comments

यह अच्छा लग रहा है, लेकिन यह एन = 10 के लिए बीच में एक अतिरिक्त न्यूलाइन का उत्पादन करता है

— 21

@ maxb संकेत के लिए धन्यवाद। मैं इसे 9 अतिरिक्त बाइट्स के साथ तय कर सकता था; लेकिन दूसरा तरीका छोटा है।

— टाइटस

Answer 28

VBA (एक्सेल), 105, 101, 99 बाइट्स

संपादित करें: केटा से -4 बाइट्स! धन्यवाद!

क्रोनोसाइडल से 2: -2 बाइट्स संपादित करें! यहाँ प्रारंभ करें (एहसास हुआ कि परीक्षण मामलों में केवल 10. के लिए काम किया गया था)

हाँ, एक्सेल ने इस बार VBA को हराया। जो कुछ। (हम आपके लिए आ रहे हैं)

d=vbCr:For i=1To[a1]:a=i Mod 3:?IIf(a=1,"Yeah"+d,"")IIf(i/2=i\2,"","But"+d)IIf(a=2,"No"+d,"");:Next

^ यह तत्काल विंडो में चिपकाया जाता है और डिबग विंडो में आउटपुट होता है

Ungolfed

d = vbCr
'For 1 to the value in A1 (using 0 gave extra values, and VBA skips the for loop if 0)
For i = 1 To [a1]    'aka: Range("A1").value
    a = i mod 3
    '? is the same as Print (Debug.Print when not in the Immediate Window)
    Print IIf(a = 1, "Yeah" + d, "") _ '<-- Just a line continuation
          'Keeta taught me that the \ operator is division with truncation,
          '     so if they are equal then there is no remainder!
          IIf(i / 2 = i \ 2, "", "But" + d) _
          IIf(a = 2, "No" + d, "");
    'Print usually prints a newline, but it still outputs if the string is blank...
    '   So we append a newline -if true- and use a semi-colon to kill the newline
Next

Comments

@Keeta अच्छा विचार है, लेकिन नहीं ... यदि आप मेरे पहले कोड को देखते हैं, तो मैं [a1] का उपयोग करता हूं जिसका अर्थ है रेंज / सेल .value :) मुझे इसे और अधिक स्पष्ट करना चाहिए जो एक स्पष्टीकरण था, हालांकि, क्षमा करें: /

— seadoggie01

हाँ, मैंने देखा और टिप्पणी को हटाने की कोशिश की। मैं कैसे के बारे में i / 3 = i \ 3 के बजाय i mod 3 = 0 (और वही mod 2 = 0 के लिए) का उपयोग कर रहा हूं। यह कोशिश नहीं की है, लेकिन यह काम करेगा?

— कीता

@Keeta मैंने पहले कभी भी ऑपरेटर को नहीं देखा है ... मुझे ऐसा नहीं लगता है, हालांकि, यह शेष के बिना विभाजन का मूल्य लौटाता है ... जैसे कि मुझे लगता है कि मॉड के विपरीत

— seadoggie01

एक पूर्णांक विभाजन है और एक अस्थायी बिंदु है। 7/3 = 2.3333 जहां 7 \ 3 = 2 (छोटा विभाजन)। 6/3 2 होना चाहिए, और 6 \ 3 भी 2 होना चाहिए ताकि जब भी शेष हो तो यह काम करना चाहिए (मुझे लगता है)।

— कीता

VBA स्वचालित रूप से फ़ंक्शन आउटपुट को &IIf(..)

— सुगम बना

Answer 29

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

5Rż7FṚṁị“'⁴\ÆẓNƇ»ḲŒP¤Ẏ

एक विवादास्पद लिंक लाइनों की सूची (जो टिप्पणियों में अनुमति दी गई है लगता है)

इसे ऑनलाइन आज़माएं! (पाद लेख लिंक का उपयोग करके कॉल करता हैÇऔर नईलाइन्स के साथ जुड़ता हैYजो जेली में निहित मुद्रण के बाद से सब कुछ एक साथ स्मैश करता है यदि यह हो सकता है)

कैसे?

$2\times3=6$

अब ध्यान दें कि पहले छह मान हैं:

["Yeah", "But"]
["No"]
["But"]
["Yeah"]
["But", "No"]
[]

तो लाइनों की परिणामी सूची को इन मूल्यों को दोहराया जाना चाहिए (या छोटा कर दिया जाना चाहिए) nएक साथ लंबाई के साथ।

अब ध्यान दें कि पावर-सेट "Yeah", "But", "No"है:

[]
["Yeah"]
["But"]
["No"]
["Yeah", "But"]
["Yeah", "No"]
["But", "No"]
["Yeah", "But", "No"]

इसलिए प्रत्येक अवधि बिजली के सेट के इन 1-अनुक्रमित मूल्यों की है "Yeah", "But", "No":

5, 4, 3, 2, 7, 1

कोड इस सूची को बनाता है, इसे लंबाई nमें ढालता है, पावर-सेट में अनुक्रमित करता है, और फिर आंतरिक सूचियों को निकालता है (जो खाली तारों को भी हटा देता है, क्योंकि स्ट्रिंग्स जेली में सूचीबद्ध हैं) ...

5Rż7FṚṁị“'⁴\ÆẓNƇ»ḲŒP¤Ẏ - Link: integer, n   e.g. 10
5                      - literal five            5
 R                     - range                   [1,2,3,4,5]
   7                   - literal seven           7
  ż                    - zip together            [[1,7],[2],[3],[4],[5]]
    F                  - flatten                 [1,7,2,3,4,5]
     Ṛ                 - reverse                 [5,4,3,2,7,1]
      ṁ                - mould like (n)          [5,4,3,2,7,1,5,4,3,2]
                    ¤  - nilad followed by link(s) as a nilad:
        “'⁴\ÆẓNƇ»      -   compressed string     "Yeah But No"
                 Ḳ     -   split at spaces       ["Yeah","But","No"]
                  ŒP   -   power-set             [[],["Yeah"],["But"],["No"],["Yeah","But"],["Yeah","No"],["But","No"],["Yeah","But","No"]]
       ị               - index into              [["Yeah","But"],["No"],["But"],["Yeah"],["But","No"],[],["Yeah","But"],["No"],["But"],["Yeah"]]
                     Ẏ - tighten                 ["Yeah","But","No","But","Yeah","But","No","Yeah","But","No","But","Yeah"]

Comments

मुझे संदेह है कि यह इससे छोटा है। शानदार जवाब, और एक महान व्याख्या, अच्छी तरह से किया!

— अधिकतम

Answer 30

पायथन 2 , 93 92 83 बाइट्स

lambda i:''.join('Yeah\n'*(x%3<1)+'But\n'*(x%2<1)+'No\n'*(x%3==1)for x in range(i))

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

@Jonathan Frech के धन्यवाद के साथ एक विशाल 9 बाइट्स बचाए गए

Comments

आप टपल इंडेक्सिंग के बजाय स्ट्रिंग पुनरावृत्ति का उपयोग कर सकते हैं - ('','Yeah\n')[x%3<1]के बराबर है "Yeah\n"*(x%3<1)।

— जोनाथन फ्रीच

@JonathanFrech - बहुत अच्छा! इसी तरह की तकनीक को अन्य मामलों में भी लागू किया जा सकता है। बहुत धन्यवाद!

— एलपेड्रो