29

प्रोग्राम ए आउटपुट, रन होने पर बी का कोड प्रोग्राम करता है और बी आउटपुट ए के सोर्स को।

आवश्यकताएँ:

दोनों कार्यक्रमों में केवल एक भाषा
कार्यक्रम अलग हैं। एक कार्यक्रम जो स्वयं आउटपुट करता है वह योग्य नहीं है।
दोनों कार्यक्रम गैर-रिक्त हैं, या कम से कम 1 बाइट लंबाई में हैं। स्रोत और आउटपुट दोनों में अनुगामी न्यूलाइन्स को अनदेखा किया जाता है
~~स्टड बंद है।~~ कुछ भी न पढ़ें (ताकि आप स्रोत को नहीं पढ़ सकें और उसमें हेरफेर कर सकें)। आउटपुट स्टडआउट जाता है।
संपादित करें: स्टड से जुड़ा है /dev/null। यदि आप स्पष्ट कर सकते हैं तो आप इसे बंद करने का आदेश दे सकते हैं।
randomकार्यों का उपयोग न करें ।

अतिरिक्त:

यदि संभव हो तो स्पष्टीकरण दें

स्कोर कुल लंबाई है । अनुगामी newline गिनती नहीं है अगर यह कार्यक्रम को प्रभावित नहीं करता है।

code-golf quine

— iBug
स्रोत

8

सम्बंधित।

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

5

"यादृच्छिक कार्यों का उपयोग न करें?" क्या मतलब? एक यादृच्छिक संख्या का उत्पादन करने वाले कार्य?

— श्री एक्सकोडर

2

संबंधित लोककथा

— रे

मुझे पूरा यकीन है कि आपके पास वास्तव में स्टड बंद नहीं है। यह कुछ वातावरण को उड़ा देता है क्योंकि स्टड पहले खोली गई फ़ाइल का डुप्लिकेट बन जाता है। वैसे भी, अगर आप इसे ठीक नहीं करते हैं तो मैं इसका दुरुपयोग करूंगा।

— जोशुआ

18

सीजाम , 13 + 13 = 26 बाइट्स

{sYZe\"_~"}_~

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

आउटपुट

{sZYe\"_~"}_~

व्याख्या

{       e# Standard quine framework, leaves a copy of the block on the stack
        e# for the block itself to process.
  s     e# Stringify the block.
  YZe\  e# Swap the characters at indices 2 and 3, which are Y and Z themselves.
  "_~"  e# Push the "_~" to complete the quine.
}_~

चूंकि e\इसके दूसरे और तीसरे ऑपरेंड में कम्यूटेटिव है, इसलिए अन्य प्रोग्राम बिल्कुल वैसा ही है, स्वैपिंग Zऔर Yअपने मूल क्रम में वापस।

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

17

CJam ,११ + १३ = २४ 11 + 12 = 23 बाइट्स

"N^_p"
N^_p

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

आउटपुट:

"N^_p
"
N^_p

आउटपुट में 13 बाइट्स हैं, लेकिन:

अनुगामी newline गिनती नहीं है अगर यह कार्यक्रम को प्रभावित नहीं करता है।

इसलिए मैंने इसका लाभ उठाने के लिए स्थान को एक नई रेखा में बदल दिया।

यह सबसे छोटी CJam उचित रानी पर आधारित है:

"_p"
_p

और N^एक न्यूलाइन के साथ स्ट्रिंग को एक्सर करने के लिए है, जो एक नईलाइन जोड़ता है यदि कोई न्यूलाइन नहीं है, और इसे हटा दें यदि कोई स्ट्रिंग है, तो प्रत्येक वर्ण अद्वितीय है।

मुझे लगता है कि मैंने उस क्वीन को क्वीन क्वेश्चन में देखा है, लेकिन मुझे वह नहीं मिला।

— jimmy23013
स्रोत

+1 अब तक के सभी अन्य उत्तरों के विपरीत, दो अलग-अलग आकार के कार्यक्रम होने के लिए। संपादित करें: जैसे ही मैं फिर से मतदान कर सकता हूं .. अंतिम सीमा तक पहुंच गया

— >>>

लंबाई में भिन्न होने के लिए अच्छा है।

— जुग

"मुझे लगता है कि मैंने उस क्वीन को क्वीन क्वेश्चन में देखा है, लेकिन मुझे वह नहीं मिला।" यह केवल गोल्फस्क्रिप्ट उत्तर में उल्लिखित है।

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

12

