17

चुनौती का विवरण:

एक प्रोग्राम लिखें जो उपयोगकर्ता को इनपुट के लिए पूछता है। उपयोगकर्ता दर्ज करेगा Goodया Bad। आपको किसी अन्य इनपुट का समर्थन करने की आवश्यकता नहीं है। यदि उपयोगकर्ता प्रवेश करता है Good, तो प्रिंट करें Badऔर इसके विपरीत (stdout आदि के लिए)।

टिप्पणियाँ:

1) आप दो शब्दों के किसी अन्य युग्म का उपयोग नहीं कर सकते।

2) आपके प्रोग्राम को केवल एक बार पूछना और प्रिंट करना है।

3) आपको शीघ्र स्ट्रिंग प्रदर्शित करने की आवश्यकता नहीं है।

4) आउटपुट को किसी भी तरह से इनपुट से अलग होना चाहिए।

5) किसी भी फ़ंक्शन को मान स्वीकार करने और परिणाम वापस करने की अनुमति नहीं है; उपयोगकर्ता को कार्यक्रम के साथ बातचीत करनी चाहिए।

सौभाग्य!

code-golf string interactive

— इशाक खान
स्रोत

9

क्या हम एक ऐसा कार्य लिख सकते हैं जो इसके लिए संकेत देने के बजाय तर्क के रूप में इनपुट लेता है?

— Adám

8

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

— Jo King

2

इनपुट (स्टडिन आदि) के लिए उपयोगकर्ता पूछता है कि केवल STDIN या इंटरैक्टिव इनपुट की अनुमति है। कृपया इसे सभी डिफ़ॉल्ट I / O विधियों में बदल दें

— MilkyWay90

1

"इनपुट के लिए उपयोगकर्ता पूछता है", क्या यह कुछ स्पष्ट प्रश्न होना चाहिए? क्योंकि खाली CLI प्रॉम्प्ट वास्तव में कुछ भी नहीं मांग रहा है ...

— user0721090601

5

इस प्रतिबंध का उद्देश्य क्या है? किसी भी फ़ंक्शन को मान स्वीकार करने और परिणाम वापस करने की अनुमति नहीं है; उपयोगकर्ता को कार्यक्रम के साथ बातचीत करनी चाहिए

— mbomb007

46

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

exit('GBoaodd'['G'<input()::2])

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

कैसे?

यदि इनपुट 'Good'तुलना द्वारा टेस्ट 'G'<input()।

इस तथ्य का उपयोग करता है कि पायथन में False==0और एक अपरिभाषित और एक के साथ एक स्लाइस के सूचकांक के True==1रूप में परिणाम का उपयोग करने के लिए ।start'GBoaodd'stopstep2'GBoaodd'[start:stop:step]

STDERR को प्रिंट करता है (इसके exitस्थान पर एक बाइट को सहेजना print)।

— जोनाथन एलन
स्रोत

क्या तरकीब है! समझ में नहीं आता कि यह कैसे काम करता है।

— इशाक खान

क्या आप बाइट्स को छोटा करने के लिए लैम्बडा का उपयोग कर सकते हैं?

— MilkyWay90

@ MilkyWay90 प्रश्न के अनुसार इनपुट स्वीकार करने वाला एक कार्यक्रम होना चाहिए।

— जोनाथन एलन

@A__ डिफ़ॉल्ट रूप से हां, हालांकि ओपी द्वारा एक टिप्पणी है जो यह बताती है कि इसे यहां ओवरराइड किया जा सकता है।

— जोनाथन एलन

4

बहुत बुरा है कि "अच्छा" और "बुरा" एक "डी" साझा करते हैं, या आप कर सकते हैं 'GoodBad'.strip(input())जो एक बाइट कम है।

— xnor

15

एपीएल (Dyalog यूनिकोड) , 13 बाइट्स ^SBCS

पूर्ण कार्यक्रम जो स्टड और प्रिंट से इनपुट के लिए संकेत देता है।

'GooBad'~¯1↓⍞

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

⍞ स्टड से इनपुट के लिए संकेत; GoodयाBad

¯1↓ अंतिम चरित्र को छोड़ें ( d); GooयाBa

