में इस सवाल का मैं एक अनाग्राम इसके उत्पादन के आधार पर Quine लगता है करने के लिए कहा। हालांकि ऐसा लग रहा है कि हमारे पास अभी तक गोल्फ अनाग्राम गोल्फ को पूछने का सवाल नहीं है। तो आपका काम यह होगा कि आप कम से कम एंग्राम क्वीन बना सकें।

विपर्यय क्वीन क्या है?

एनाग्राम क्वीन एक गैर रिक्त कार्यक्रम है जो अपने मूल कोड के अलावा अन्य अपने स्रोत कोड के विपर्यय को प्रिंट करता है।

यहाँ अजगर 2 में विपर्यय क्वीन का एक उदाहरण दिया गया है:

print`'`print`*2'*2`

इस चुनौती के लिए आपको अपना स्रोत नहीं पढ़ना चाहिए।

code-golf quine permutations

— गेहूं का जादूगर
स्रोत

2

@LeakyNun नहीं, यह एक क्वीन नहीं हो सकता।

— गेहूं जादूगर

2

क्या आउटपुट कोड को एक मान्य प्रोग्राम होना चाहिए?

— एमडी एक्सएफ

1

@MDXF नहीं यह नहीं है।

— गेहूं जादूगर

2

@ ओक्स यह एक क्वीन के लिए हमारी मानक आवश्यकताओं का पालन करना चाहिए (यह एक क्वीन होने के अलावा)।

— गेहूं जादूगर

1

@LeakyNun आपका मन है, मुझे नहीं लगता कि 0-बाइट कार्यक्रमों में एनाग्राम होते हैं जो मूल से भिन्न होते हैं!

— नील

29

अजगर , 2 बाइट्स

)(

आउटपुट

()

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

)  # Ends statement, does nothing in this program
 ( # Create an empty tuple
   # Implicitly print the empty tuple

— छड़ी
स्रोत

3

क्या इसका मतलब यह है कि आपने खोजा है कि ()एक अच्छी तरह से ज्ञात की तुलना में बहुत छोटा है jN*2]"jN*2]?

— जिम

1

@Jim नहीं, क्योंकि यह पेलोड-सक्षम नहीं है: c

— रॉड

9

वी , 4 बाइट्स

2ii2

आउटपुट:

i2i2

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

— रिले
स्रोत

2x डालें i2?

— कैलक्यूलेटरफैनलाइन

1

हां। 2 -> do the next thing twice i -> insert the following

— रिले

आह मैं देख रहा हूं, मुझे लगा कि यह विम था।

— गेहूं जादूगर

@WheatWizard नोप, यह मानक V quine का एक तुच्छ संशोधन है।

— रिले

1

@isaacg: नहीं, विम में आपको ईएससी को एक बार पूरा करने के बाद प्रेस करना होगा, जो कि एक समस्या है क्योंकि आउटपुट में कोई ईएससी चरित्र नहीं है।

9

> <> , 9 8 7 बाइट्स

का उपयोग करके !और वृद्धि करने के लिए @WheatWizard के लिए 1 बाइट के लिए धन्यवाद"

#इसके बजाय का उपयोग करके @ ConorO'Brien के लिए 1 बाइट का धन्यवाद दिया<!

":1->o#

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

आउटपुट "#o>-1:।

व्याख्या

":1->o#"        Push this string (note that the IP wraps around)
:               Duplicate the top value of the stack (35 from the "#")
1-              Subtract one from it to get 34 ('"')
>o#             Print every character on the stack until the program cannot pop any more and still tries to pop a value from the stack afterwards
                The program exits with an error from not being able to pop a value from an empty stack

— क्रिकटी लिथोस
स्रोत

":1+>o<!थोड़ा छोटा है।

— गेहूं जादूगर

@WheatWizard धन्यवाद, यह एक साफ-सुथरा गोल्फ था :)

— क्रिति लिथोस

1

आप 7 बाइट्स प्राप्त कर सकते हैं:":1->o#

