तीन पॉलीग्लॉट, दो पीरियड-दो क्वाइन और एक कोड-गोल्फ चैलेंज

32

एक प्रोग्राम ए का निर्माण करें जो इसे भाषा ए में चला रहा है, प्रोग्राम बी का उत्पादन करता है और भाषा बी में प्रोग्राम ए का निर्माण प्रोग्राम सी का उत्पादन करता है।

प्रोग्राम B, जब भाषा B में चलाया जाता है, प्रोग्राम A का निर्माण करता है, और भाषा A में प्रोग्राम B चलाने से प्रोग्राम C बनता है।

प्रोग्राम सी, जब भाषा ए या भाषा बी में चलाया जाता है, तो "गलत भाषा!"

Program | Language | Result
--------|----------|----------
A       | A        | Program B
B       | B        | Program A
A       | B        | Program C
B       | A        | Program C
C       | A        | "Wrong language!" 
C       | B        | "Wrong language!"

आपके उत्तर को इस टेम्पलेट का उपयोग करना चाहिए:

भाषा ए / भाषा बी, {एक बाइट्स} + {बी बाइट्स} = {कुल बाइट्स} बाइट्स

कार्यक्रम ए:

a code

कार्यक्रम बी:

b code

कार्यक्रम सी:

c code

स्रोत:

# Language A/Language B, <a bytes> + <b bytes> = <total bytes> bytes

Program A:

    a code
Program B:

    b code
Program C:

    c code
  • इन कार्यक्रमों में से कोई भी इनपुट नहीं लेना चाहिए।
  • एक ही भाषा के विभिन्न संस्करण अलग-अलग भाषाओं में गिने जाते हैं। (हालांकि यह हतोत्साहित किया जाता है क्योंकि यह उबाऊ समाधान की ओर जाता है)
  • भाषाएँ A और B अलग-अलग होनी चाहिए।
  • आपको फ़ाइल से अपना स्वयं का स्रोत कोड नहीं पढ़ना चाहिए। कार्यक्रम खाली नहीं हो सकते हैं
  • मानक खामियां लागू होती हैं।