'GooBad'~ मल्टीसेट इन वर्णों को इनमे से घटाता है; BadयाGood

— एडम
स्रोत

5

— नीच

1

कोड है GooBadया GoodBad?

— NoOneIsHere

मुझे लगता है कि यह होना चाहिए GooBad, जैसा कि एक वर्ण जोड़ने के लिए `` d`` इस पोस्ट को 14 बाइट्स बना देगा।

@NoOneIsHere धन्यवाद। फिक्स्ड।

— एडम जूल

12

ट्यूरिंग मशीन बट वे वर्स , 405 बाइट्स

0 0 0 1 1 0 0
1 1 1 1 2 0 0
0 2 0 1 3 0 0
0 3 0 1 4 0 0
0 4 0 1 5 0 0
1 5 0 1 6 0 0
0 5 1 1 h 0 0
1 6 1 1 7 0 0
1 7 0 1 8 1 0
0 8 0 1 9 0 0
1 9 1 1 9 0 0
0 9 0 1 a 0 0
1 a 0 1 a 0 0
0 a 0 0 b 0 0
0 b 1 1 c 1 0
0 c 0 0 d 0 0
1 d 0 0 e 0 0
0 e 0 0 f 0 0
0 f 1 1 g 1 1
1 h 1 1 i 0 0
0 i 1 1 j 1 0
0 j 0 1 k 0 0
1 k 1 1 k 0 0
0 k 0 1 l 0 0
0 l 1 1 l 0 0
1 l 1 0 m 1 0
1 m 1 1 n 1 0
1 n 1 1 o 0 0
0 o 0 1 p 1 1

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

खैर, इसमें थोड़ा समय लगा।

अनधिकृत प्रदर्शनी :

0 0 0 1 1 0 0 Start going to the sixth bit
1 1 1 1 2 0 0
0 2 0 1 3 0 0
0 3 0 1 4 0 0
0 4 0 1 5 0 0 End going to the sixth bit
1 5 0 1 6 0 0 If the sixth bit is 1, then it is Good. Start transforming "G" to "B" and go to state 6
0 5 1 1 h 0 0 Else, it is Bad. Start transforming "B" to "G" and go to state h
1 6 1 1 7 0 0 Keep on transforming "G" to "B"
1 7 0 1 8 1 0 End transforming and print "B"
0 8 0 1 9 0 0 We are in the first "o" in "Good". Start moving into the 5th bit.
1 9 1 1 9 0 0
0 9 0 1 a 0 0
1 a 0 1 a 0 0 Do some looping magic and start transforming "o" to "a"
0 a 0 0 b 0 0 End looping magic
0 b 1 1 c 1 0 End transforming and print "a"
0 c 0 0 d 0 0 
1 d 0 0 e 0 0 Start transforming "a" to "d"
0 e 0 0 f 0 0 
0 f 1 1 g 1 1 Stop transforming, print "d", and terminate
1 h 1 1 i 0 0 Continue transforming "B" to "G"
0 i 1 1 j 1 0 Stop transforming and print out "G"
0 j 0 1 k 0 0 Start going into position to print out "oo"
1 k 1 1 k 0 0
0 k 0 1 l 0 0 Move more efficiently using LOOPING MAGIC1!1111111 
0 l 1 1 l 0 0 looping magic end, start transforming
1 l 1 0 m 1 0 end transforming and print out out "o"
1 m 1 1 n 1 0 print out "o" again
1 n 1 1 o 0 0 get into the "d" byte
0 o 0 1 p 1 1 print "d" and execute YOU HAVE BEEN TERMINATED

— MilkyWay90
स्रोत

4

"ट्यूरिंग-मशीन-बट-वे-वर्स", एक शक के बिना, मेरा नया पसंदीदा एसोलैंग है।

— माइक। लायर

@MikeTheLiar धन्यवाद!

— MilkyWay90

@A__favorite/disliked/"Turing-Machine-But-Way-Worse" is, without a doubt, my new favorite esolang.

— MilkyWay90

"आप कुछ अलग कर चुके हैं" अर्नोल्ड, क्या आप हैं?