— कॉनर ओ'ब्रायन

@ ConorO'Brien टिप के लिए धन्यवाद, यह वास्तव में चालाक है।

— कृतिका लिथोस

धन्यवाद :) मुझे सुखद आश्चर्य है कि यह वास्तविक रानी की

— कॉनर ओ'ब्रायन

9

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

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

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

यह सबसे छोटा संस्करण नहीं हो सकता है, लेकिन कम से कम यह काम करता है।

मजेदार तथ्य , आउटपुट कोड वास्तव में निष्पादित किया जा सकता है (और यह समाप्त होता है)।

उत्पादन

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

व्याख्या

>>--<<-[[<+>->+>->+++<<<]>-]    Initializes the tape with the
                                help of a recurrence relation.
<<<<<<[--->>.<<]>>++<<<[->>>
.<<<]>>-<<<[--->>>.<<<]>>>--    Prints the characters using
<<<<[++>>>>.<<<<]>>>>+++>--.    classic loops.
[---<.>]>+.......++.......

<<<>>>>>>>>>-----+++            Junk to complete the anagram.

— 6infinity8
स्रोत

8

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

प्रिंट ( "" "पी" आर "मैं" n "टी" 2 ( ") *" "" * 2)

प्रिंट p"r"i"n"t"2(")*p"r"i"n"t"2(")*\n, क्रमबद्ध आउटपुट:\n""""""""""""(())**22iinnpprrtt

— CalculatorFeline
स्रोत

उफ़, पुराना संस्करण :(

— कैलकुलेटर

1

@Downvoter कृपया अनवांटेड करें।

— कैलक्यूलेटरफैनलाइन

7

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

p"p*2"*2

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

यह प्रिंट करता है

"p*2p*2"

व्याख्या

यह सवाल में अजगर के जवाब के समान काम करता है। यह स्ट्रिंग बना देगा p*2p*2फिर रूबी के उपयोग से स्ट्रिंग pका प्रतिनिधित्व प्रिंट होगा।

— गेहूं का जादूगर
स्रोत

आप के pबजाय का उपयोग कर सकते हैं puts! इतना समय बर्बाद ...

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

4

@carusocomputing यह पुट के रूप में एक ही बात नहीं है। p xके बराबर हैputs x.inspect

— कॉनर ओ'ब्रायन

6

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

f=($=`($)=>{$=$+"${"``"}$"}`)=>$+$

फ़ंक्शन के साथ कोई गड़बड़ नहीं है। एक बोनस के रूप में, स्ट्रिंग के अंदर का कोड लगभग कानूनी लगता है। संपादित करें: के +बजाय का उपयोग करके 8 बाइट्स सहेजे गए repeat(2)।

— नील
स्रोत

1

के *2बजाय का उपयोग क्यों नहीं .repeat(2)करता है, कि काम नहीं करता है?

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

1

@carusocomputing JavaScript *स्ट्रिंग्स के लिए अधिभार नहीं डालती है

— कॉनर ओ'ब्रायन

1

@carusocomputing कि मुझे एक विचार दिया, धन्यवाद!

— नील

4

क्लेन , 7 + 6 = 13 बाइट्स

यहाँ पर एक उत्तर दिया गया है > <> उत्तर के आधार पर ।

":1+@!

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

यह आउटपुट

:1+@!"

— गेहूं का जादूगर
स्रोत

4

जाप , 10 9 बाइट्स

बेहतर तरीका मिला :-)

Q+2ç"Q+2ç

आउटपुट "Q+2çQ+2ç। इसे ऑनलाइन टेस्ट करें!

व्याख्या

Q+2ç"Q+2ç    // Implicit: Q = quotation mark
    "Q+2ç    // Take this string.     Q+2ç
  2ç         // Repeat it twice.      Q+2çQ+2ç
Q+           // Prepend a quote.      "Q+2çQ+2ç
             // Implicit: output result of last expression

भी हो सकता है Qi2ç"Qi2ç, जो प्रिंट करता है Qi2çQi2ç"। यह मानक जाप क्वीन के करीब है:

"iQ ²"iQ ²

लेकिन मुझे विश्वास नहीं है कि 9-बाइट क्वीन के लिए स्ट्रिंग के बीच में उद्धरण चिह्न को छेड़ने का कोई आसान तरीका है।

— ETHproductions
स्रोत

एक और 10-बटर:Q+"+Q² " ²

— कॉनर ओ'ब्रायन

@ ConorO'Brien हां, और आप हमेशा 24 संभावित क्रमों में से प्रत्येक में स्ट्रिंग के अंदर 4 वर्णों की व्यवस्था कर सकते हैं। इसके अलावा, मेरा मानना है कि आप हमेशा दोनों स्थानों को नई

— कहानियों के

3

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

$><<%q($><<%q()*2)*2

यह आउटपुट

$><<%q()*2$><<%q()*2

रूबी के %q(...)स्ट्रिंग सिंटैक्स का लाभ उठाते हुए , जो नेस्टेड कोष्ठक का समर्थन करता है।

— Doorknob
स्रोत

3

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


_

$nn$

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

प्रिंटों


n$_
n$

दोनों में एक _, दो n, दो $और तीन लाइनफीड होते हैं।

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

व्याख्या

खाली इनपुट को ए से बदलें _।


$nn$

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

हम n$n$इस चरण में भी उपयोग कर सकते हैं , जो तब प्रिंट करेगा:

n
$_n
$

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

3

पायथन रेप्लस, 4 बाइट्स

यह मेरा पहला कोड गोल्फ समाधान है, इसलिए मुझे उम्मीद है कि यह नियमों को पूरा करेगा। अजगर 2 या 3 इंटरैक्टिव दुभाषिया में:

>>> (1),
(1,)

आउटपुट इनपुट का विपर्यय है।

एक और:

>>> 2*'2*'
'2*2*'

पायथन 2 में:

>>> type('rst <>'),
(<type 'str'>,)

पायथन 3 में:

>> {1, 0}
{0, 1}

अद्यतन 2017-06-15: फिर भी एक और:

>>> 01.
1.0

— कर्नल आतंक
स्रोत

1

मुझे लगता है कि यहां अंतिम उत्तर क्वीन नियमों का उल्लंघन करता है (आउटपुट में सभी वर्ण इनपुट में मिलान वर्ण के समान उद्देश्य की सेवा करते हैं)। अन्य ठीक हैं, हालांकि।

2

हास्केल , 38 39 बाइट्स

main=print$[0,0]>>"main=print$[0,0]>>"

इसे ऑनलाइन आज़माएं! आउटपुट:

"main=print$[0,0]>>main=print$[0,0]>>"

संपादित करें: +1 बाइट क्योंकि मैं पहले अंतर्निहित अनुवर्ती नईलाइन के बारे में भूल गया था print।

वैकल्पिक: (एक ही बाइट काउंट में ASCII-उल्लू शामिल नहीं है)

main=print$e++e;e="main=print$e++e;e="

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

आउटपुट:

"main=print$e++e;e=main=print$e++e;e="

— Laikoni
स्रोत

अभी मुश्किल से नहीं बल्कि एक सच्चे Quine से एक अनाग्राम Quine ....

— Feathercrown

2

ग्रूवी, 24 20 बाइट्स

{"""{""*""2""}"""*2}

कैलक्यूलेटर कैलकुलेटर के लिए -4 धन्यवाद, व्हॉट्सएप की जरूरत नहीं थी!

आउटपुट:

{""*""2""}{""*""2""}

स्पष्टीकरण:

अनाम बंद होने पर, जिसे बुलाया जाता है, {""*""2""}दो बार (संक्षिप्त) लौटता है ।

— जादू ऑक्टोपस Urn
स्रोत

1

कृपया स्पष्टीकरण दें। इसके अलावा, बाइट्स (शायद) *2उद्धरणों के बीच पैडिंग के रूप में उपयोग करके बचाए जा सकते हैं :{"""{""*""2""}"""*2}