RProgN 2 , 3 + 3 = 6 बाइट्स

पहला कार्यक्रम:

0
1

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

दूसरा कार्यक्रम:

1
0

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

-2 मार्टिन एंडर को धन्यवाद ।

— आउटग्रॉफर को एरिक करें
स्रोत

7

आप भाषाओं को स्विच करके दो बाइट्स बचा सकते हैं: tio.run/##Kyooyk/P0zX6/9@Ay/D/fwA

— मार्टिन

@MartinEnder Ooh सही है मैं भूल गया RProgN 2 इस तरह के व्यवहार को प्रदर्शित करता है ... btw मुझे पता नहीं अगर यह अभी भी उस छोटी गाड़ी है।

— आउटगोल्फ जूल

11

मैं RProgN के बारे में कुछ नहीं जानता सिवाय इसके कि यह व्यवहार मौजूद है।

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

@ आरपीएनआरएन के एमआर्इंडइंडर लेखक, बस पूछें कि क्या आपको कुछ भी स्पष्ट करने की आवश्यकता है!

— ATaco

@ATaco खैर, मैंने आपको डाउनवोट स्पष्ट करने के लिए कहा है, लेकिन मुझे नहीं लगता कि आप कर सकते हैं ...

— एरिक द आउटगलर

6

सी, 95 + 95 = 190 बाइट्स

16 * 2 बाइट बचाने के लिए @immibis को धन्यवाद!

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}

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

आउटपुट:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=0^1;printf(s,34,s,34,i);}

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

कौन से आउटपुट:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}

— Steadybox
स्रोत

1

क्यों नहीं इसे हमेशा सी कहा जाता है, और इस कार्यक्रम को अलग बनाने के लिए मैं इस पर भरोसा करता हूं? C,% C से कम है

— user253751

@ मिनीबिस हां, आप सही हैं, यह पूरी तरह से पर्याप्त है।

— स्टीडिओबॉक्स

5

जावास्क्रिप्ट, 67 + 67 = 134 बाइट्स

पहला कार्यक्रम:

alert(eval(c="`alert(eval(c=${JSON.stringify(c)},n=${+!n}))`",n=0))

दूसरा कार्यक्रम:

alert(eval(c="`alert(eval(c=${JSON.stringify(c)},n=${+!n}))`",n=1))

यह हरमन लॉएन्स्टाइन के त्रि-अंतरक्वाइन के उत्तर पर आधारित है

जावास्क्रिप्ट (अमान्य-स्रोत स्रोत पढ़ता है), 75 + 75 = 150 61 + 61 = 122 58 + 58 = 116 50 + 50 = 100 बाइट्स

तुषार की बदौलत 20 बाइट्स बचाए, क्रेग आयरे को 6 बाइट्स दिए, और 16 बाइट्स की बदौलत kamoroso94

पहला कार्यक्रम:

f=_=>alert(("f="+f).replace(0,a=>+!+a)+";f()");f()

दूसरा कार्यक्रम:

f=_=>alert(("f="+f).replace(1,a=>+!+a)+";f()");f()

1s को 0s के साथ स्वैप करें और इसके विपरीत। वे दोनों एक ही काम करते हैं, सिर्फ उनके स्रोत कोड के कारण अलग-अलग आउटपुट का उत्पादन करते हैं।

— SuperStormer
स्रोत

1

चलो कुछ बाइट्स बचाते हैं। f.toString()=> (''+f), (0|1)=> 0|1, (a,b)=> aजिसके परिणामस्वरूपf=()=>("f="+(''+f).replace(/0|1/g,a=>a==0?1:0)+";f()");f()

— तुषार

आप एक अप्रयुक्त पैरामीटर का उपयोग कर सकते हैं बाइट्स की एक जोड़ी को बचाने के लिए f=_=>और पार्सल को कॉलबैक से हटाने के लिए @Tushar का सुझाव दिया:a=>+!+a

— क्रेग आयरे

-3 बाइट्स के "f="+(f+"")साथ बदलें ("f="+f)।

— kamoroso94

बदलें /0|1/gऔर /1|0/gसाथ 0और 1क्रमशः -5 बाइट्स के लिए।

— kamoroso94

क्या आपने इसे चलाया? यह इस तरह काम करता है f=_=>alert(("f="+f).replace(0,a=>+!+a)+";f()");f()।

— kamoroso94

4

पायथन 2, 63 + 63 = 126 बाइट्स

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

पहला कार्यक्रम:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]

आउटपुट:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