— टेंपोरलवॉल्फ

@TemporalWolf यह मैं है, अर्नोल्ड!

— MilkyWay90

9

बैश, 20 बाइट्स

sed s/$1//<<<GoodBad

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

— Doorknob
स्रोत

8

8088 विधानसभा, आईबीएम पीसी डॉस, 25 बाइट्स

unassembled:

BA 0110     MOV  DX, OFFSET GB  ; point DX to 'Good','Bad' string 
D1 EE       SHR  SI, 1          ; point SI to DOS PSP (80H) 
02 04       ADD  AL, [SI]       ; add input string length to AL, set parity flag 
7B 02       JNP  DISP           ; if odd parity, input was 'Bad' so jump to display 'Good'
02 D0       ADD  DL, AL         ; otherwise add string length as offset for 'Bad' string 
        DISP: 
B4 09       MOV  AH, 9          ; DOS display string function 
CD 21       INT  21H            ; call DOS API, write string to console 
C3          RET                 ; return to DOS 
        GB  DB  'Good$','Bad$'

स्पष्टीकरण:

इनपुट स्ट्रिंग की लंबाई (प्लस लीडिंग स्पेस) को देखता है जो DOS मेमोरी एड्रेस पर स्टोर करता है 80H, और इसे AL(शुरुआत 0 में DOS द्वारा ) जोड़ता है । यदि 1स्ट्रिंग की लंबाई के द्विआधारी प्रतिनिधित्व में बिट्स की एक अजीब संख्या है , तो सीपीयू समता ध्वज को विषम, और इसके विपरीत में सेट किया गया है। तो इनपुट स्ट्रिंग ' Bad'लंबाई 4( 0000 0100), विषम समता है और इनपुट स्ट्रिंग ' Good'है 5( 0000 0101) समता है।

DXशुरू में स्ट्रिंग को इंगित करने के लिए सेट किया गया है 'Good$Bad$', और अगर समता भी है (मतलब इनपुट था ' Good') स्ट्रिंग पॉइंटर को उस लंबाई से आगे बढ़ाएं ( 5) तो यह अब इंगित करता है 'Bad$'। यदि समता विषम है, तो कुछ भी न करें क्योंकि यह पहले से ही इंगित करता है 'Good$'। फिर $कंसोल को समाप्त करने के लिए DOS API का उपयोग करें ।

उदाहरण:

डाउनलोड करें और GOODBAD.COM का परीक्षण करें या xxdडंप से निर्माण करें :