— कैलक्यूलेटरफ्लीन

@CalculatorFeline यह बहुत आत्म व्याख्यात्मक है। लेकिन हां, यह एक <s> 100% </ s> मेरा 9% बेहतर विचार है।

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

3

वास्तव में, यह केवल 9% बेहतर है: पी

— कैलकुलेटरफ्लीन

2

05AB1E , 10 बाइट्स

'∞∞''∞'JJ∞

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

आउटपुट:

∞∞''JJ''∞∞

स्पष्टीकरण:

Code       | Explanation                | Stack
-----------+----------------------------+-------------------
'∞         | Push literal '∞'.          | ["∞"]
  ∞        | Mirror.                    | ["∞∞"]
   ''      | Push literal "'".          | ["∞∞","'"]
     ∞     | Mirror.                    | ["∞∞","''"]
      'J   | Push literal 'J'.          | ["∞∞","''","J"]
        J  | Join it all together.      | ["∞∞''J"]
         ∞ | Mirror.                    | ["∞∞''JJ''∞∞"]
-----------+----------------------------+-------------------
           | Implicit print.            | ∞∞''JJ''∞∞

— जादू ऑक्टोपस Urn
स्रोत

2

सीजाम , 6 बाइट्स

"_`"_`

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

प्रिंटों

_`"_`"

व्याख्या

"_`"   e# Push this string.
_      e# Duplicate.
`      e# Stringify it, which wraps it in quotes.
       e# Implicitly print stack contents.

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

मैं यह पोस्ट करने वाला था ... "` _ "

— _`

1

बैश, 36 बाइट्स

tee f<<<'tee f<<<""cat f'"''"
cat f

यह आउटपुट

tee f<<<""cat f''
tee f<<<""cat f''

(और फ़ाइल fको साइड इफेक्ट के रूप में बनाता है, लेकिन इसे प्रति मेटा अनुमति दी जाती है ।)

कार्यक्रम और आउटपुट दोनों में एक अनुगामी न्यूलाइन है।

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

tee f<<<string
cat f

स्ट्रिंग को उद्धृत करने की आवश्यकता है क्योंकि इसमें रिक्त स्थान और <वर्ण होंगे, इसलिए तब मेरे पास था

tee f<<<'tee f<<<cat f'
cat f

जो लगभग काम करता है, सिवाय इसके कि यह उद्धरणों का उत्पादन नहीं करता है। सौभाग्य से, बैश बस एक दूसरे के बगल में रखकर स्ट्रिंग शाब्दिक संयोजन का समर्थन करता है, इसलिए "''"हेस्ट्रिंग से जुड़ने और ""एकल उद्धरण भाग के अंदर डालने से यह समाधान निकलता है ।

— Doorknob
स्रोत

1

PHP , 44 बाइट्स

<?=str_repeat('<?=\str_\repeat(\'\',2);',2);

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

— जार्ग हुल्सरमैन
स्रोत

1

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

"2*`"2*`

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

व्याख्या

प्रश्न में पायथन उदाहरण के समान

