मुहावरा "गलत करते समय"


47

डू एज़ फ़ाल्स

आज काम पर मेरे एक सहकर्मी (झूठे) करते समय उपयोग के मामले का वर्णन कर रहे थे। वह जिस व्यक्ति से बात कर रहा था, वह सोच रहा था कि यह मूर्खतापूर्ण है और यह सरल है कि यदि कथन ज्यादा बेहतर होंगे। फिर हमने अपने दिन का आधा समय बर्बाद करने के लिए आगे बढ़ कर सबसे अच्छा तरीका लिखा:

do
{
   //some code that should always execute...

   if ( condition )
   {
      //do some stuff
      break;
   }

   //some code that should execute if condition is not true

   if ( condition2 )
   {
       //do some more stuff
       break;
   }

   //further code that should not execute if condition or condition2 are true

}
while(false);

यह एक मुहावरा है जो काफी बार c में पाया जाता है। आपके प्रोग्राम को शर्तों के आधार पर नीचे दिए गए छद्म कोड के समान आउटपुट का उत्पादन करना चाहिए।

do
{
   result += "A";

   if ( C1)
   {
      result += "B";
      break;
   }

   result += "C"

   if ( C2 )
   {
       result += "D";
       break;
   }

   result += "E";

}
while(false);

print(result);

इसलिए इनपुट हो सकता है:

1. C1 = true, C2 = true
2. C1 = true, C2 = false
3. C1 = false, C2 = true
4. C1 = false, C2 = false

और आउटपुट होना चाहिए:

1. "AB"
2. "AB"
3. "ACD"
4. "ACE"

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स पर आंका जाएगा। मानक खामियों पर रोक लगाई जाती है।

हां यह एक सरल है, लेकिन उम्मीद है कि हम कुछ रचनात्मक जवाब देखेंगे, मुझे उम्मीद है कि सादगी लोगों को उन भाषाओं का उपयोग करने के लिए प्रोत्साहित करेगी जिनके साथ वे आश्वस्त हैं।


क्या आउटपुट को अपरकेस होना चाहिए, या लोअरकेस को भी अनुमति है?
अदनान

7
अपने सहकर्मी के साथ बहस के लिए एक तरफ, यह मुझे लगता है कि आप एक ही चीज़ का उपयोग कर सकते हैं जिसके return resultस्थान पर एक विधि का उपयोग किया जाता है break। फिर आपको पुन: प्रयोज्य का बोनस मिलता है और कॉलिंग कोड को भी सरल बनाया जाता है। लेकिन शायद मुझे कुछ याद आ रहा है।
jpmc26

3
मुझे नहीं पता था कि यह सी में एक मुहावरा था ...
मेहरदाद

5
@ मेहरदाद कुछ लोग इसके बजाय ऐसा करते हैं gotoक्योंकि प्रयोग gotoखराब रूप है :)
सेठ

2
केवल समय जो मैंने कभी इस्तेमाल किया है do{}while(false)वह मैक्रोज़ के अंदर है। एक साधारण ifपर्याप्त नहीं है, क्योंकि यह elseआसपास मौजूद बुरी तरह से बातचीत करता है । मैक्रो के बिना आप doऔर भी निकाल सकते हैं while
nwp

जवाबों:


19

पायथन 3, 31

सहेजा गया 1 बाइट xnor के लिए धन्यवाद।

ES6 से केवल एक बाइट दूर। : / स्टुपिड पायथन और इसके लंबे अनाम फ़ंक्शन सिंटैक्स।

एक लाइनर के लिए हुर्रे!

lambda x,y:x*"AB"or"AC"+"ED"[y]

परीक्षण के मामलों:

assert f(1, 1) == "AB"
assert f(1, 0) == "AB"
assert f(0, 1) == "ACD"
assert f(0, 0) == "ACE"

7
यदि आप फिर से आदेश देते हैं x*"AB", तो आप अंतरिक्ष को बाद में बचा सकते हैं।
xnor

2
क्षमा करें, आपके लंबे, अनाम फ़ंक्शन सिंटैक्स में अजगर की मृत्यु होगी: P
कॉनर ओ'ब्रायन