0000000: ba10 01d1 ee02 047b 0202 d0b4 09cd 21c3  .......{......!.
0000010: 476f 6f64 2442 6164 24                   Good$Bad$

— 640KB
स्रोत

7

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

“Ċ³ṫ³»œṣ

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

एक पायथन के तर्क के रूप में एक पूर्ण कार्यक्रम की उम्मीद है

कैसे?

“Ċ³ṫ³»œṣ - Main Link: list of characters, S
“Ċ³ṫ³»   - compression of dictionary words "Good"+"Bad" = ['G','o','o','d','B','a','d']
      œṣ - split on sublists equal to S
         - implicit, smashing print

— जोनाथन एलन
स्रोत

1

ऐसा लगता है कि ओपी ने जवाब दिया, इनपुट STDIN तक सीमित नहीं है।

— आउटगोल्फ

6

पायथन 3, 38 37 34 33 बाइट्स

exit("C">input()and"Good"or"Bad")

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

exit() : आउटपुट के रूप में एक निकास कोड देता है

"C">input(): जाँचता है कि इनपुट Cवर्णमाला क्रम में स्ट्रिंग से बड़ा है या नहीं

and"Good": यदि परिणाम है True, तो साथ लौटता हैGood

or"Bad" : अन्यथा, साथ लौटता है Bad

2

34:print("C">input()and"Good"or"Bad")

— 14

2

exit(input()[3:]and"Bad"or"Good")एक ही बाइट काउंट के लिए भी काम करता है।

— नील

6

सी, 39 38 बाइट्स

main(){puts("Good\0Bad"+getchar()%6);}

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

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

— लियो तेनाबाम
स्रोत

5

main(){puts("Good\0Bad"+getchar()%6);}38 बाइट्स

— tsh

क्या आपको नहीं जोड़ना चाहिए #include<stdio.h>?

— पोलफोसोल ఠ_ఠ

3

@polfosol ఠ_ఠ यदि यह कोड गोल्फ के अलावा कुछ भी था, तो आपको चाहिए , लेकिन C89 में, आप स्पष्ट रूप से फ़ंक्शन को रोक सकते हैं ।

— सिंह तेनबाम

आप के बजाय एक अशक्त बाइट का उपयोग कर सकते हैं \0?

— नमस्ते

5

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

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

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

स्पष्टीकरण:> +++++>,>,>,>

या तो पढ़ें: "जी", 5, "ओ", "ओ", "डी" या "बी", 5, "ए", "डी", 0

[<<<< [- <- >> --- <] <। >> +। >>> >>>] यदि अंतिम वर्ण शून्य नहीं है:

पहली सेल से 5 और तीसरे सेल से तीन बार सब्स्ट्रेक्ट करें। वृद्धि सेल 3

आउटपुट सेल 1, 3, 5।

<[<<< [- <+ >> +++ <] <>> -।। ..> >>]

अन्यथा 5 को पहले सेल में एक बार और तीसरे सेल में तीन बार जोड़ें।

कमी सेल 3

आउटपुट सेल 1, 3, 3, 4

— हेलेना
स्रोत

यह एक अच्छा उपाय है। इनपुट में न्यूलाइन का उपयोग न करके आप इसे थोड़ा छोटा कर सकते हैं। ,> +++++>,>,>, [<<< [- <-।।। >> --- <] <>> + >> >>] <[<< [- <+ >> +++ <] <। >> ->>>>]

— डोरियन

हाँ, मुझे एहसास हुआ कि वहाँ अनुकूलन करने के लिए कुछ है, लेकिन मुझे यह व्याख्या करना कठिन लगा कि नियम 4 का पालन करने के लिए क्या आवश्यक है

— हेलेना

4

हास्केल, 36 34 बाइट्स

interact g
g"Bad"="Good"
g _="Bad"

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

संपादित करें: -2 बाइट्स @cole के लिए धन्यवाद

— nimi
स्रोत

1

34 बाइट्स

— कोल

4

आर , 42 37 35 32 बाइट्स

-10 Giuseppe और AkselA के लिए धन्यवाद!

`if`(scan(,'')>'C','Bad','Good')

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

— रॉबर्ट एस।
स्रोत

1

कोई दिक्कत नहीं है। मैं बहुत से अन्य आर गोल्फर्स के नामों को पहचानता हूं, इसलिए मैं अक्सर पदों पर क्लिक करता हूं अगर मैं उनका नाम सबसे हाल ही में देखता हूं। :-)

— Giuseppe

1

इस उत्तर के रूप में "C"पहले के बजाय का उपयोग करने से एक और युगल बाइट की बचत होगी। "Bad"

— Giuseppe

1

बस जिज्ञासा से बाहर, कुछ `if`(readline()>"C","Bad","Good")एक वैध जवाब की तरह होगा? मैं इस खेल और इसके नियमों के लिए नया हूं।

— १०:३३ बजे अकेल

2

@ अक्साला हां, लेकिन मैं scan(,"")इसके बजाय का उपयोग करने का सुझाव दूंगा readline()। अगर आपके पास कोई आर-विशिष्ट प्रश्न हैं, तो गोल्फर , आर गोल्फ चैटरूम में जाने के लिए स्वतंत्र महसूस करें :-)

— Giuseppe

2

@ अक्साला कुछ विशिष्ट युक्तियों के लिए आर में गोल्फ के लिए टिप्स भी देखती है ; वहाँ छिपे हुए जवाहरात हैं अगर आप उन्हें पढ़ते हैं :-)

— Giuseppe

4

sed , 21 16 13 बाइट्स

धन्यवाद @ संकेत के संकेत के लिए।

/B/cGood
cBad

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

टीआईएल cवर्तमान लाइन के पार्सिंग को शॉर्ट-सर्किट करेगा।

— GammaFunction
स्रोत