संकेत

  • C ++ और [पायथन / बैश / अन्य #टिप्पणी वाली भाषाएँ] अच्छे कॉम्बो हैं क्योंकि आप मैक्रोज़ को परिभाषित कर सकते हैं कि एक भाषा को अनदेखा कर सकते हैं

यह कोड-गोल्फ है , इसलिए बाइट का सबसे छोटा योग प्रोग्राम ए और बी जीतता है।

code-golf  quine  code-generation  polyglot 
— noɥʇʎԀʎzɐɹƆ
स्रोत
मैं इस पर काम कर रहा हूँ ...
— ओलिवर नी
6
@CrazyPython दंड या प्रतिशत न करें। बस इसे अनुमति दें, या नहीं। प्रतिशत अब [कोड-गोल्फ] स्कोरिंग करते हैं। meta.codegolf.stackexchange.com/a/8106/34718
— mbomb007
1
@ ais523n मैंने इसे हटा दिया, यह चुनौती को बहुत आसान बना देता है।
— no --zɐɹƆ
1
@CrazyPython समाप्त। मैंने एक अलग रणनीति के साथ कल से शुरुआत की। यह बहुत छोटा और आसान होने के नाते समाप्त हो गया।
— mbomb007
1
Wrong language!किसी भी रूप में उत्पादन किया जा सकता है (यानी सभी कैप्स, सभी लोअरकेस, आदि)?
— आर। काप

जवाबों:

10

Befunge-98 (PyFunge) / > <> , 123 + 123 = 266 250 246 बाइट्स

कार्यक्रम ए: 
"81!#.#vp00g>:#,_j+4<.=1l5v!o#!g00
g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# \!gff+k,@,k*8ba$$ #o#!a"

इसे Befunge-98 में आज़माएं! , इसे> <> में आज़माएँ!

कार्यक्रम बी: 
"00g!#o!v5l1=.<4+j_,#:>g00pv#.#!18
g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# \!gff+k,@,k*8ba$$ #o#!a"

इसे> <> में आज़माएँ! , यह Befunge-98 में कोशिश करो!

कार्यक्रम सी: 
"a0!#.pek,@f[>o<!egaugnal gnorW

इसे Befunge-98 में आज़माएं! इसे> <> में आज़माएँ!

यह काम किस प्रकार करता है:

दोनों कार्यक्रमों में दूसरी पंक्ति समान है और दोनों भाषा के लिए समान कार्य करती है। जब बाईं ओर से प्रवेश किया जाता है <<<<, तो यह पूरी दूसरी पंक्ति को प्रिंट करता है। उन के दाईं ओर प्रवेश करते समय, प्रोग्राम सी प्रिंट करें।

जब पहली पंक्ति गलत भाषा में चलाई जाती है, तो यह प्रोग्राम C उत्पादक अनुभाग के माध्यम से प्रवेश करती है। अन्यथा, यह शीर्ष रेखा को आगे की तरफ पीछे की ओर प्रिंट "करता है और दूसरी पंक्ति के उत्पादन खंड में प्रवेश करता है।

पहली पंक्ति

कार्यक्रम ए: 
"81!#.#vp00g>:#,_j+4<.=1l5v!o#!g00

><>:
" Wrapping string literal over the first line
 81!#.  Jumps the pointer to the Program C producer

Befunge-98:
" Wrapping string literal
 81!#.  Pushes 8,0 (! inverts number, # skips over .)
      #v Skip over the exit
        p00g Pops the excess 8,0 and space and gets the " from 0,0
            >:#,_ Classic print until stack is empty
       v         j+4< Skips back to the exit and goes to the second line
कार्यक्रम बी: 
"00g!#o!v5l1=.<4+j_,#:>g00pv#.#!18

><>:
" Wrapping string literal
 00g!# Gets the " from 0,0
      o!v5l1=. Print until the stack is empty and jump to the second line

Befunge-98:

" Wrapping string literal
 00g Gets the " from 0,0
    !#o!v Skip the instruction o and go to Program C producer

दूसरी पंक्ति:

g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# $$00gff+k,@,k*9aa$$ #o#!a"

><>: Second line producer
g00<<<<< Get the " from cell 0,0
        ......      " Wrapping string literal over the stack
               #o#!a  Print newline and the stack and exit
Program C producer:
       >0!#[        Clear stack
            f8+1!#. Jump to cell 22,1
                   .....'...'   Push program C to the stack
                             00g Get " from cell 0,0
                                !#o# Print stack until empty

Befunge-98: Second line producer

g00<<<<< Get the " from cell 0,0
        ......              " Wrapping string literal
                       #o#!a  Skip over instruction o
                     $$       Pop the excess characters
                  90a Push a newline and 90
               @,k      Execute , instruction (print) 90+1 times, printing second line

Program C producer:
        >0!#[ Push 1 and skip [
             f8+1!#. Push 22, 0 and skip .
                    48*k'...' Execute ' instruction 32 times, pushing program C
                         ...'00g!#o# Push 0 and skip the instruction o
                                     \! Convert excess values to two 0s
                                       g Get " from cell 0,0
                                          ff+ Push 30
                                             k, Execute , 30+1 times, printing program C
                                               @ Exit program

कार्यक्रम सी

"a0!#.pek,@f[>o<!egaugnal gnorW

><>:
" Wrapping string literal
 a0!#. Jump to cell 10,0
           f[ Create a new stack with only the top 15 elements
             >o< Print stack

Befunge-98:
" Wrapping string literal
 a0!#. Push 10,1
      p Pop 10,1 and excess space
       ek,@ Push 14 and execute , 14+1 times and exit the program
— मजाक कर रहा है
स्रोत
2
1 बाइट बचाएं और आपको 400 का इनाम मिलेगा।
— मैजिक ऑक्टोपस Urn
@MagicOctopusUrn मुझे लगता है कि ओपी यह कहना भूल गया "अन्यथा जो किंग को मिल जाता है"
— जो किंग
@ जॉकिंग जरूरी नहीं है। यदि इनाम नहीं दिया जाता है, तो यह स्वचालित रूप से उच्चतम प्रतिनिधि को आधे प्रतिनिधि के साथ दिया जाता है।
— mbomb007
1
@MagicOctopusUrn ठीक है, वहाँ। खुश? : पी
— जो राजा
4x से अधिक खुशी; पी।
— मैजिक ऑक्टोपस Urn
16

जावास्क्रिप्ट (ईएस 6) / पायथन 3, 264 + 258 = 522 बाइट्स

कार्यक्रम ए:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;print(c);'''
console.log(b,...[a,b,c].map(uneval))//'''

कार्यक्रम बी:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;'''
print=_=>console.log(c)//'''
print(a%(a,b,c))

कार्यक्रम सी:

1//2;alert=print
alert('Wrong language!')

शायद गोल्फ ...

जावास्क्रिप्ट स्पष्टीकरण

कार्यक्रम ए:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;print(c);'''

// Print the Python program (b), replacing the "%s"s with the raw forms of a, b, and c:
console.log(b,...[a,b,c].map(uneval))//'''

कार्यक्रम बी:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;'''

// Define a function `print` which prints `c` (the "Wrong language!" program):
print=_=>console.log(c)//'''

// Call `print`, ignoring the argument (which is NaN):
print(a%(a,b,c))

कार्यक्रम सी:

// Ignore this line:
1//2;alert=print

// Alert "Wrong language!":
alert('Wrong language!')

अजगर की व्याख्या

कार्यक्रम ए:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Print `c` (the "Wrong language!" program):
1//2;print(c);

# Ignore this part:
'''
console.log(b,...[a,b,c].map(uneval))//'''

कार्यक्रम बी:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Ignore this part:
1//2;'''
print=_=>console.log(c)//'''

# Print the JS program (a), replacing the "%r"s with the raw forms of a, b, and c:
print(a%(a,b,c))

कार्यक्रम सी:

# Set `alert` to the function `print`:
1//2;alert=print

# Call this function on "Wrong language!":
alert('Wrong language!')
— ETHproductions
स्रोत
यह कैसे काम करता है की एक व्याख्या जोड़ने के लिए देखभाल?
— दोपहर ɥʇʎԀʎ
@CrazyPython पूरा हो गया :-)
— 15
बहुत रचनात्मक, अच्छी तरह से किया।
— no --zɐɹƆ 1
9

पायथन 3 + जावास्क्रिप्ट (राइनो), 171 + 171 = 342 बाइट्स

प्रोग्राम ए (आउटपुट प्रोग्राम बी में पायथन 3, जावास्क्रिप्ट में प्रोग्राम सी; नोट अनुगामी न्यूलाइन):

s="'";d='"';r=['print("s="+d+s+d+";d="+s+d+s+";r=["+s+r[1]+s+","+s+r[0]+s+"];eval(r[([11]+[0])[1]])")','print("print("+d+"Wrong language!"+d+")")'];eval(r[([11]+[0])[1]])

प्रोग्राम बी (जावास्क्रिप्ट में ए प्रोग्राम आउटपुट, पायथन में प्रोग्राम सी; नोट ट्राइलिंग न्यूलाइन):

s="'";d='"';r=['print("print("+d+"Wrong language!"+d+")")','print("s="+d+s+d+";d="+s+d+s+";r=["+s+r[1]+s+","+s+r[0]+s+"];eval(r[([11]+[0])[1]])")'];eval(r[([11]+[0])[1]])

प्रोग्राम सी (आउटपुट "गलत भाषा!" किसी भी भाषा में; एक अनुगामी न्यूलाइन भी है, जो स्कोर में नहीं गिना जाता है):

print("Wrong language!")

ध्यान दें कि मैं यहां जावास्क्रिप्ट की एक असामान्य बोली का उपयोग कर रहा हूं। लोग आमतौर पर ब्राउज़र कार्यान्वयन का उपयोग करते हैं, लेकिन उन लोगों के पास आउटपुट के साथ समस्या है, इसे एक अजीब तरीके से (उपयोग करके alert) कर रहे हैं। मैं उबंटू पैकेज का उपयोग कर रहा हूं, rhinoजो एक "ऑफ़लाइन" जावास्क्रिप्ट कार्यान्वयन है जो एक विशिष्ट ब्राउज़र पर लागू पुस्तकालयों के एक अलग सेट के साथ है (यह एक एम्बेड करने योग्य स्क्रिप्टिंग भाषा के रूप में अभिप्रेत है); यह उल्लेखनीय है कि यह printउसी शैली में एक कथन प्रदान करता है , उदाहरण के लिए, पायथन 3।

यह इस अर्थ में एक "सही बहुविकल्पी" है कि दोनों भाषाएं एक ही क्रम में, एक ही क्रम में चल रही हैं, जिससे उन्हें समान अर्थ मिलता है। उन दोनों के पास एक ही एएसटी है (और इस कार्यक्रम को कम करने के माध्यम से पायथन 3 + जावास्क्रिप्ट पॉलीग्लॉट क्वीन बनाने के लिए यह काफी तुच्छ है)। ऐसा कोई कोड नहीं है जो एक भाषा के लिए विशिष्ट हो, जो मुझे लंबाई को नीचे लाने में मदद करता है। संयोग से, आपको पायथन 3 का उपयोग करना होगा ताकि आप अलग-अलग बयानों के लिए अर्धविरामों का उपयोग कर सकें (यदि आपने नईलाइन्स का उपयोग किया है तो आपको नए अक्षरों से बचना होगा)।

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

कार्यक्रम का दिल वह सरणी है rजो चुनौती द्वारा उपयोग किए जाने वाले दो कार्यक्रमों का मुख्य निकाय रखती है; कार्यक्रमों में से एक (एक जो प्रोग्राम ए में पहले आता है, और दूसरा प्रोग्राम बी में) एक लगभग क्वीन है जो बस मूल कार्यक्रम को एक साथ टुकड़े के माध्यम से आउटपुट करता है (ज्यादातर rखुद से, कुछ स्ट्रिंग शाब्दिक के साथ), और अन्य प्रिंट प्रोग्राम सी। प्रोग्राम को सच्ची क्वीन नहीं बनाने के लिए (जिससे यह पता लगाना असंभव हो जाता है कि हम गलत भाषा में चल रहे थे), rउल्टे क्रम में मुद्रित होने वाले तत्व ; r[0]कार्यक्रम ए r[1]में कार्यक्रम बी में है, और इसके विपरीत।

अंत में, यह आवश्यक है evalकि सही तत्व का उपयोग किया जाए r। यह उस अभिव्यक्ति का उपयोग करके पूरा किया जाता है ([11]+[0])[1]जो पायथन 3 और जावास्क्रिप्ट में एक अलग मूल्य पैदा करता है। दोनों भाषाएं इसे समान रूप से परिभाषित करती हैं, लेकिन उनके पास अलग-अलग विचार हैं कि सूचियों के अलावा क्या होता है:

  • जब पायथन 3 को जोड़ता [11]है [0], तो यह [11, 0](सूचियों को संक्षिप्त करना) हो जाता है , और फिर सूची का दूसरा तत्व लेना ( [1]) हमें पूर्णांक 0 देता है।

  • जब जावास्क्रिप्ट जोड़ता [11]है [0], तो यह हो जाता है "110"( सूचियों के स्ट्रिंग निरूपण को सुगम बनाना), और फिर स्ट्रिंग का दूसरा चरित्र ( [1]) लेने से हमें स्ट्रिंग मिलती है "1", जिसे जावास्क्रिप्ट सूची में एक सूचकांक के रूप में उपयोग करने के लिए काफी खुश है।

इसलिए, पायथन 3 rदोनों कार्यक्रमों का पहला तत्व चलाता है (प्रोग्राम ए चलने पर लगभग ए-क्वीन का उत्पादन करता है, और प्रोग्राम बी को चलाते समय प्रिंटिंग प्रोग्राम सी); जावास्क्रिप्ट दूसरा तत्व चलाता है, और इस प्रकार प्रोग्राम ए और प्रोग्राम बी को विपरीत तरीके से व्यवहार करता है।

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

(मैं एक अलग कारण के लिए इस तरह "सच पॉलीग्लॉट" पर काम कर रहा था, जिसे मैंने अब एक चुनौती के रूप में पोस्ट किया है, और महसूस किया कि तकनीकों को इस एक के रूप में अच्छी तरह से अनुकूलित किया जा सकता है।)

— mbomb007
स्रोत
170 प्रत्येक होना चाहिए, 171 नहीं ...
— no 170z
1
यह 171 है, आपको न्यूलाइन भी गिनना होगा। (आम तौर पर आप कोड-गोल्फ सवालों में कभी भी नईलाइन्स पर नहीं जाते हैं , लेकिन quines में, अक्सर अंत में एक newline होने से चीजें आसान हो जाती हैं।)
मैंने आपके लिए अनुगामी newlines जोड़ा। आपको <pre><code>...</code></pre>उन्हें दिखाने के लिए उपयोग करना होगा।
— mbomb007
आप किसी सूची में अनुक्रमण करने के लिए किसी भी चीज़ का शाब्दिक उपयोग कर सकते हैं ; जेएस वास्तव में जो भी पहले एक स्ट्रिंग में है, उसे रूपांतरित करता है। "a"[0], "a"["0"]और "a"[[[[[[[["0"]]]]]]]]सभी एक ही बात को पूरा करते हैं।
— ETHproductions
8

सी / पायथन, 733 बाइट्स + 733 बाइट्स = 1466 बाइट्स

कार्यक्रम ए:

#define int char*
int
a1="#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}";
int
a2="print(c%(13,34,34))";
int
b1="#define print(X) main(){printf(c,13,34,34);};";
int
b2="print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))";
int
c="#define print(a) main(){puts(a);}%cprint(%cWrong language!%c)";
int
d="#define int char*%cint%ca1=%c%s%c;%cint%ca2=%c%s%c;%cint%cb1=%c%s%c;%cint%cb2=%c%s%c;%cint%cc=%c%s%c;%cint%cd=%c%s%c;%c%s%c%s";
#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}
print(c%(13,34,34))

कार्यक्रम बी: 

#define int char*
int
a1="#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}";
int
a2="print(c%(13,34,34))";
int
b1="#define print(X) main(){printf(c,13,34,34);};";
int
b2="print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))";
int
c="#define print(a) main(){puts(a);}%cprint(%cWrong language!%c)";
int
d="#define int char*%cint%ca1=%c%s%c;%cint%ca2=%c%s%c;%cint%cb1=%c%s%c;%cint%cb2=%c%s%c;%cint%cc=%c%s%c;%cint%cd=%c%s%c;%c%s%c%s";
#define print(X) main(){printf(c,13,34,34);};
print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))

