क्विन / रिवर्स क्वीन

Question

एक पूरा कार्यक्रम लिखें जो एक बूलियन या गैर-नकारात्मक पूर्णांक इनपुट लेता है। यह जरुरी है:

• यदि इनपुट मान गलत है, तो अपना स्वयं का सोर्स कोड आउटपुट करें
• यदि इनपुट मान सत्य है, तो रिवर्स में अपने स्वयं के सोर्स कोड को आउटपुट करें

आपका कार्यक्रम पैलंड्रोमिक नहीं हो सकता है, न ही यह किसी भी तरह से अपने स्वयं के स्रोत कोड को पढ़ सकता है।

यह कोड गोल्फ है - बाइट्स जीत में सबसे छोटा कोड।

Comments

इसलिए ... अगर मेरी भाषा में बूलियन्स नहीं हैं। लेकिन 0 मिथ्या है और सकारात्मक पूर्णांक सत्य हैं। क्या मैं यह मान सकता हूं कि इनपुट केवल 0 या 1 होगा (बूलियंस के लिए स्टैंड-इन के रूप में - भाषा वास्तव में हमेशा उन दोनों में से एक को एक सशर्त ऑपरेटर के परिणाम के रूप में प्राप्त करेगी)? या क्या मुझे किसी पूर्णांक का समर्थन करना है, क्योंकि मैं "वास्तविक" बूलियन का उपयोग नहीं कर सकता हूं?

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

Answer 1

गोल> <> , 9 बाइट्स

'rd3*I?rH

मुझे यह जानकर थोड़ा अजीब लगा, क्योंकि हमारे पास पहले से ही <> विटी और मिंकोलंग उत्तर हैं। मानक क्वीन के लिए एकमात्र जोड़ I(पूर्णांक इनपुट पढ़ें), ?(अगले सत्य पर अमल करें) और r(रिवर्स स्टैक) हैं।

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

Comments

संघ में शामिल हों! : D आप वैसे भी जीत रहे हैं। +1

— Addison Crump

8 बाइट्स:sP#Hr?I"

— जो किंग

Answer 2

सीजेएम, 17 16 बाइट्स