2

cएक छोटा समाधान प्रदान करता है

— 16:41 पर user41805

1

आप अभी भी 3 से अधिक बाइट बचा सकते हैंc

— user41805

थोड़ा इसके साथ चारों ओर खेलना था, लेकिन मुझे यह समझ में आया!

— गामाफंक्शन

3

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

मुझे अर्नुल्ड का उत्तर पसंद है, लेकिन मैं चाहूंगा कि उपयोगकर्ता इनपुट को स्वीकार करे और StackExchange पर रनवेबल हो:

alert(prompt()[3]?'Bad':'Good')

स्निपेट का विस्तार करें

— ADJenks
स्रोत

3

बेफुंज -93 , 20 18 बाइट्स

"BadooGB"~-_#@,,<,

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

-2 बाइट्स जो किंग की बदौलत

— नकारात्मक सात
स्रोत

3

रूबी , 22 बाइट्स

->n{n>?F?"Bad":"Good"}

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

— जीबी
स्रोत

प्रश्न कहता है "इनपुट के लिए उपयोगकर्ता पूछता है", लेकिन ऐसा करने का सबसे छोटा तरीका लैम्ब्डा की जगह है p getsऔर इसलिए यह समान लंबाई है। (मेरी मूल टिप्पणी में कहा गया है कि आप 2 बाइट बचा सकते हैं, लेकिन मैंने परिणाम को प्रिंट करने के लिए हिसाब नहीं दिया)

— डेवमॉन्गोज

3

यदि हम वास्तव में एक पूर्ण प्रोग्राम के बारे में बात करने जा रहे हैं जो उपयोगकर्ता से इनपुट के लिए पूछ रहा है, तो -pध्वज का उपयोग करने से सबसे कुशल उत्तर मिलेगा: $_=$_>?F?:Bad:"Good"20 बाइट्स। इसे ऑनलाइन आज़माएं!

— मूल्य स्याही

3

05AB1E , 10 9 बाइट्स

”‚¿‰±”áIK

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

इसे ऑनलाइन आज़माएं या दोनों परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

”‚¿‰±”     # Push dictionary string "Good Bad"
      á    # Only keep letters (to remove the space)
       IK  # Remove the input
           # (output the result implicitly)

मेरा 05AB1E टिप देखें (अनुभाग का उपयोग कैसे करें शब्दकोश का उपयोग करें? ) , यह समझने के लिए कि क्यों ”‚¿‰±”है "Good Bad"।

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

मैं इस पर कई वैकल्पिक बदलाव देख सकता हूं, लेकिन वे सभी एक ही बाइट काउंट पर समाप्त होते हैं :(

— एमिगॉन

1

दरअसल, आप एक बाइट को बचा सकते हैं á।

— एमिग्ना जूल

@Eignigna आह, शानदार। अब जब मुझे लगता है कि मैं áविश्वास नहीं कर सकता कि मैंने इसके बारे में नहीं सोचा था, लेकिन साथ ही मुझे पता है कि मैंने इसके बारे में कभी नहीं सोचा होगा। ;) धन्यवाद! (और हाँ, मेरे पास कुछ 10-बाइट विकल्प भी थे।)

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

1

यहां तक कि जरूरत नहीं है, ”‚¿Bad”IKयह भी एक 9 है

— ग्रैमी

3

जावा (JDK) , 124 बाइट्स

interface G{static void main(String[]a){System.out.print(new java.util.Scanner(System.in).next().length()>3?"Bad":"Good");}}

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

सबसे अधिक संभावना है, सुधार के लिए अभी भी कुछ जगह है, लेकिन मैं पूरी तरह से कोड गोल्फिंग के लिए नया हूं।

— फेलिक्स बोहनेकर
स्रोत

2

स्वागत हे! एक स्पष्टीकरण और / या एक ऑनलाइन दुभाषिया से लिंक जोड़ने पर विचार करें जहां आप अपना कोड चला सकते हैं। (उदाहरण के लिए अन्य उत्तर देखें।) केवल-कोड के उत्तर को स्वचालित रूप से निम्न-गुणवत्ता के रूप में चिह्नित किया जाता है।