कार्यक्रम सी:

#define print(a) main(){puts(a);}
print("Wrong language!")

मैंने पायथन के साथ C / C ++ का उपयोग करने के आपके संकेत का उपयोग किया। बहुत संक्षिप्त नहीं है, लेकिन अभी भी योग्य मुझे लगता है।

3
आपने अपना खाता क्यों हटाया !? यहाँ क्यों नहीं रहे?
— no .zɐɹƆ 1
1
स्पष्टीकरण, कृपया?
— no --zɥʇʎԀʎ
2
@CrazyPython यदि वह अपने खाते को हटा देता है, तो वे कोड की व्याख्या कैसे करेंगे?
— NoOneIsHere 17
7

पायथन 2 / रेटिना, 550 + 645 = 1373 1254 1221 1195 बाइट्स

मुझे यकीन नहीं है कि अगर unichrऔर replaceभागों को और अधिक गोल्फ हो सकता है। मैंने पायथन 3 का उपयोग करने की कोशिश की, लेकिन कोष्ठक जोड़ने और उन्हें संभालने से बहुत कुछ खो जाता है। मैंने सेटिंग R=unicode.replaceऔर उपयोग करने की कोशिश की , लेकिन आउटपुट गड़बड़ हो गया।

ध्यान दें कि रेटिना में डिफ़ॉल्ट रूप से अपने आउटपुट में एक अनुगामी न्यूलाइन है, और यह कार्यक्रमों में शामिल नहीं है। अगर कोई कहता है कि मुझे इसे हटाने की आवश्यकता है, तो यह तुच्छ रूप से किया जा सकता है। इसके अलावा, अजगर कोड repl.it में काम करता है, लेकिन Ideone.com पर काम करने की गारंटी नहीं है।