दूसरा कार्यक्रम:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

आउटपुट:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]

— मृत पोसुम
स्रोत

4

जावास्क्रिप्ट ( JsShell ), 35 + 34 = 69 बाइट्स

1:

(f=x=>print(`(f=${f})(${-x})`))(-1)

2:

(f=x=>print(`(f=${f})(${-x})`))(1)

— TSH
स्रोत

3

गणितज्ञ, 43 + 44 = 87 बाइट्स

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -1 1]

तथा

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -(-1)]

— alephalpha
स्रोत

मेरे कंप्यूटर पर इसका परीक्षण किया और दूसरे के आउटपुट में केवल -1अंत में है, नहीं -1 1।

— नंबरमान जूल 13'17

@numbermaniac मैंने इन कोड को टेक्स्ट-आधारित इंटरफ़ेस में लिखा था। ऐसा लगता है कि वे नोटबुक में काम नहीं करते हैं।

— एलेफाल्फा

3

asmutils sh, 16 + 16 बाइट्स, "स्टड बंद है" नियम का दुरुपयोग करते हुए।

#!/bin/sh
tr x y

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

यह इंटरक्वाइन पेलोड सक्षम है लेकिन पेलोड सम्मिलित करना मुश्किल है।

इसके अलावा, यह मूल संस्करण उन दिनों में उपयोग किए गए प्राचीन कर्नेल में कुछ पागल बग का दुरुपयोग करता है। (मुझे नहीं पता कि उस कर्नेल के साथ क्या हो रहा है - मुझे बाद में पता चला कि इसमें उपकरणों के लिए अलग-अलग प्रमुख और मामूली संख्याएँ भी थीं।) यदि आप एबीआई परिवर्तनों को ठीक करते हैं जो एस्किम को तोड़ते हैं तब भी काम नहीं करेगा। मैं भूल जाता हूं कि asmutils sh के पास निष्पादन है या नहीं, लेकिन अगर ऐसा होता है, तो यह एक आधुनिक संस्करण है:

exec dd skip=0 | tr x y

यह asmutils dd में एक जानबूझकर बग का दुरुपयोग करता है; यह एक प्रदर्शन अनुकूलन है, अगर यह स्किप के लिए llseek को कॉल करता है, अगर यह कर सकता है, लेकिन एक बाइट को बचाने के लिए इसे SEEK_SET के बजाय SEEK_SET से गुजरता है। इसके परिणामस्वरूप स्ट्रैडर पर कचरा होता है लेकिन स्टडआउट पर इंटरक्वाइन। Asmutils dd के पास stderr स्पैम को दबाने का विकल्प नहीं है।

— दर्शाता है
स्रोत

/dev/nullइसके बजाय जुड़े में काम करेंगे तो क्या यह काम करेगा ? वैसे भी, अच्छी नौकरी!

— 23

@ आईबग: नहींं। स्टड बंद होने पर पूरी तरह से निर्भर करता है और तथ्य यह है कि asmutils sh libc के खिलाफ लिंक नहीं है और इसलिए lib में ऑटो-रिपेयर कोड इनहेरिट नहीं करता है।

— जोशुआ

क्या आपको जरूरत है #!/bin/sh?

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

@ कैलाकेटरफेलिन: जो किसी और चीज़ की आपकी परिभाषा की सटीकता पर निर्भर करता है।

— जोशुआ

आम तौर पर, शेबंग की गिनती नहीं की जाती है, इसलिए यह 6 बाइट्स होगा।

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

2

अंडरलोड , 32 + 32 = 64 बाइट्स

(a~a*(:^)*S)(~(a)~a*^a(:^)**S):^

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

(~(a)~a*^a(:^)**S)(a~a*(:^)*S):^

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

— मैडिसन सिल्वर
स्रोत

1

कॉमन लिस्प, 58 अक्षर

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

... या 24 वर्ण यदि आपको बुरा न लगे तो *print-circle*विश्व स्तर पर इसके लिए तैयार है T:

#1=(print '(write '#1#))

कोड का मुद्रित प्रतिनिधित्व एक चक्रीय संरचना के रूप में पढ़ा जाता है, जहां #1#बाद में सामान्य सेल को इंगित किया जाता है #1=। हम कार्यक्रमों को उद्धृत करते हैं ताकि वे निष्पादित न हों। चूंकि *print-circle*टी है, आरईपीएल मुद्रण के दौरान ऐसे पाठक चर का उत्सर्जन करने का ध्यान रखता है; उपरोक्त कोड प्रिंट और रिटर्न:

#1=(write '(print '#1#))

जब हम उपरोक्त कोड का मूल्यांकन करते हैं, तो यह प्रिंट करता है:

#1=(print '(write '#1#))

यदि आप उस डिफ़ॉल्ट मान के साथ रहना चाहते हैं *print-circle*, जो एक अनुरूप कार्यान्वयन में NIL है, तो आपको अस्थायी रूप से चर को फिर से बनाना होगा:

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

एलईटी के शरीर के अंदर, हम चीजों को *print-circle*टी के साथ प्रिंट करते हैं । इसलिए हम प्राप्त करते हैं:

#1=(write
    '(let ((*print-circle* t))
       (print '#1#))
    :circle t)

जैसा कि आप देख सकते हैं, नया प्रोग्राम रिबंड नहीं करता है *print-circle*, लेकिन जब से हम उपयोग कर रहे हैं write, जो निम्न-स्तरीय फ़ंक्शन कहलाता है print, हम अतिरिक्त तर्क जैसे कि पास कर सकते हैं :circle। कोड फिर अपेक्षा के अनुसार काम करता है:

#1=(let ((*print-circle* t))
     (print '(write '#1# :circle t)))

हालाँकि, आपको उपरोक्त कार्यक्रमों को स्क्रिप्ट के रूप में निष्पादित करने की आवश्यकता है, न कि एक REPL के अंदर, क्योंकि भले ही आप परिपत्र संरचनाओं की देखभाल करते समय चीजों को प्रिंट करते हैं, दोनों writeऔर printमुद्रित होने वाले मूल्य को भी लौटाते हैं; और एक डिफ़ॉल्ट REPL में, मान भी मुद्रित किया जा रहा है, लेकिन गतिशील संदर्भ के बाहर जहां *print-circle*T है।

— कोर निपात
स्रोत

1

> <> , 16 + 16 = 32 बाइट्स

":1-}80.r   !#o#

तथा

#o#!   r.08}-1:"

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

यह प्रोग्राम में एक जंप का उपयोग करके काम करता है, पहला प्रोग्राम जंप स्टैक के रिवर्स को छोड़ देगा (यदि यह स्टैक को उलटता है तो यह एक क्वीन होगा)। दूसरा प्रोग्राम रिवर्स नहीं छोड़ता है, लेकिन यह पहले से ही कार्यक्रम के प्रवाह से उलट है, तो यह मूल पैदा करेगा।

यह कोड एक त्रुटि में समाप्त हो जाएगा।

— पेल पेलिकन
स्रोत

1

RProgN 2 , 7 + 7 = 14 बाइट्स

मैं प्रिंट आर्डर का दुरुपयोग करने के बजाय RProgN के बेहतर उपयोग को दिखाने की कोशिश करना चाहता था ...

1
«\1\-

तथा...

0
«\1\-

व्याख्या की

1   # Push the constant, 1. (Or 0, depending on the program)

«\1\-
«       # Define a function from this to the matching », in this case there isn't any, so define it from this to the end of the program, then continue processing.
 \      # Flip the defined function under the constant.
  1\-   # Get 1 - Constant.

क्योंकि यह स्टैक को उल्टा प्रिंट करता है, पहले नया प्रिंट किया जाता है, फिर फ़ंक्शन का स्ट्रिंग संस्करण मुद्रित किया जाता है।

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

— Ataco
स्रोत

1

लोगो , 65 + 66 = 131 बाइट्स

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] 1]

तथा

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] -1]

— user202729
स्रोत

1

पायथन 3, 74 + 74 = 148 बाइट्स

a='a=%r;b=%r;print(b%%(b,a))';b='b=%r;a=%r;print(a%%(a,b))';print(b%(b,a))

तथा

b='b=%r;a=%r;print(a%%(a,b))';a='a=%r;b=%r;print(b%%(b,a))';print(a%(a,b))

~~मुझे यह समझ में नहीं आता है~~

— आ आ आ आ आ आ
स्रोत

1

> <> , 12 + 12 = 24 बाइट्स

'3d*!|o|!-c:

तथा

':c-!|o|!*d3

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

दोनों प्रोग्राम कोड को स्टैक में जोड़ने के लिए एक रैपिंग स्ट्रिंग शाब्दिक का उपयोग करते हैं, फिर 'विभिन्न तरीकों के माध्यम से कमांड का उत्पादन करते हैं । स्टैक को प्रिंट करते समय यह कोड को पीछे की ओर धकेलता है, हालांकि 'सामने की तरफ रहता है। कई बदलाव हैं जो उत्पादन करते हैं '; 3d*, d3*, 00g, :c-जब साथ रखा 3d*और :9-जब साथ रखा 00g।