— mbomb007

4

लंबाई का हिस्सा सिर्फ हो सकता है!="Bad"

— जो किंग

109 बाइट्स

— ओलिवियर ग्रेगोइरे

3

रूबी, 30 28 बाइट्स

puts %w|Good Bad|-gets.split

गोल्फ-आईस्ट नहीं, लेकिन मुझे अनुगामी न्यूलाइन को हटाने और एक कॉल में एक सरणी में बदलने के लिए विभाजन का दुरुपयोग पसंद है।

EDIT -2 बाइट्स वैल्यू इंक के सुझाव के लिए धन्यवाद!

— DaveMongoose
स्रोत

यह प्रिंट "Good"या "Bad"(उद्धरण के साथ); मुझे यकीन नहीं है कि इसकी अनुमति है।

— जॉर्डन

1

इस तथ्य का दुरुपयोग करें कि putsएक सरणी के प्रत्येक तत्व को एक अलग लाइन पर प्रिंट करता है। यह 3 बाइट्स की तुलना में अधिक महंगा है p, लेकिन जब से आप इसे बाहर निकालते हैं, [0]तब यह बाहर निकलता है और फिर 2 बाइट्स को बिना किसी आवश्यकता के पार्सन्स से बचाते हैं। इसे ऑनलाइन आज़माएं!

— मान स्याही

@ValueInk धन्यवाद! जॉर्डन का मुद्दा भी इस बदलाव से हल हो जाता है इसलिए यह एक जीत है।

— डेवमॉन्गोज

3

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

(पठनीयता के लिए व्हॉट्सएप जोड़ा गया)

G.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:
Open mind.Be you nicer the sum ofa big cat the cube ofa big big cat?If solet usScene V.
You is the sum ofthe sum ofyou a big big cat a cat.Speak thy.You is the sum ofyou twice twice twice the sum ofa big big cat a cat.Speak thy.Speak thy.You is the square oftwice the sum ofa big big cat a cat.Let usScene X.
Scene V:.Ajax:
You is the sum ofthe sum ofyou a big big pig a pig.Speak thy.You is the sum ofyou the sum ofa big big big big big cat a pig.Speak thy.You is the sum ofyou the sum ofa big cat a cat.
Scene X:.Ajax:Speak thy.

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

मुझे इनपुट का पहला अक्षर मिलता है Open mind। फिर मुझे यह निर्धारित करने की आवश्यकता है कि यह क्या है। B= 66 और G= 71 के बीच की सभी संख्याओं में से , मेरा ब्रूट फ़ॉरेसर कहता है कि 66 लिखना सबसे कम है ( the sum ofa big cat the cube ofa big big cat), इसलिए मैं इनपुट के पहले अक्षर की तुलना 66 से करता हूं। दृश्य I प्रिंट करना जारी रखता है Good, या दृश्य V प्रिंट Bad।

— हैलो अलविदा
स्रोत

2

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

oo
o
T`G\oaB`Ro
o
oo

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण सूट शामिल है। स्पष्टीकरण:

oo
o

बारी Goodमें God।

T`G\oaB`Ro

GoaBउस सूची के रिवर्स के साथ अक्षरों को स्थानांतरित करें , इस प्रकार Gसे Bऔर के oसाथ aआदान-प्रदान, यानी के Godसाथ आदान-प्रदान Bad।

o
oo

बारी Godमें Good।

— नील
स्रोत

1

17 बाइट्स , लेकिन कम रचनात्मक

— pbeentje

2

स्टैक्स , 9 8 बाइट्स

çEF♫a║▬h

इसे चलाएं और डीबग करें

~~अनिवार्य रूप से replace("BadGood", input, "")।~~

"GooBa" के साथ मल्टीसेट xor। एल्गोरिथ्म लुइस मेन्डो से वर्बेटिम की नकल की

— पुनरावर्ती
स्रोत

2

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

=IF(A1>"C","Bad","Good")

@ MilkyWay90 के <Cसुझाव का उपयोग करना ।

— Wernisch
स्रोत

2

PHP ,26 23 बाइट्स

एक टर्नरी सिर्फ सस्ता है:

<?=$argn==Bad?Goo:Ba?>d

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

मूल उत्तर, 26 बाइट्स

<?=[Ba,Goo][$argn==Bad]?>d

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

या 21 बाइट्स (लेकिन यह मूल रूप से अरनुल्ड का जवाब है )

<?=$argn[3]?Ba:Goo?>d

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

— 640KB
स्रोत

प्रश्न के वाक्यांश को देखते हुए, readline()की तुलना में अधिक उपयुक्त होने की संभावना है $argn।

— प्रागक्रोक

2

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

“GooBa”œ^

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

व्याख्या

इनपुट और स्ट्रिंग के बीच मल्टीसेट सममित अंतर “GooBa”।

— लुइस मेंडो
स्रोत

@JonathanAllan धन्यवाद संपादित

— लुइस मेंडू

मुझे ऐसा कोई संकेत नहीं दिख रहा है कि इनपुट को STDIN के माध्यम से आना है ...

— एरिक आउटगॉल्फर

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

— जोनाथन एलन

ऐसा लगता है कि ओपी ने जवाब दिया, इनपुट STDIN तक सीमित नहीं है।

— एर्ग आउटफोलर

@EriktheOutgolfer धन्यवाद! लुढ़का हुआ

— लुइस मेंडो

2

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

'Good','Bad'-ne$args

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

-2 बाइट्स mazzy के लिए धन्यवाद

— आंद्रेई ओडेगो
स्रोत

1

19 बाइट में 20 बाइट्स

— माज़ी

2

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

?^_^_o=[^aB^_|^ooG^]

2

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

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

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

बैड पर निर्भर गुड से एक अक्षर छोटा है, इसलिए अंतिम इनपुट खाली है।

स्पष्टीकरण:

,>,,<<,       Get input into the first three cells
[             If the last letter was not empty (i.e. Good)
 >-----.      Decrement 'G' to 'B' and print
 <---.        Decrement 'd' to 'a' and print
 +++.         Increment back to 'd' and print
>>]           End loop
>[            If it is Bad instead
 +++++.       Increment 'B' to 'G' and print
 +[-<-->]<-.. Manipulate into  'o' and print twice
 >>.          Print 'd'
>]            End loop

— मजाक कर रहा है
स्रोत

2

बूलफक , 47 बाइट्स

+>,+;>,;,+;>;;;+;+;+[;<;;;,;+;;+;<];;+;+;;+;;+;

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

इस तथ्य का उपयोग करता है कि आप मूल रूप से इनपुट को बिट्स के रूप में ले सकते हैं और फिर कुछ बिट्स को विपरीत अक्षर में बदलने के लिए उल्टा कर सकते हैं।

स्पष्टीकरण:

+>,+;>,;,+;>;;;+;+;+    Print the first letter by inverting the first and third bits of the input
                        'B' = 01000010
                        'G' = 11100010
                        This leaves the tape as
                            1 1 1 1' in the case of Bad
                            1 0 0 1' in the case of Good
                        By making the center cells the inverted bits
[;<;;;,;+;;+;<]         Print the center letters by looping over the two pairs of cells
                        0 1' results in 'a' = 10000110
                        1 1' results in 'o' = 11110110 by printing the 1 in the 2-4th places
                        1 1 1 1' loops twice, while 1 0 0 1' only loops once
;;+;+;;+;;+;            Finally print 'd' = 00100110

— मजाक कर रहा है
स्रोत

2

Keg , `-rt` 20 17 15 13 8 7 बाइट्स (SBCS)

-᠀‘5ƳP↫

ट्रांसपाइल्स:

from KegLib import *
from Stackd import Stack
stack = Stack()
printed = False
iterable(stack, 'GoodBad')
string_input(stack)
maths(stack, '-')

if not printed:
    printing = ""
    for item in stack:
        if type(item) in [str, Stack]:
            printing += str(item)
        elif type(item) == Coherse.char:
            printing += item.v

        elif item < 10 or item > 256:
            printing += str(item)
        else:
            printing += chr(item)
    print(printing)

यह 05AB1E उत्तर का एक पोर्ट है। अनिवार्य रूप से, यह:

स्ट्रिंग को पुश करता है "GoodBad"
एक स्ट्रिंग के रूप में इनपुट लेता है
पुश स्ट्रिंग से इनपुट को घटाता है। यह GoodBadकुछ भी नहीं के साथ इनपुट के पहले उदाहरण को बदलकर काम करता है ।
परिणामी स्ट्रिंग को स्पष्ट रूप से प्रिंट करता है।
-rtझंडा केग बताता दाएं से बाएं टोकन पढ़ने के लिए।

उत्तर इतिहास

?G=[øBad|ø‘5Ƴ

निम्नलिखित के लिए ट्रांसपाइल्स:

from KegLib import *
from Stackd import Stack
stack = Stack()
printed = False
Input(stack)
character(stack, 'G')
comparative(stack, '=')
if bool(stack.pop()):
    empty(stack)
    character(stack, 'B')
    character(stack, 'a')
    character(stack, 'd')

else:
    empty(stack)
    iterable(stack, 'Good')

if not printed:
    printing = ""
    for item in stack:
        if type(item) is Stack:
            printing += str(item)

        elif type(item) is str:
            printing += custom_format(item)
        elif type(item) == Coherse.char:
            printing += item.v

        elif item < 10 or item > 256:
            printing += str(item)
        else:
            printing += chr(item)
    print(printing)

व्याख्या

?G=[øBad|ø‘5Ƴ

?            #Get input from user
 G=          #If the first letter is "G"
   [øBad     #Clear the stack and push "Bad"
        |    #Else,
         ø‘5Ƴ#Clear the stack and push the compressed string "Good"

— Lyxal
स्रोत

1

कमाल है, मैं उस लंबाई तक नहीं जा सका ... मैंने आपके जवाब को गलत ठहराया है।

@A__ ठीक वैसे ही जैसे मैंने आपका वोट किया है

— Lyxal

मेरा जवाब तुम्हारा बहुत बुरा है। आपको मेरा उत्तर नहीं देना चाहिए ...

क्या कोई तारीख अप करने के लिए प्रलेखन है?

— EdgyNerd

@EdgyNerd वास्तव में नहीं। जब से मैंने डॉक्स को अपडेट किया है तब से यह एक समय है। नई चीज़ों के बारे में अधिकांश जानकारी चैट में / यहाँ मिल सकती है

— Lyxal

2

चारकोल , 13 बाइट्स

¿⁻ＬＳ³Ba¦Goo¦d

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

स्पष्टीकरण:

¿⁻ＬＳ³          If length of input minus 3 is truthy:
      Ba¦         print Ba
         Goo¦       else print Goo
             d        print d

— छद्म नाम
स्रोत

"अच्छा" और "बुरा" गमागमन

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

कैसे?

एपीएल (Dyalog यूनिकोड) , 13 बाइट्स SBCS

ट्यूरिंग मशीन बट वे वर्स , 405 बाइट्स

बैश, 20 बाइट्स

8088 विधानसभा, आईबीएम पीसी डॉस, 25 बाइट्स

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

कैसे?

पायथन 3, 38 37 34 33 बाइट्स

सी, 39 38 बाइट्स

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

हास्केल, 36 34 बाइट्स

आर , 42 37 35 32 बाइट्स

sed , 21 16 13 बाइट्स

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

बेफुंज -93 , 20 18 बाइट्स

रूबी , 22 बाइट्स

05AB1E , 10 9 बाइट्स

जावा (JDK) , 124 बाइट्स

रूबी, 30 28 बाइट्स

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

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

स्टैक्स , 9 8 बाइट्स

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

PHP ,26 23 बाइट्स

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

व्याख्या

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

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

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

स्पष्टीकरण:

बूलफक , 47 बाइट्स

स्पष्टीकरण:

Keg , -rt 20 17 15 13 8 7 बाइट्स (SBCS)

उत्तर इतिहास

व्याख्या

चारकोल , 13 बाइट्स

स्पष्टीकरण:

एपीएल (Dyalog यूनिकोड) , 13 बाइट्स ^SBCS

Keg , `-rt` 20 17 15 13 8 7 बाइट्स (SBCS)