यह भी ध्यान दें कि प्रमुख और अनुगामी अनुगामी नीचे दिए गए कोड में महत्वपूर्ण हैं।

कार्यक्रम ए (पायथन 2): 638 587 566 550 बाइट्स (UTF-8)

पायथन 2 , रेटिना

U=unichr;s=U(39)*3;_=u'''\n#U=unichr;s=U(39)*3;_=u%s.replace(U(9),U(96));print _%%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|¶#·print"Wrong language!"·#?.*t|"·¶#{2}|^.¶\n#1 #\n\n#T ²-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''.replace(U(9),U(96));print _%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|
#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

प्रोग्राम बी (रेटिना): 735 667 655 645 बाइट्स (आईएसओ 8859-1)

रेटिना , अजगर 2


#U=unichr;s=U(39)*3;_=u'''\n#U=unichr;s=U(39)*3;_=u%s.replace(U(9),U(96));print _%%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|·#¸print"Wrong language!"¸#?.*t|"¸·#{2}|^.·\n#1   #\n\n#T ³-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''.replace(U(9),U(96));print _%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|¶#·print"Wrong language!"·#?.*t|"·¶#{2}|^.¶
#1`#

#T`²-¹`_o`[^¹]
n=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n

कार्यक्रम सी:

पायथन 2 , रेटिना