{`"_~"+Wq~g#%}_~

इसका परीक्षण यहां करें।

मानक क्वीन का एक काफी सीधा-आगे संशोधन। 17 बाइट्स के लिए अन्य समाधान:

{`"_~"+q~{W%}&}_~
{`"_~"+q~!2*(%}_~

अगर मैं मान सकता हूं कि इनपुट केवल 0 या 1 है (बूलियन के लिए स्टैंड-इन के रूप में, जो कि सीजेएम के लिए कोई समर्पित प्रकार नहीं है), तो मैं 15 को छोड़ कर प्राप्त करता हूं g:

{`"_~"+Wq~#%}_~

व्याख्या

{`"_~"+  e# Standard generalised quine framework. Leaves the source code on the stack. 
  W      e# Push a -1.
  q~     e# Read and evaluate input.
  g      e# signum, turning truthy values into 1 (leaving 0 unchanged).
  #      e# Power. -1^0 == 1, -1^1 == -1.
  %      e# Select every Nth element: a no-op for 1 and reverses the string for -1.
}_~

Comments

चूंकि 0 और 1 CJam के बूलियन हैं, मुझे नहीं लगता कि आपको इसकी आवश्यकता है g।

— डेनिस

@ डेनिस हाँ मुझे उस पर वास्तव में यकीन नहीं था।

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

हैरानी की बात यह है कि मैंने किसी तरह इसे हराया। यदि आप इसे और अधिक नीचे गोल्फ, लेकिन मुझे आश्चर्य नहीं होगा : डी

— एडिसन क्रम्प

Answer 3

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

_WQjN*2]"_WQjN*2]

मानक पायथ क्वीन का एक सीधा संशोधन।

Comments

लानत है, मैं इसे एक घंटे के बाद से सैंडबॉक्स होने के बाद पोस्ट करने की प्रतीक्षा कर रहा था।

— 2050

Answer 4

> <>, 17 बाइट्स

स्टैक पर इनपुट पुश करने के लिए -v फ्लैग (+1 बाइट) की आवश्यकता होती है (या ऑनलाइन इंटरप्रेटर पर पहले से स्टैक पर इनपुट डालने के लिए)।

'rd3*$?rol?!;70.

आप बाइट्स (ध्वज के बिना) की समान मात्रा के लिए नीचे कर सकते हैं यदि पूर्णांक इनपुट केवल अनुमत थे (यानी 0 झूठी के लिए, सत्य के लिए 1)।

'rd3*ic%?rol?!;80.

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

सत्य </ falsy के लिए> <> क्रमशः 0 और 0 कुछ भी नहीं हैं।

Answer 5

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

... मैं ... मैं सीजाम की पिटाई कर रहा हूँ! (पर चिल्लाते हुए) माँ! देखो, मा, मैंने इसे टाल दिया!

'Rd3 * i86 * -) आर एल \ हे

स्पष्टीकरण:

'Rd3 * i86 * - (आर एल \ हे
मानक क्वीन, लेकिन एक मोड़ के साथ:

'स्रोत कोड को एक स्ट्रिंग के रूप में कैप्चर करें
 rd3 * ASCII में 'चरित्र बनाएँ
     i86 * - ASCII के रूप में इनपुट चरित्र प्राप्त करें और फिर उसमें से 48 घटाएं। 
                    यदि यह शून्य है, तो यह होगा यदि कथन अगले निर्देश को छोड़ देगा।
          (r यदि स्टैक का शीर्ष आइटम शून्य है, तो अगला आइटम न करें।
                    यहां अगला आइटम रिवर्स है।
            l \ O स्टैक का प्रिंट आउट लें।

Vitsy का नया संस्करण , 11 बाइट्स

v'rd3 *} v) RZ
v इनपुट को एक चर के रूप में कैप्चर करें।
 'जब तक दूसरे से मुठभेड़ न हो तब तक स्रोत पर कब्जा करो'
  stack स्टैक को उल्टा करें।
   d3 * स्टैक पर पुश करें।
      } स्टैक को दाईं ओर घुमाएं।
       v) यदि यह शून्य नहीं है तो स्टैक और परीक्षण के लिए चर (इनपुट) को पुश करें।
         यदि ऐसा है, तो स्टैक को उल्टा करें।
          Z स्टैक में सब कुछ आउटपुट।

Answer 6

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

$=_=>'$='+(_?$:[...''+$].reverse().join``)

यह मेरी ब्लिंग क्वीन का एक संशोधन है । यह दो बार लंबा है, भी।

Comments

क्या यह वास्तव में कुछ भी उत्पादन करता है? जवाब है कि केवल एक REPL में काम करने की अनुमति नहीं है।

— feersum

@ETHproductions जो फ़ंक्शन को कॉल करेगा, लेकिन यह अभी भी कुछ भी प्रिंट नहीं करेगा। इसके अलावा, यह अब और नहीं होगा।

— डेनिस

@ डेनिस राइट। ठीक है, मुझे लगता है कि इसका मतलब prompt()आवश्यक है, जब तक कि हम Node.JS पर नहीं जाते। मेरा मानना ​​है कि $=_=>(A=`$=${$};$(prompt())`,alert(_?A:[...A].reverse().join``));$(prompt())यह ठीक से काम करता है, हालांकि शायद इसे और नीचे ले जाया जा सकता है।

— ETHproductions

"आपका कार्यक्रम किसी भी तरह से अपना स्रोत कोड नहीं पढ़ सकता है ... [...] क्या यह समाधान इस श्रेणी में आता है?

— ETHproductions

Answer 7

बर्लेस्क, 40 बाइट्स

ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh

स्पष्टीकरण:

बर्लेस्क में उन्नत स्टैक और कोड हेरफेर बिल्ट-इन है। वास्तव में, आप प्रोग्राम के स्रोत कोड का उपयोग नहीं कर सकते हैं, लेकिन आप भविष्य में निष्पादित होने वाले शेष कोड तक पहुंच सकते हैं। इसका मतलब यह है कि #Qइसके बाद आने वाले सभी कोड वापस आ जाएंगे, यही वजह है कि हमें #Qउस कोड में सब कुछ जोड़ना होगा जो हम कर रहे हैं ri#Q।

blsq ) #Q1 2++
12 -- this is the result of 1 2++
{1 2 ++} -- this is the result of #Q

++1 2स्टैक आधारित होने के कारण तकनीकी रूप से अवैध कोड है। लेकिन हम इसे निष्पादित करने के लिए कोड में हेरफेर कर सकते हैं 1 2++:

blsq ) #Q<-#q++1 2 
12

इन बिल्ट-इन के साथ काम करना अविश्वसनीय रूप से पेचीदा है और किसी ने भी अभी तक क्वीन से संबंधित चीजों के अलावा किसी भी उत्पादक के लिए इसका इस्तेमाल नहीं किया है। यदि आप उलट जाते हैं ++1 2तो आपको 2 1++उत्पादन मिलेगा 21और नहीं 12। ऊपर दिए गए कोड 12का कारण #Qयह है क्योंकि इसमें भी <-इतना ही शामिल है कि हम अंत में बहुत अधिक निष्पादित कर रहे हैं 2 1++: p। हम निष्पादन को समाप्त करते हैं 2 1++#q<-जो पैदा करता है 12।

हम वास्तव में हमारे कोड में चीजों को बदल सकते हैं उदाहरण के लिए यह कोड ?+अपने आप में सभी घटनाओं को प्रतिस्थापित करता है?*

blsq ) #Q(?+)(?*)r~5.-#q5 5?+
25

उपयोग:

$ echo "1" | blsq --stdin 'ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh'
hs fi sp "-<" j +. /\ "Q#ir" -~ HS 2Q#ir
$ echo "0" | blsq --stdin 'ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh'
ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh

Answer 8

हास्केल, 126 118 108 बाइट्स

main=readLn>>=putStr.([t,reverse t]!!);t=s++show s;s="main=readLn>>=putStr.([t,reverse t]!!);t=s++show s;s="

अपेक्षा 0या 1इनपुट के रूप में।

Answer 9

मिन्कोलांग 0.10 , 13 बाइट्स

"66*2-n,?r$O.

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

यह इन चार वर्णों को छोड़कर मानक क्वीन के समान है n,?r:। nइनपुट से पूर्णांक लेता है, ,इसे निष्क्रिय कर देता है, इसलिए यदि इनपुट सत्य है तो इसे ?छोड़ rदिया जाता है। अन्यथा, rस्टैक को उलट देता है ताकि यह रिवर्स ऑर्डर में आउटपुट हो।

Comments

मेरी गड़गड़ाहट दूर हो गई है। : सी

— एडिसन क्रम्प

Answer 10

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

s="print('s=%r;exec s'%s)[::1-2*0**input()]";exec s

Answer 11

जावा 10 (पूर्ण कार्यक्रम), 282 बाइट्स

interface N{static void main(String[]a){var s="interface N{static void main(String[]a){var s=%c%s%1$c;s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}";s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}

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

जावा 10 (लैम्बडा फ़ंक्शन के रूप में), 154 बाइट्स

b->{var s="b->{var s=%c%s%1$c;s=s.format(s,34,s);return b?new StringBuffer(s).reverse():s;}";s=s.format(s,34,s);return b?new StringBuffer(s).reverse():s;}

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

स्पष्टीकरण:

interface N{                          // Class
  static void main(String[]a){        //  Mandatory main-method
    var s="interface N{static void main(String[]a){var s=%c%s%1$c;s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}";
                                      //   Unformatted source code
    s=s.format(s,34,s);               //   Format the source code (the quine-String)
    System.out.print(                 //   Print:
      new Boolean(a[0])?              //    If the input is true:
       new StringBuffer(s).reverse()  //     Print the quine-String reversed
      :                               //    Else:
       s);}}                          //     Print the quine-String as is

Quine स्पष्टीकरण:

• var sअस्वरूपित स्रोत कोड शामिल
• %s इस स्ट्रिंग को अपने साथ रखने के लिए उपयोग किया जाता है s.format(...)
• %c, %1$cऔर 34दोहरे उद्धरण चिह्नों को प्रारूपित करने के लिए उपयोग किया जाता है
• s.format(s,34,s) यह सब एक साथ रखता है

और फिर new StringBuffer(s).reverse()इनपुट-बूलियन के आधार पर क्विन-स्ट्रिंग को उलटने के लिए उपयोग किया जाता है।

Answer 12

05AB1E , 21 बाइट्स

0"D34çý‚sè"D34çý‚sè

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

जोड़कर डिफ़ॉल्ट क्वीन का संशोधन ।0"D34çý"D34çý‚sè

स्पष्टीकरण:

0                        # Push 0 to the stack
                         #  STACK: [0]
 "D34çý‚sè"             # Push the string 'D34çý‚sè' to the stack
                         #  STACK: [0, 'D34çý‚sè']
            D            # Duplicate this string
                         #  STACK: [0, 'D34çý‚sè', 'D34çý‚sè']
             34ç         # Push '"' to the stack
                         #  STACK: [0, 'D34çý‚sè', 'D34çý‚sè', '"']
                ý        # Join the stack with '"' delimiter
                         #  STACK: ['0"D34çý‚sè"D34çý‚sè']
                 Â       # Bifurcate (short for Duplicate & Reverse)
                         #  STACK: ['0"D34çý‚sè"D34çý‚sè', 'ès‚Âýç43D"ès‚Âýç43D"0']
                  ‚      # Pair them up:
                         #  STACK: [['0"D34çý‚sè"D34çý‚sè','ès‚Âýç43D"ès‚Âýç43D"0']]
                   s     # Swap to get the boolean input (0 or 1)
                         #  STACK: [['0"D34çý‚sè"D34çý‚sè','ès‚Âýç43D"ès‚Âýç43D"0'], 1]
                    è    # Index the input into the list
                         #  STACK: ['ès‚Âýç43D"ès‚Âýç43D"0']
                         # (Output the top of the stack implicitly)

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

0"D34çý‚sè?"D34çý‚sè?

इसे ऑनलाइन आज़माएं। ( नई लाइन के बिना? एक स्पष्ट प्रिंट है )