13 * 2 बाइट्स के लिए Befunge-98 में पोस्ट करने के लिए एक समान समाधान

"2+ck, @,kc+2

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

1

स्टैक्स , 18 + 20 = 38 बाइट्स

"Vn|^34bL"Vn|^34bL

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

"Vn|^34bL
"Vn|^34bL

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

व्याख्या

पूर्णता के लिए जोड़ा गया। पोर्ट ऑफ @ jimmy23013 का सीजेएम उत्तर। सेट xor का उपयोग कर नई सुर्खियों को टॉगल करता है।

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

0

जावास्क्रिप्ट (ईएस 6), 36 + 36 = 72 बाइट्स

कार्यक्रम 1:

f=n=>('f='+f).replace(/4|5/g,n=>n^1)

कार्यक्रम 2:

f=n=>('f='+f).replace(/5|4/g,n=>n^1)

ये प्रोग्राम खुद को क्लोन करके काम करते हैं और इसके 5साथ 4और 4साथ बदलते हैं5

console.log((
    f=n=>('f='+f).replace(/4|5/g,n=>n^1)
)())
console.log((
    f=n=>('f='+f).replace(/5|4/g,n=>n^1)
)())

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

— हरमन एल
स्रोत

2

चूँकि यह क्वीन का टैग है , यह वही है जिसे आमतौर पर "चीटिंग क्वीन" माना जाता है, क्योंकि यह अपना स्रोत पढ़ता है। निश्चित नहीं है कि ओपी का निर्णय क्या है, लेकिन उन्हें आमतौर पर अनुमति नहीं है।

— स्टीफन

0

क्लेन , 26 24 बाइट्स

<:3+@+3<:"

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

व्याख्या

यह मेरी क्लेन क्वीन के समान ही काम करता है , जहां यह स्रोत को पीछे की ओर प्रिंट करता है ", उसके बाद अंतिम एक पलिंड्रोमिक होने के साथ इस से दूर हो जाता है, इसलिए हम सभी को इसकी कार्यक्षमता को नुकसान पहुंचाए बिना इसे गैर-पैलिंड्रोमिक बनाने की आवश्यकता है। स्विच करके <और :हम कार्यक्षमता के साथ हस्तक्षेप किए बिना ऐसा करने में सक्षम थे।

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

0

परी / जीपी , 36 + 36 = 72 बाइट्स

(f=(x)->print1("(f="f")("1-x")"))(1)

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

(f=(x)->print1("(f="f")("1-x")"))(0)

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

— alephalpha
स्रोत

इंटरक्वाइन - दो प्रोग्राम जो एक दूसरे को लूप में आउटपुट करते हैं

सीजाम , 13 + 13 = 26 बाइट्स

व्याख्या

CJam ,११ + १३ = २४ 11 + 12 = 23 बाइट्स

RProgN 2 , 3 + 3 = 6 बाइट्स

सी, 95 + 95 = 190 बाइट्स

जावास्क्रिप्ट, 67 + 67 = 134 बाइट्स

जावास्क्रिप्ट (अमान्य-स्रोत स्रोत पढ़ता है), 75 + 75 = 150 61 + 61 = 122 58 + 58 = 116 50 + 50 = 100 बाइट्स

पायथन 2, 63 + 63 = 126 बाइट्स

जावास्क्रिप्ट ( JsShell ), 35 + 34 = 69 बाइट्स

गणितज्ञ, 43 + 44 = 87 बाइट्स

asmutils sh, 16 + 16 बाइट्स, "स्टड बंद है" नियम का दुरुपयोग करते हुए।

अंडरलोड , 32 + 32 = 64 बाइट्स

कॉमन लिस्प, 58 अक्षर

> <> , 16 + 16 = 32 बाइट्स

RProgN 2 , 7 + 7 = 14 बाइट्स

व्याख्या की

लोगो , 65 + 66 = 131 बाइट्स

पायथन 3, 74 + 74 = 148 बाइट्स

> <> , 12 + 12 = 24 बाइट्स

स्टैक्स , 18 + 20 = 38 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 36 + 36 = 72 बाइट्स

क्लेन , 26 24 बाइट्स

व्याख्या

परी / जीपी , 36 + 36 = 72 बाइट्स