"2*`"     e# Push the string "2*`"
     2*   e# Repeat it twice
       `  e# Get its string representation (wrap in quotes)

आउटपुट है "2*`2*`"।

— बिजनेस कैट
स्रोत

1

Befunge, 11 बाइट्स

' 2+">:#,_@

प्रिंटों:

+2 '@_,#:>"

स्पष्टीकरण:

' 2+"        Put a " on the stack (32 + 2)
    "        Put the rest of the code on stack (wrap-around string)
     >:#,_   Print stack
          @  End

— MegaTom
स्रोत

हाँ। लेकिन ऐसा करता है "। उस पर क्या प्रतिबंध है?

— मेगाटॉम

मुझे नहीं लगता कि "इसे पढ़ने वाले खुद का स्रोत मानते हैं, यह सिर्फ एक स्ट्रिंग शाब्दिक है। gहालांकि बहुत ही स्पष्ट रूप से अपने स्वयं के स्रोत को पढ़ रहा है।

— गेहूं जादूगर

@HeatWizard ठीक है। मै इसे बदलूंगा।

— मेगाटॉम

":1+>:#,_@!यह भी काम करता है लेकिन इसकी कमी नहीं है।

— गेहूं जादूगर

' 2+"8k,@9 बाइट्स के लिए

— अंडा

1

QBIC , 8 बाइट्स

?A+@?A@+

मुझे अभी पता चला है कि QBIC में एक उचित क्वीन कैसे करें। इसके बाहर विपर्यय बनाना स्ट्रिंग स्ट्रिंग में वर्णों के आसपास बस स्विच करके किया जाता है। इस तरह से 24 संभावित एनाग्रम हैं।

— steenbergh
स्रोत

1

Befunge-98 , 8 बाइट्स

"'$<@,k7

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

— OVS
स्रोत

1

ओम , 14 बाइट्स

"æ3M.Cæ"æ3M."C

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

आउटपुट:

æ3M.CæC.M3æ"""

व्याख्या

"æ3M.Cæ"æ3M."C
"æ3M.Cæ"       # Pushes "æ3M.Cæ"
        æ      # Palindrone of that string
         3M    # 3 times...
           ."   # Push " on the stack
             C  # Concatenate with the string above

— Datboi
स्रोत

1

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

f=(s='f=')=>f+s

आउटपुट:

(s='f=')=>f+sf=

स्निपेट:

कोड स्निपेट दिखाएं

f=(s='f=')=>f+s

console.log(f());

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

— रिक हिचकॉक
स्रोत

1

विखंडन 2 , 9 8 6 बाइट्स

R"'!+O

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

व्याख्या

एक परमाणु बनाया जाता है R, जो सही चलता है। यह परमाणु तब एक के पार आता है ", जो मुद्रण मोड शुरू करता है। प्रिंटिंग मोड में, सभी वर्ण (मिलान तक ") मुद्रित होते हैं। इसका मतलब है कि यह '!+ORइस मामले में प्रिंट करता है। फिर, जो कुछ बचा है ", वह छपाई है , जो शेष पात्रों द्वारा किया जाता है। '!एटम के द्रव्यमान को वर्ण कोड में सेट करता है !, और +इसे वर्ण कोड में बढ़ाता है "। फिर, चरित्र कोड द्वारा आउटपुट होता है Oऔर परमाणु को नष्ट कर दिया जाता है, कार्यक्रम समाप्त होता है।

(असल में, यह सबसे छोटी रानी का सिर्फ एक चक्कर है)

— ल्यूक
स्रोत

मेरा मानना है कि आप केवल मानक क्वीन का उपयोग कर सकते हैं और इसे साइक्लीकली शिफ्ट कर सकते हैं (इसलिए कुछ ऐसा R"'!+O, अप्रयुक्त)।

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

@MartinEnder: आप सही कह रहे हैं। अपडेट किया गया। मदद के लिए धन्यवाद।

— ल्यूक

1

गणितज्ञ, 2 बाइट्स

.0

आउटपुट:

0.

दशमलव बिंदु से शुरू होने वाली संख्या जैसे कि .123व्याख्या की जाती है 0.123, वैसे .0ही व्याख्या की जाती है 0.0। चूंकि दशमलव बिंदु के बाद संख्या का हिस्सा शून्य है, इसलिए गणितज्ञ इसे प्रिंट नहीं करता है।

— बेन
स्रोत

1

मुझे नहीं लगता कि यह मान्य है। हमारी साइट परिभाषा के लिए यह आवश्यक है कि क्वीन में एक "एनकोडर" और एक "डिकोडर" हो, यह बैन शाब्दिक केवल प्रकार का क्वीन है।

— गेहूं जादूगर

खदानों के लिए सभी नियम इस चुनौती को पूरा करते हैं।

— गेहूं जादूगर

@HeatWizard: .खुद को एन्कोड करता है, लेकिन मुझे नहीं लगता 0है? दशमलव बिंदु से परे एक 0 को दशमलव बिंदु से पहले एक प्रमुख शून्य को एन्कोडिंग के रूप में नहीं देखा जा सकता है, बाद वाला फ्लोट को प्रिंट करने का एक साइड इफेक्ट है। पुराने नियम के तहत, यहाँ कोई समस्या नहीं है। (मुझे यकीन नहीं है कि नए नियम अभी तक लागू हुए हैं।)

@ ais523 मुझे नहीं पता। शायद यह एक मेटा प्रश्न द्वारा संबोधित किया जाना चाहिए।

— गेहूं जादूगर

1

जावास्क्रिप्ट (अभी तक एक और), 11 बाइट्स

f=_=>'=f'+f

के साथ फोन किया f(), आउटपुट

=f_=>'=f'+f

कोड स्निपेट दिखाएं

f=_=>'=f'+f

console.log(f());

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

— गोटो ०
स्रोत

1

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

a='a=%r;pritn(a%%a)';print(a%a)

— आये आये
स्रोत

1

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

.S.S

भागो और डिबग ऑनलाइन!

इस उत्तर का एक सीधा बंदरगाह ।

पुराना संस्करण, 8 बाइट्स

..b..LbL

भागो और डिबग ऑनलाइन!

एक सस्ती सस्ती चाल के साथ वैकल्पिक संस्करण जिसे लगभग किसी भी भाषा में उचित quines पर लागू किया जा सकता है।

"43bL"34bL

भागो और डिबग ऑनलाइन!

क्योंकि "34bL"34bLस्टैक्स में एक उचित क्वीन है।

अभी तक एक और संस्करण, केवल सिंगल-चार स्ट्रिंग शाब्दिक का उपयोग कर।

''c'Lc'cccLcLL

भागो और डिबग ऑनलाइन!

व्याख्या

.S.S        Generates powerset ["","S","S.","."]
            Implicit flatten and output

..b         Push string ".b"
   ..L      Push string ".L"
      b     Duplicate both strings
       L    Concatenate all 4 strings to a single one.

— वीजुन झोउ
स्रोत

0

05AB1E , 13 बाइट्स

"34çJ∞"34çJ∞

आउटपुट:

34çJ∞""∞Jç43

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

"34çJ∞"      # Push this string                 | [ 34çJ∞ ]
       34ç   # Push a quote (")                 | [ 34çJ∞, " ]
          J  # Join                             | [ 34çJ∞" ]
           ∞ # Mirror                           | [ 34çJ∞""∞Jç43 ]
             # Implicitly output with a newline

— रिले
स्रोत

गोल्फ एनाग्राम क्वाइन

विपर्यय क्वीन क्या है?

अजगर , 2 बाइट्स

वी , 4 बाइट्स

> <> , 9 8 7 बाइट्स

व्याख्या

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

उत्पादन

व्याख्या

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

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

व्याख्या

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

क्लेन , 7 + 6 = 13 बाइट्स

जाप , 10 9 बाइट्स

व्याख्या

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

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

व्याख्या

पायथन रेप्लस, 4 बाइट्स

हास्केल , 38 39 बाइट्स

ग्रूवी, 24 20 बाइट्स

आउटपुट:

स्पष्टीकरण:

05AB1E , 10 बाइट्स

आउटपुट:

स्पष्टीकरण:

सीजाम , 6 बाइट्स

व्याख्या

बैश, 36 बाइट्स

PHP , 44 बाइट्स

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

व्याख्या

Befunge, 11 बाइट्स

QBIC , 8 बाइट्स

Befunge-98 , 8 बाइट्स

ओम , 14 बाइट्स

व्याख्या

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

विखंडन 2 , 9 8 6 बाइट्स

व्याख्या

गणितज्ञ, 2 बाइट्स

जावास्क्रिप्ट (अभी तक एक और), 11 बाइट्स

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

व्याख्या

05AB1E , 13 बाइट्स