यह वास्तव #!`W.*!में अंतिम दो लाइनों के बजाय का उपयोग करके कम किया जा सकता है , लेकिन यह ए और बी को लंबे समय तक बनाता है, क्योंकि `एक पंक्ति में होने का मतलब यह नहीं था कि मुझे इसे अलग तरीके से संभालने की आवश्यकता है (क्योंकि रेटिना में एक पंक्ति में पहला बैकटिक है। एक विन्यास सीमांकक है)।


print"Wrong language!"
#?.*t|"


स्पष्टीकरण:

कार्यक्रम सी:

                        # Retina: replace nothing with the Python code string
print"Wrong language!"  # >> code is executed if run in Python
#?.*t|"                 # Comment w/ '?' for Retina to skip, then replace up to the 't',
                        #    as well as any quotation marks, with nothing

मैंने अपने पहले प्रयास के दौरान सबसे पहले प्रोग्राम सी लिखा और इसे ज्यादातर वही रखा। पायथन में, यह स्ट्रिंग को प्रिंट करता है और टिप्पणी को अनदेखा करता है। रेटिना में, यह कुछ भी नहीं की जगह लेता है print"Wrong language!"और फिर आसपास के हिस्सों को हटा देता है Wrong language!।

जटिल कार्यक्रमों को बेहतर ढंग से समझने के लिए, आइए सरलीकृत संस्करणों को देखें:

कार्यक्रम ए (सरलीकृत):

print"\n#PYTHON\n#1`#\n\n#T`²-¹`_o`[^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n"#|
#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

जब मैंने स्क्रैच से शुरू किया था, तो मैंने PYTHONकोड के लिए प्लेसहोल्डर के रूप में बिट का उपयोग किया था जो प्रोग्राम ए को प्रिंट करना चाहिए। इस सरल संस्करण ने यह स्पष्ट करना आसान बना दिया कि प्रोग्राम बी और प्रोग्राम सी दोनों कैसे प्रिंट होंगे।

printऔर सब कुछ अंदर क्या प्रिंट कार्यक्रम बी है, लेकिन पहले, चलो देखते हैं कि कैसे प्रोग्राम सी छपा है, ऐसा इसलिए है क्योंकि आसान है। के बाद print"..."है #|। इस ट्रिक ने कठिनाई को दूर किया जिसे मैंने अपने पहले प्रयास में अनुभव किया। यह रेटिना को दूसरी पंक्ति के साथ कुछ भी बदलने की अनुमति नहीं देता है, जो प्रोग्राम सी होगा, सिवाय इसके कि #सामने की तरफ। अंतिम 2 लाइनें पहले हटा देती हैं #। मैं #{2}मंच के सभी घटनाओं को हटाने से रोकता था #। मैं #1`#प्रोग्राम B में उपयोग किए गए उपयोग की तरह नहीं कर सकता , क्योंकि इससे प्रोग्राम A की पहली पंक्ति में उस बैकलिक की समस्या होती है।

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

कार्यक्रम बी:


#PYTHON
#1`#

#T`²-¹`_o`[^¹]
n=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n

पहले दो पंक्तियाँ पायथन कोड के साथ कुछ भी नहीं बदलेगी, लेकिन #सामने और कुछ पात्रों के साथ थोड़ा अलग है। यह भाग स्पष्टता के लिए छोड़ा गया है। अगला चरण पहले हटा देता है #। फिर, मैं संपूर्ण प्रोग्राम ए में देखे गए #T`²-¹`_o`[^¹]कुछ replaceऑपरेशनों को पूर्ववत करने के लिए एक लिप्यंतरण (टी) चरण का उपयोग करता हूं । इस चरण का उपयोग रेटिना में शाब्दिक पायलट को आउटपुट करने का एक तरीका है , जो अन्यथा असंभव हो सकता है। इसके ·साथ , और इसके ³साथ बदलता है। ²। ¹उनके साथ नजरअंदाज किए जाने के कारण घटनाएँ समान रहेंगी [^¹]।

कार्यक्रम ए:

पठनीयता के लिए नई सूचियाँ और टैब जोड़े गए हैं।

U=unichr;s=U(39)*3;