5
@ C @O'Bʀɪᴇɴ मुझे पता था कि पायथन को वापस पकड़ना होगा। मैं एक PEP ASAP जमा करूँगा।
मॉर्गन थ्राप


9
एक λपर्याय बनाने के लिए एक PEP lambdaबहुत अच्छा होगा :)
रॉबर्ट ग्रांट

13

जावास्क्रिप्ट ईएस 6, 30 26 25 बाइट्स

एक साधारण अनाम फ़ंक्शन दो इनपुट ले रहा है। कॉल करने के लिए एक चर को असाइन करें। अपडेट : आइए इंडेक्स बैंडवगन पर कूदें। यह 4 बाइट्स बचाता है। मैंने पायथन पर अपनी बढ़त हासिल कर ली है । फ़ंक्शन को करीने से बाइट सहेजा गया; जैसे बुलाओ (...)(a)(b)। धन्यवाद पैट्रिक रॉबर्ट्स!

a=>b=>a?"AB":"AC"+"ED"[b]

पुराना, मूल संस्करण, 30 बाइट्स (अजगर जवाब में नहीं पिघलाया जाना शामिल है (;):

(a,b)=>"A"+(a?"B":b?"CD":"CE")

यह वह बात नहीं है ...
Theonlygusti

15
@theonlygusti यह एक कोड-गोल्फ है, न कि एक लोकप्रियता प्रतियोगिता। इसके अलावा, यदि अधिक संक्षिप्त समाधान है तो अपशिष्ट बाइट्स चालाक क्यों हैं?
कॉनर ओ'ब्रायन

मुझे आपकी पसंद पसंद है नाक:b?
J Atkin

@Jtkin वास्तव में!
कॉनर ओ'ब्रायन



9

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

x#y|x="AB"|y="ACD"|1<2="ACE"

प्रयोग उदाहरण: False # True-> "ACD"

सीधे गार्ड के रूप में इनपुट मूल्यों का उपयोग करना।


9

MATL , 15 17 बाइट्स

?'AB'}'AC'69i-h

इनपुट अलग लाइनों पर 0या हैं 1। वैकल्पिक रूप से, (MATL's ) और by (MATL's ) 0द्वारा प्रतिस्थापित किया जा सकता है ।Ffalse1Ttrue

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

?           % if C1 (implicit input)
  'AB'      %   push 'AB'
}           % else
  'AC'      %   push 'AC'
  69        %   push 69 ('E')
  i-        %   subtract input. If 1 gives 'D', if 0 leaves 'E'
  h         %   concatenate horizontally
            % end if (implicit)

8

ब्रेनफक, 65 बाइट्स

यह मानता है कि C1 और C2 कच्चे 0 या 1 बाइट्स के रूप में इनपुट हैं। जैसे

echo -en '\x00\x01' | bf foo.bf

golfed:

++++++++[>++++++++<-]>+.+>+>,[<-<.>>-]<[<+.+>>,[<-<.>>-]<[<+.>-]]

Ungolfed:

                                      Tape
                                      _0
++++++++[>++++++++<-]>+.+  print A    0 _B
>+>,                       read C1    0 B 1 _0  or  0 B 1 _1
[<-<.>>-]<                 print B    0 B _0 0  or  0 B _1 0
[<+.+>>                    print C    0 D 1 _0
    ,                      read C2    0 D 1 _0  or  0 D 1 _1
    [<-<.>>-]<             print D    0 D _0 0  or  0 D _1 0
    [<+.>-]                print E    0 D _0    or  0 E _0
]

मैं टिप्पण लायक है कि इस समाधान का मानना है while लूप से बाहर तोड़ने के आधार पर वास्तव में।



7

NTFJ , 110 बाइट्स

##~~~~~#@|########@|~#~~~~~#@*(~#~~~~#~@*########@^)~#~~~~##@*##~~~~~#@|########@|(~#~~~#~~@*):~||(~#~~~#~#@*)

अधिक पठनीय:

##~~~~~#@|########@|~#~~~~~#@*(~#~~~~#~@*########@^)~#~~~~##@*##~~~~~#@|########@|(~#~~~#~~@*
):~||(~#~~~#~#@*)

यह निश्चित रूप से मनोरंजक था। इनपुट के रूप में दो वर्णों ( या ) का उपयोग करके इसे यहाँ आज़माएँ01

0, 1 (वर्ण) को बिट्स में परिवर्तित करने के लिए ETHProduct की विधि का उपयोग करना, यह सरल हो जाता है।

##~~~~~#@|########@|

यह उक्त विधि है। शीर्ष इनपुट मान के साथ 193 ( ##~~~~~#@), इसे नंदिंग ( ), |इस मामले में, पहला चार कोड, एक 48 (49)। यह 1 के लिए 254 और 255 के लिए 25 पैदावार देता है। इसे 255 के साथ मिलाते हुए ( ########@) इनपुट के अनुसार 0 या 1 बिट उपज देता है।

~#~~~~~#@*

यह एक प्रिंट करता है A, क्योंकि सभी इनपुट के साथ शुरू होता है A*पॉप Aजब मुद्रण, तो ढेर उसकी पहले वाली स्थिति से अपरिवर्तित है।

(~#~~~~#~@*########@^)

केस 1: पहला बिट है 1, और (अंदर कोड सक्रिय करता है। ~#~~~~#~@*प्रिंट करता है B, और ########@^255 धक्का देता है और कोड में उस स्थिति में कूदता है। यह कार्यक्रम का अंत होने के कारण इसे समाप्त करता है।

केस 2: पहला बिट है 0(को छोड़ देता है )और कोड जारी रहता है।

~#~~~~##@*

यह प्रिंट करता है C, क्योंकि यह अगला चरित्र है।

##~~~~~#@|########@|

यह हमारे दूसरे इनपुट को थोड़ा परिवर्तित करता है।

(~#~~~#~~@*)

यदि हमारा दूसरा बिट 1 है, तो हम प्रिंट करने के लिए आगे बढ़ते हैं E

:~||

यह हमारे बिट के बूलियन नकार का नंद प्रतिनिधित्व है A NAND (0 NAND A) = NOT A:।

(~#~~~#~#@*)

यह अब सक्रिय हो जाता है अगर बिट ए 0और प्रिंट था E


5

पायथ, 16 बाइट्स

+\A?Q\B+\C?E\D\E

परीक्षण सूट

Ternaries!

स्पष्टीकरण:

+\A              Start with an A
?Q\B             If the first variable is true, add a B and break.
+\C              Otherwise, add a C and
?E\D             If the second variable is true, add a D and break.
\E               Otherwise, add a E and finish.

लगातार दो लाइनों पर इनपुट।


3
ओह पाइथमास्टर, इस कार्यक्रम के तरीकों से हमें अवगत कराएँ। ;)
कॉनर ओ'ब्रायन

5

CJam, 15 16 17 बाइट्स

'Ali'B'C'Eli-+?

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

@Randomra की बदौलत एक बाइट, और @Dennis की बदौलत एक बाइट

स्पष्टीकरण:

'A                  e# push "A"
  li                e# read first input as an integer
    'B              e# push "B" 
      'C            e# push "C"
        'E          e# push "E"
          li-       e# leave "E" or change to "D" according to second input
             +      e# concatenate "C" with "E" or "D"
              ?     e# select "B" or "C..." according to first input

पुराना संस्करण (16 बाइट्स):

'Ali'B{'C'Eli-}?

स्पष्टीकरण:

'A                  e# push character "A"
               ?    e# if-then-else
  li                e# read first input as an integer. Condition for if
    'B              e# push character "B" if first input is true
      {       }     e# execute this if first input is false
       'C           e# push character "C"
         'E         e# push character "E"
           li       e# read second input as an integer
             -      e# subtract: transform "E" to "D" if second input is true
                    e# implicitly display stack contents

5
हमारे अच्छे दोस्त अली और एली!
कॉनर ओ'ब्रायन

5

अजगर, 13 वर्ण, 19 बाइट्स

.HC@"૎્««"iQ2

इनपुट के रूप में ले जाता है [ए, बी]

व्याख्या

               - autoassign Q = eval(input())
           iQ2 -    from_base(Q, 2) - convert to an int
   @"૎્««"    -   "૎્««"[^]
  C            -  ord(^)
.H             - hex(^)

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

या एक परीक्षण सूट का उपयोग करें


2
कम से कम UTF-8 में, इसका वजन 19 बाइट होता है।
डेनिस

1
बाइटिज़ममैटर्स बाइट्स गिनने के पूरी तरह से बनाए गए तरीके का उपयोग करता है, जो वास्तविक एन्कोडिंग के अनुरूप नहीं है (और नहीं कर सकता है )। यह वर्ग बाइट्स को 2 बाइट्स के रूप में गिनता है (UTF-8 में 3 बाइट्स) और «1 बाइट प्रत्येक के रूप में (UTF-8 में 2 बाइट्स)। दोनों wcऔर यह सहमत है कि यह 19 बाइट्स है।
डेनिस

4

सी, 76 बाइट्स

मैं नाम दिया c1करने के लिए c, c2करने के लिए Cऔर resultकरने के लिए r। सी प्रोग्रामर बचने के लिए चरम सीमा पर जाते हैं goto। यदि आपके पास कभी भी सी में बेतुका सिंटैक्स के साथ एक प्रोब्लम है, तो यह सबसे अधिक होने की संभावना है क्योंकि आपने उपयोग नहीं किया था goto

char r[4]="A";if(c){r[1]=66;goto e;}r[1]=67;if(C){r[2]=68;goto e;}r[2]=69;e:

Ungolfed

char r[4] = "A";
if(c1){
    r[1] = 'B';
    goto end;
}
r[1] = 'C';
if(c2){
    r[2] = 'D';
    goto end;
}
r[2] = 'E';
end:

आप के साथ शुरू कर सकते हैं char r[4]="A";? मेरी सी जंग लगी है।
लार्स

क्या वास्तव में एक स्ट्रिंग शाब्दिक घोषित करने का हास्यास्पद तरीका नहीं है?
तमोग्ना चौधरी

@TamoghnaChowdhury क्रमबद्ध करें स्ट्रिंग शाब्दिक लेखन योग्य नहीं हैं। यह एक सरणी है जो तब स्ट्रिंग शाब्दिक "ए" द्वारा आरंभ की जाती है। चूंकि "ए" केवल पहले दो बाइट्स सेट करता है, शेष को स्थिर अवधि की वस्तुओं के लिए नियमों के अनुसार प्रारंभ किया जाता है (इसलिए इस मामले में 0)। [C99 6.7.8 / 22]
रे

1
आप करने के लिए प्रारंभ सूची बदलकर 22 बाइट्स बचा सकता है "AC"और सब कुछ जगह r[1]=67करने के लिए r[2]=69;साथr[2]=c2?68:69;
रे

4

सी, 41 बाइट्स

मुझे यकीन नहीं है कि सवाल के लिए एक कार्यक्रम, एक फ़ंक्शन या एक कोड स्निपेट की आवश्यकता होती है।
यहाँ एक समारोह है:

f(a,b){a=a?16961:4473665|b<<16;puts(&a);}

यह दो मापदंडों में इनपुट प्राप्त करता है, जो 0 या 1 (अच्छी तरह से bहोना चाहिए), और प्रिंट करने के लिए प्रिंट होना चाहिए।

aएक में सेट करता है 0x4241, 0x454341या 0x444341। जब एक स्ट्रिंग के रूप में मुद्रित किया जाता है, तो थोड़ा-एंडियन एएससीआईआई सिस्टम पर, आवश्यक आउटपुट देता है।


4

आर , 41 39 37 बाइट्स

pryr::f(c("ACD","ACE","AB")[1+a+a^b])

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

आर में, TRUEऔर FALSEकरने के लिए मजबूर कर रहे हैं 1और 0क्रमश: आप उन्हें संख्या के रूप में उपयोग करने का प्रयास करते हैं। हम सूचकांक करने के लिए इन नंबरों में बदल सकते हैं 1, 2और 3सूत्र के माध्यम से 1+a+a^b

  a  |   b  | 1+a+a^b
TRUE | TRUE | 1+1+1^1 = 3
TRUE | FALSE| 1+1+1^0 = 3
FALSE| TRUE | 1+0+0^1 = 1
FALSE| FALSE| 1+0+0^0 = 2

फिर इन मानों सूची सूचकांक करने के लिए उपयोग किया जाता है ACD, ACE, ABसही उत्पादन उपज के लिए।

दो बाइट्स जेसीई के लिए धन्यवाद बचा लिया।

यदि आप एक ifबयान के साथ एक संस्करण पसंद करते हैं , तो 41 बाइट्स के लिए निम्नलिखित है:

pryr::f(`if`(a,"AB",`if`(b,"ACD","ACE")))

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



@ जय धन्यवाद, मैंने जवाब अपडेट कर दिया है!
rturnbull

3

गणितज्ञ, ३५ ३० बाइट्स

If[#,"AB",If[#2,"ACD","ACE"]]&

बहुत आसान। अनाम फ़ंक्शन।


3

रेटिना, 22 बाइट्स

1.+
AB
.+1
ACD
.+0
ACE

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


1
retina.tryitonline.net/… । इसके ^साथ उपसर्ग करें m`, इसे बहु-पंक्ति इनपुट के लिए काम करने के लिए, जो प्रश्न के लिए आवश्यक नहीं है, लेकिन परीक्षण को आसान बनाता है।
डिजिटल ट्रॉमा

मुझे लगता है कि आप दो इनपुट के बीच की जगह को हटाकर 3 बाइट्स बचा सकते हैं।
कैलक्यूलेटरफलाइन

3

जावास्क्रिप्ट, 38 बाइट्स

का उपयोग न-सीमांकक 0या के 1बजाय false/true

_=>"ACE ACD AB AB".split` `[+('0b'+_)]

1
आप split` ` इसके बजाय का उपयोग कर सकते हैंsplit(" ")
20

आप +('0b'+prompt())इसके बजाय का उपयोग कर सकते हैंparseInt(prompt(),2)
20


3

अर्नोल्ड , 423 बाइट्स

IT'S SHOWTIME
HEY CHRISTMAS TREE a
YOU SET US UP 0
HEY CHRISTMAS TREE b
YOU SET US UP 0
BECAUSE I'M GOING TO SAY PLEASE a
BECAUSE I'M GOING TO SAY PLEASE b
TALK TO THE HAND "ABD"
BULLSHIT
TALK TO THE HAND "ABE"
YOU HAVE NO RESPECT FOR LOGIC
BULLSHIT
BECAUSE I'M GOING TO SAY PLEASE b
TALK TO THE HAND "ACD"
BULLSHIT
TALK TO THE HAND "ACE"
YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

चूंकि अर्नोल्ड में औपचारिक इनपुट नहीं है, इसलिए पहले 2 YOU SET US UPमानों को या तो 0 या 1 के बजाय बदल दें।

व्याख्या

यह सिर्फ सशर्त बयानों का एक पूरा गुच्छा है जो सभी संभावित आउटपुट के लिए जिम्मेदार है। क्यों, आप पूछ सकते हैं? खैर, अर्नोल्ड में वास्तव में स्ट्रिंग की समझ नहीं है। यह भी तार नहीं कर सकते! नतीजतन, हमें अधिक ... अक्षम ... पद्धति का सहारा लेना होगा।


ईआर, आउटपुट "एबी" होना चाहिए यदि कोई सही है, तो "एबीडी" / "एबीई" नहीं। कि अपने कोड को कम करना चाहिए!
टोबी स्पाईट

3

जावा, 28 बाइट्स

बहुत सारे उत्तरों के रूप में समान बॉयलरप्लेट। प्रकार है BiFunction<Boolean,Boolean, String>

(c,d)->c?"AB":d?"ACD":"ACE"

मुझे पता है कि लगभग दो साल हो गए हैं, लेकिन जब आप एक का उपयोग करते हैं तो (c,d)->1 बाइट से गोल्फ हो सकता c->d->है java.util.function.Function<Boolean, java.util.function.Function<Boolean, String>>
केविन क्रूज़सेन

2

पायथ, 21 बाइट्स

@c"ACE ACD AB AB"diz2

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

इनपुट के रूप में लिया जाता है 0 या 1 के बजाय सच / गलत जबकि C1 पहले आता है।

व्याख्या

इस तथ्य का उपयोग करते हुए कि केवल 4 संभावित परिणाम हैं। इनपुट को बाइनरी के रूप में व्याख्या करके काम करता है, इसे बेस 10 में परिवर्तित करता है और लुकअप स्ट्रिंग से सही परिणाम चुनने के लिए इसका उपयोग करता है।

@ c "ACE ACD AB AB" diz2 # z = इनपुट

                  iz2 # बाइनरी इनपुट को आधार 10 में बदलें
 c "ACE ACD AB AB" d # स्पेस में स्प्लिट स्ट्रिंग
@ # सूचकांक पर तत्व प्राप्त करें

2

वाई , 20 बाइट्स

इस घटना में कि पहला इनपुट एक है, केवल एक इनपुट लिया गया है। मुझे लगता है कि इस व्यवहार की अनुमति है। यहाँ कोशिश करो!

'B'AjhMr$'C'E@j-#rCp

Ungolfed:

'B'A jh M
   r$ 'C 'E@ j - # r
 C p

व्याख्या की:

'B'A

यह पात्रों को Bतब Aस्टैक पर ले जाता है।

jh M

यह एक इनपुट लेता है, इसे बढ़ाता है, इसे पॉप करता है और उस सेक्शन की संख्या से आगे बढ़ता है।

केस 1 j1 = 0:। यह अधिक दिलचस्प है। r$स्टैक को उलट देता है और एक मूल्य पॉप करता है, 'C'Eपात्रों को धक्का देता है Cऔर E। अपने न्यूमेरिक समकक्ष में @कनवर्ट करता Eहै, दूसरे इनपुट को उसमें से घटाता है, और उसे एक वर्ण में देता है। rअन-स्टैक को उलट देता है। फिर, प्रोग्राम सी-लिंक को देखता है और अगले लिंक पर जाता है p, और स्टैक प्रिंट करता है।

केस 2: प्रोग्राम अंतिम लिंक पर जाता है p, जो पूरे स्टैक को प्रिंट करता है।


2

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

param($x,$y)(("ACE","ACD")[$y],"AB")[$x]

इनपुट द्वारा अनुक्रमित नेस्टेड ऐरे। PowerShell में, $true/ 1और $false/ 0व्यावहारिक रूप से बराबर (बहुत ढीला typecasting करने के लिए धन्यवाद), कर रहे हैं ताकि अच्छी तरह से एक दो तत्व सरणी में अनुक्रमित। यह वास्तव में पॉवरशेल के रूप में एक टर्नरी के करीब है, और मैंने इसे गोल्फ में बहुत बार उपयोग किया है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 1 1
AB

PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 1 0
AB

PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 0 1
ACD

PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 0 0
ACE


2

विटसी , 26 बाइट्स

एक नई लाइन को अलग करने के साथ STDIN के माध्यम से 1s या 0s के रूप में इनपुट की अपेक्षा करता है।

W([1m;]'DCA'W(Zr1+rZ
'BA'Z

मैं वास्तव में इस चुनौती के दौरान बयान के साथ एक गंभीर समस्या की खोज की। डी: यह टूटे हुए संस्करण के साथ पोस्ट किया गया है, लेकिन यह ठीक काम करता है। (मैं समस्या को ठीक करने के बाद इसे अपडेट करूंगा) कृपया ध्यान दें कि मैंने विटेसी को / ifnot के फिक्स के साथ अपडेट किया है। यह परिवर्तन मुझे कोई लाभ नहीं देता है, केवल स्पष्टीकरण।

स्पष्टीकरण:

W([1m;]'DCA'W(Zr1+rZ
W                      Get one line from STDIN (evaluate it, if possible)
 ([1m;]                If not zero, go to the first index of lines of code (next line)
                       and then end execution.
       'DCA'           Push character literals "ACD" to the stack.
            W          Get another (the second) line from STDIN.
             (         If not zero, 
do the next instruction.
              Z        Output all of the stack.
               r1+r    Reverse the stack, add one (will error out on input 0, 1), reverse.
                   Z   Output everything in the stack.

'BA'Z
'BA'                   Push character literals "AB" to the stack.
    Z                  Output everything in the stack.

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


2

मोम , 26 बाइट्स

0असत्य के रूप में व्याख्या करना , 1सत्य के रूप में।

E`<
D`d"`C`~<
_T~T~`A`"b`B

आउटपुट:

julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i1
i1
AB
Program finished!

julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i1
i0
AB
Program finished!

julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i0
i1
ACD
Program finished!

julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i0
i0
ACE
Program finished!

मेरे गितुब भंडार से मेरी मधुमक्खी दुभाषिया क्लोन करें ।


मुझे पूरा यकीन है कि आपको उद्धरण की आवश्यकता नहीं है।
अंडरग्राउंडोरेल

@undergroundmonorail: ठीक है, मैं अपना समाधान अपडेट करूंगा। धन्यवाद।
ML

2

सी, 47 45 बाइट्स

चूंकि केवल 3 अलग-अलग परिणाम हैं, हम इस तरह के तीन तारों में से एक को चुन सकते हैं:

char*f(c,d){return"AB\0 ACE\0ACD"+(!c<<d+2);}

2 बाइट्स के लिए हरमन एल को धन्यवाद

डेमो

#include<stdio.h>
int main()
{
    printf("%s\n%s\n%s\n%s\n",
           f(1,1),
           f(1,0),
           f(0,1),
           f(0,0));
}

1
-2 बाइट्स:char*f(c,d){return"AB\0 ACE\0ACD"+(!c<<d+2);}
हरमन एल

TIO से लिंक करें pls
ASCII-only

1

पर्ल, 23 ​​बाइट्स

say<>>0?AB:<>>0?ACD:ACE

आवश्यकता है -E| -M5.010झंडा और इनपुट 1 और 0 के रूप में लेता है:

$ perl -E'say<>>0?AB:<>>0?ACD:ACE' <<< $'0\n0'
ACE
$ perl -E'say<>>0?AB:<>>0?ACD:ACE' <<< $'0\n1'
ACD
$ perl -E'say<>>0?AB:<>>0?ACD:ACE' <<< $'1\n0'
AB

वैकल्पिक समाधान जिसकी आवश्यकता है -pऔर 22 + 1 = 23 बाइट्स हैं:

$_=/^1/?AB:/1/?ACD:ACE
perl -pe'$_=/^1/?AB:/1/?ACD:ACE' <<< '0 1'

say-<>?AB:-<>?ACD:ACEदो बाइट्स कम है।
nwellnhof

1

05AB1E , 23 20 बाइट्स

कोड:

Ii"AB"?q}"AC"?69I-ç?

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


1
यह संभवतः 05AB1E का एक प्राचीन संस्करण है, लेकिन यह अब 14 बाइट्स हो सकता है: i„ABë„AC69I-çJ इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें
केविन क्रूज़सेन

1
@KevinCruijssen अच्छा लगा! यह वास्तव में 05AB1E का एक प्राचीन संस्करण है। यहां भाषा लगभग तीन महीने पुरानी थी (इसमें निहित इनपुट भी नहीं था)।
अदनान

1
हाँ, मैं वास्तव में पहले से ही अग्रणी के बारे में उलझन में था I। ; पी
केविन क्रूज़सेन

1

जाप, 19 बाइट्स

"A{U?'B:'C+(V?'D:'E

इसे ऑनलाइन टेस्ट करें!

मजेदार तथ्य: यह 16 बाइट्स होगा यदि यह बग के लिए नहीं था:

"A{U?"B:C{V?"D:E

कीड़े सबसे बुरे हैं: |
कॉनर ओ'ब्रायन

2
@ C @O'Bʀɪᴇɴ Lemme देखें कि क्या मैं एक पुराना संस्करण खोद सकता हूं जिसमें यह बग नहीं था। तब 16 बाइट्स वैध होगी।
20

1
बग क्या है?
कैलक्यूलेटरफेलीन

@CalculatorFeline मेरा मानना ​​है कि इस तरह नेस्टेड स्ट्रिंग्स किसी कारण से ट्रांसपाइल नहीं होती हैं।
ETHproductions
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.