_=u'''
    \n#U=unichr;s=U(39)*3;

    _=u%s.replace(U(9),U(96));

    print _%%(s+_+s)
    .replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179))
    .replace(U(183),U(184)).replace(U(182),U(183))#|

    ¶#·print"Wrong language!"·#?.*t|"·
    ¶#{2}|^.
    ¶

    \n#1    #\n\n#T ²-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''

.replace(U(9),U(96));

print _%(s+_+s)
.replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179))
.replace(U(183),U(184)).replace(U(182),U(183))#|

#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

यह निम्नलिखित पायथन क्वीन की सामान्य संरचना का अनुसरण करता है:

_='_=%r;print _%%_';print _%_

जब आप पहले या बाद में चीजों को जोड़ते हैं, तो आपको उन्हें स्ट्रिंग में भी डालना होगा।

U=unichr;_='U=unichr;_=%r;print(_%%_).replace('','')';print(_%_).replace('','')

मैं उद्धरण चिह्नों (बैकस्लैश के उपयोग से बचना) को शामिल करना आसान बनाने के लिए ट्रिपल-उद्धृत स्ट्रिंग का उपयोग करना चाहता था। s=U(39)*3;स्ट्रिंग है '''। मैं %sइसके बजाय भी इस्तेमाल करता था %r, ताकि नई कहानियों या अन्य पात्रों के साथ कुछ समस्याओं से बचने के लिए बैकस्लैश के साथ भाग निकला।

U=unichr;s=U(39)*3;_='''U=unichr;s=U(39)*3;_=%s;print(s+_%%_+s).replace('','')''';print(s+_%_+s).replace('','')

तो अब, प्रतिस्थापन। पहला प्रतिस्थापन .replace(U(9),U(96));टैब को बदलने के लिए है जिसे हम प्रोग्राम बी में देखते हैं। यह प्रतिस्थापन स्ट्रिंग फॉर्मेटिंग से पहले किया जाता है , क्योंकि टैब को प्रोग्राम ए में टैब बने रहने की आवश्यकता है। अन्य प्रतिस्थापन केवल 2 में कुछ वर्णों का उपयोग करने से बचने के लिए हैं कार्यक्रम बी की रेखा:

.replace(U(10),U(92)+'n')   # Replace newlines with a backslash and 'n', for B to print A.
.replace(U(96),U(9))        # Replace backticks with tabs for the first part of B.
.replace(U(178),U(179))     # Replace '²' with '³', which will be undone with B's T stage
.replace(U(183),U(184))     # Replace '·' with '¸', which will be undone with B's T stage
.replace(U(182),U(183))     # Replace '¶' with '·', which will be undone with B's T stage

ये अंतिम तीन प्रतिस्थापन प्रोग्राम बी में लिप्यंतरण चरण का अनुमान लगाते हैं, ताकि उन पात्रों को या तो हटा दिया जाए या जब उन्हें नहीं होना चाहिए, तो उन्हें दोहराया जाए।

कोड का एकमात्र अन्य भाग प्रोग्राम बी से कोड है जो प्रतिस्थापन के कारण होने वाले परिवर्तनों को छोड़कर अनिवार्य रूप से प्रतिलिपि-वर्ण-वर्ण है।


¹ पर अपने टिप के लिए मार्टिन के लिए धन्यवाद उत्पादन करने के लिए कैसे एक शाब्दिक रेटिना में। इसने सब कुछ इतना आसान कर दिया।

— mbomb007
स्रोत
4

Befunge / अजगर, 381 + 485 259 + 345 229 + 304 = 533 बाइट्स

कार्यक्रम A: Befunge में प्रयास करें | अजगर में कोशिश करो

#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''

कार्यक्रम बी: पायथन में प्रयास करें | Befunge में प्रयास करें

#>55+"]:5+5+["50g"!egaugnal gnorW"50g"'<:#>!#,_@<'tnirp">:#,_@
print """#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''"""

कार्यक्रम C: Befunge में प्रयास करें | अजगर में कोशिश करो

print'<@_,#!>#:<'"Wrong language!"[+5+5:]

व्याख्या

प्रोग्राम C: यह इस तथ्य पर निर्भर करता है कि Befunge-93 असमर्थित निर्देशों को अनदेखा करता है, इसलिए जबकि pहानिरहित 0 पर 0 में शून्य लिखते हैं, शेष को printउस <निर्देश तक अनदेखा किया जाता है जो दिशा को उलट देता है। फिर दाएं से बाएं ओर बहते हुए, +5+5स्टैक पर एक 10 (लाइनफीड) को धक्का दिया जाता है और उसके बाद संदेश स्ट्रिंग द्वारा एक मानक आउटपुट अनुक्रम निष्पादित किया जाता है। पाइथन में, यह केवल दो स्ट्रिंग शाब्दिक मुद्रण कर रहा है जो एक साथ समाप्‍त होते हैं, लेकिन पहले एक (बीफुंज कोड युक्त) अंत में सरणी संदर्भ द्वारा बंद कर दिया जाता है ( [+5+5:])।

प्रोग्राम बी: पहली लाइन प्रोग्राम सी को प्रिंट करने के लिए एक काफी बेसिक बेफ्यूज सीक्वेंस है। केवल दिलचस्प बात यह है कि यह उद्धरण वर्णों का उपयोग करके उत्पन्न करता है 50g(यानी मेमोरी से चरित्र को पढ़ना) जो एएससीआईआई कोड की गणना करने की तुलना में अधिक कुशल है। #>(दिशा निर्देश पर एक पुल) अनिवार्य रूप से एक nop कि कोड अजगर द्वारा देखा जा रहा है के बाद से रोकता है #अजगर टिप्पणी चरित्र है। पायथन की व्याख्या लाइन दो पर शुरू होती है और यह केवल प्रोग्राम ए के स्रोत कोड वाले एक बहुस्तरीय स्ट्रिंग को प्रिंट कर रही है।

प्रोग्राम ए: पायथन में पहले तीन लाइनों को फिर से नजरअंदाज कर दिया जाता है क्योंकि वे शुरू करते हैं #, जबकि अंतिम पंक्ति बस प्रोग्राम सी को प्रिंट करती है। बीफ्यूंज कोड पहले तीन लाइनों में आगे और पीछे सांपों को पकड़ता है, स्टैक पर प्रोग्राम बी के लिए स्रोत का निर्माण करता है। उल्टे क्रम में। यह तीन उद्धरणों के साथ शुरू होता है, फिर एक अनुक्रम जो प्रोग्राम ए के स्रोत की एक प्रति बनाता है, और अंत में अनिवार्य रूप से उद्घाटन print """और बेफ़ुंज कोड की पहली पंक्ति के साथ एक कठोर कोडित स्ट्रिंग है । यह तो एक मानक उत्पादन अनुक्रम के साथ इसे लिखने की बात है।

विवाद के कुछ बिंदु:

  1. मुझे बताया गया है कि gजहां तक ​​इस समुदाय का संबंध है , कमांड का उपयोग करने वाली एक क्वीन को उचित क्वीन नहीं माना जाता है। मुझे यकीन नहीं है कि अगर यह नियम इस चुनौती पर भी लागू होगा, लेकिन यदि हां, तो इस जवाब को एक उचित समाधान भी नहीं माना जा सकता है।

  2. जबकि मैंने कहा है कि Befunge-93 असमर्थित निर्देशों की अनदेखी करता है, जो कि तकनीकी रूप से विनिर्देश में परिभाषित नहीं है, और आपको -qप्रोग्राम सी में चेतावनी से बचने के लिए संदर्भ दुभाषिया में (शांत) कमांड लाइन विकल्प का उपयोग करने की आवश्यकता होगी । अधिकांश अन्य दुभाषियों ठीक है, हालांकि, लेकिन कुछ परतदार संभावित दुर्घटना हो सकती है। यह भी ध्यान दें कि Befunge-98 असमर्थित निर्देशों पर प्रतिबिंबित करता है, इसलिए एक 98 दुभाषिया अनिश्चित काल तक लूप करेगा।

— जेम्स होल्डरनेस
स्रोत
स्पष्टीकरण, कृपया?
— no --zɥʇʎԀʎ
क्या -qझंडा वास्तव में "काफी" है, या क्या आपका मतलब "शांत" है? मम-हां, यह झंडा काफी उपयोगी है।
— mbomb007
@ mbomb007 हाँ, यह एक टाइपो था। इस बात के लिए धन्यवाद।
— जेम्स होल्डरनेस
1
पर्याप्त रूप से पर्याप्त, -98 एक अज्ञात निर्देश को कम नहीं कर रहा है। यह rएफ़्लेक्ट इंस्ट्रक्शन और 0 pसेल
— जो
1

पर्ल / जावास्क्रिप्ट, 176 बाइट्स + 176 बाइट्स = 352 बाइट्स

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

कार्यक्रम ए:

$P=1;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

कार्यक्रम बी:

$P=2;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

कार्यक्रम सी:

$P=0;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

व्याख्या

एक आधार के रूप में मेरे पर्ल / जावास्क्रिप्ट पॉलीक्वीन का उपयोग करता है, लेकिन एक अतिरिक्त चर सेट $Pकरता है जो नियंत्रण करता है कि कौन सा प्रोग्राम उत्पन्न करना है। चेक का उपयोग करता है जो +[]पर्ल में सत्य है, लेकिन जावास्क्रिप्ट में गलत है।

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