आदेशों की संख्या

Question

एक प्रोग्राम लिखें, जो अलग-अलग भाषाओं में चलने पर, प्रत्येक भाषा में कोड के एक अलग बाइट क्रमांकन को आउटपुट करता है। सटीक स्रोत कोड को एक क्रमचय के रूप में गिना जाता है।

यहां "अलग भाषा" अलग संस्करण (Py 2 और Py 3) या विभिन्न मानक झंडे हो सकते हैं। यह अलग आउटपुट है जो विभिन्न संस्करण को मजबूर करता है।

प्रत्येक भाषा में कार्यक्रम के लिए उचित रानी नियम लागू होते हैं। आपके स्कोर की गणना (Language count)^6/(Code length in bytes)एक उच्च स्कोर बेहतर होने के साथ की जाती है।

नमूना:

यदि आपका कोड AABतीन अलग-अलग भाषाओं में है और चल रहा है ABA, AABऔर AAB, तो उसका स्कोर 2^6/3(केवल दो में से एक AABगिनती) है। ABAनिरर्थक है तो ठीक है।

Comments

एक अलग भाषा के रूप में क्या मायने रखता है?

— लकोनी

एक उचित क्वीन की कौन सी परिभाषा लागू होती है? ( मार्टिन के , या ais523 के , या शायद इन मेटा थ्रेड्स में कुछ अन्य परिभाषा?) क्या उचित quine नियम केवल उस प्रोग्राम की व्याख्याओं पर लागू होते हैं जो वास्तव में quines हैं? (इसके लायक क्या है, मुझे नहीं लगता कि उचित कोटा नियमों को लागू करने से इस चुनौती में बहुत सुधार हुआ है।)

— लिन

स्पष्ट करने के लिए, अपने उदाहरण पर काम करना - अगर मेरा कोड भाषा -1 और भाषा -2 में AABप्रिंट करता AABहै ABA, तो मैं मानता हूं कि भाषा -1 कार्यक्रम के रूप में देखे जाने पर इसे उचित रूप से क्वीन होना चाहिए, और इसकी व्याख्या से संबंधित कोई और प्रतिबंध नहीं हैं एक भाषा -2 कार्यक्रम क्या वह सही है?

— लिन

क्या कोड की लंबाई वर्ण या बाइट्स में गिनी जाती है? हमें विभिन्न चरित्र एन्कोडिंग के साथ क्या करना चाहिए?

— डायलन

बाइट्स बनाम पात्रों के बारे में क्या?

— dylnan

Answer 1

Befunge-98 , > <> , गोल> <> , विखंडन , Wumpus , कार्डिनल , मोम और ऐलिस स्कोर: 8 ⁶ /88 = 2978.909

"65*4+059*$!#.39*0jp2+'Wk,@ ''5&.'\d&o@o&88#+\@ol?!,'.'0.6'!+Ox,++tttt=++%-$#}.6~.F4*`*R

Befunge में इसे आज़माएं! इसे> <> में आज़माएँ! इसे गोल> <> में आज़माएं! विखंडन में यह कोशिश करो! Wumpus में यह कोशिश करो! कार्डिनल में यह कोशिश करो! Beeswax में यह कोशिश करो! ऐलिस में यह कोशिश करो!

सत्यापन!

2 डी भाषाओं के बहुत सारे, सभी रैपिंग स्ट्रिंग स्ट्रिंगल। आउटपुट में अंतर इस प्रकार है:

> <>, गोल> <> और Befunge-98 सभी कोड "को अलग-अलग स्थिति में अंतिम तीन वर्णों के साथ R*", O"*( "R*क्रमशः को छोड़कर ) पीछे प्रिंट करते हैं , और क्रमशः। Beeswax में भी पीछे की तरफ कोड होता है, लेकिन पिछले तीन अक्षर आउटपुट के पहले सेक्शन में इंटरसेप्टर होते हैं। ऐलिस, ज्यादातर पीछे की ओर है सब बच गए पात्रों के अलावा ( ', \और ") के बजाय सामने ले जाया गया।

वम्पस एकमात्र वास्तविक क्वीन है, विखंडन "शुरुआत के बजाय कोड के अंत में डालता है, और कार्डिनल शुरुआत के और उसके "बीच 0और 5पास डालता है ।

विभिन्न क्रमपरिवर्तन का प्रमाण

स्पष्टीकरण:

Befunge-98:

"  Wrapping string literal pushes all other characters + a space to the stack
 65*4+  Push " to the stack
      059*$!#.39*0j   Push 1,27 to the stack
                   p  Pops the top three values of the stack (27,1,34)
                    2+  Adds 2 to the space to make "
                      'Wk,@  Prints the top 88 characters of the stack and terminates

> <> और गोल> <>:

सच कहूं, तो मैंने यहां बहुत कुछ नहीं किया। इन दोनों भाषाओं के निष्पादन के बीच एकमात्र अंतर @कमांड है, जो प्रत्येक भाषा के लिए अलग-अलग तरीकों से स्टैक के शीर्ष तीन मूल्यों को घुमाता है।

"  Wrapping string literal pushes all other characters to the stack
 65*4+  Push 34 (") to the stack
      059*$!#.  Jump to cell 45,0
                                   \@  Rotate the top three values of the stack 
                                     ol?!,'.'0.  Output the whole stack, ending in a divide by 0/stack underflow error

विखंडन:

 "............R  Spawn a pointer going right

 "  Switch to printing mode and print every other character
 "  Switch off printing mode
  6  Teleport to other 6
 "........6'!+O   Print the "

Wumpus:

"  Bouncing string literal
 65*4+  Push a (")
      059*$!#.   Push 0 and jump to cell 0,45
                                        \  Reflect off mirror
                                       +   Add 0 to top of stack
                                 @o&88#    Print the top 88 characters of the stack

कार्डिनल:

                                 %   Spawn two pointer going left/right (up/down despawn immediately)
                                  -$  Right pointer jumps to cell -1,0
                      x,++tttt=++     Left pointer prints "
"  While right pointer switches to print mode and prints the code

मोम:

 "................*`*   Spawn pointers going in every direction
                        Every other * also spawns pointers, but they do nothing
                   `    Turn on print mode for two of the pointers going in different directions
                        This prints everything but the `
          #}.6~.F4*     Print a `

ऐलिस:

"  Wrapping string literal pushes all other characters to the stack
   Except 's and mirrors
 65*4+  Push " to the stack
      059*$!#.  Does nothing
              39*0j  Jumps to cell 39,0
                         ''5&.    Push ' and duplicate it 5 times
                              '\  Push \
                                d&o@  Print the whole stack

Answer 2

पर्ल 5 , रूबी , जावास्क्रिप्ट (क्रोम), पीएचपी , अजगर 2 , अजगर 3 , 1206 बाइट्स, स्कोर 6 ⁶ /1206 = 38.6865671641791

q=1//2;s=+0;s|0;"/.__id__;#";_="""q=1//2;s=+0;s|0;"/.__id__;#";_={0}{1}{0};R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q={0}{2}{0};print(_.format(Q,_,q[0:-12]+R,"%"))""";R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q="""|;#<?ob_end_clean();
eval($_='"$t"?0?[$q=37 .chr+113 .chr+38 .chr,$p=(96 .chr+39 .chr)*4,$n=10 .chr,$s=39 .chr*12,$S=34 .chr*3]:eval("printf=console.log;c=String.fromCharCode;$q=c(96);$p=c(37,113,38,39).repeat(4);$n=c(10);$s=c(39).repeat(12);$S=c(34,34,34)"):[]?[$q=q(!g)^PA,$p=HARHARHARHAR^od2od2od2od2,$n=R^X,$s=bbbbbbbbbbbb^EEEEEEEEEEEE,$S=hhh^JJJ]:[$q=O^h,$p=str_repeat(RHa3^w9GS,4),$n=R^X,$s=str_repeat(b^E,12),$S=HHH^jjj];//#');printf($x='q=1//2;s=+0;s|0;"/.__id__;#";_=%7$sq=1//2;s=+0;s|0;"/.__id__;#";_={0}{1}{0};R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q={0}{2}{0};print(_.format(Q,_,q[0:-12]+R,"%8$s"))%7$s;R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q=%7$s|;#<?ob_end_clean();%5$seval($_=%3$s%1$s%3$s);printf($x=%3$s%2$s%3$s,$_,$x,$q,$p,$n,$s,$S,"%8$s",![]||([]+[])?$n:"");//#%4$s%6$s%7$s;print(_.format(Q,_,q[0:-12]+R,"%8$s"))%9$s',$_,$x,$q,$p,$n,$s,$S,"%",![]||([]+[])?$n:"");//#`q&%`q&%`q&%`q&%''''''''''''""";print(_.format(Q,_,q[0:-12]+R,"%"))

वैध पर्ल, रूबी, पीएचपी, पायथन 2 और पायथन 3 ऑनलाइन!

ध्यान दें : Chrome में इंस्पेक्टर कंसोल में उपरोक्त प्रोग्राम चलाना (जो स्थिति संबंधी तर्कों का समर्थन करता है console.log) सही प्रोग्राम देता है।

व्याख्या

यह उम्मीद की तुलना में बहुत लंबा है और मैंने अपने जीवन को थोड़ा कठिन बना दिया है, इसलिए मुझे इसके साथ छेड़छाड़ करने की संभावना है। मैं और अधिक भाषाओं में भी जोड़ना चाहूंगा, लेकिन मुझे कुछ ऐसा खोजने की ज़रूरत है, जो एक $सतर्क न हो ...

यह काफी एक मानक Quine प्रारूप जहां उपयोग करने के लिए बोली की गणना प्रत्येक भाषा के लिए एक छोटे से अलग है: रूबी में %q&प्रयोग किया जाता है, पीएचपी का उपयोग करता है ', जावास्क्रिप्ट (Node.js) का उपयोग करता है `और पर्ल 5 का इस्तेमाल q(... )। क्योंकि केवल उद्धरण बदलते हैं, बाकी कार्यक्रम अभी भी प्रत्येक भाषा में निष्पादन योग्य और मान्य वाक्यविन्यास है। अजगर 2 और 3 का उपयोग कर पिछले कार्यक्रम के चारों ओर लिपटा कर रहे हैं """अजगर 2 के लिए और '''अजगर 3 के लिए।

परिणामी पर्ल और रूबी कार्यक्रम मानक quines नहीं हैं, अतिरिक्त q/ %qs को प्रत्येक पुनरावृत्ति में जोड़ा जाता है, लेकिन पहला प्रोग्राम सही तरीके से लौटता है।

परिणाम हैं:

• पर्ल 5:
  eval($_=q&... q&);printf($x=q&... q&,... );//#'%`'%`'%`'%`''''''''''''"""... ...
• रूबी:
  eval($_=%q&... %q&);printf($x=%q&... %q&,... );//#`'`'`'`'''''''''''''"""... ...
• जावास्क्रिप्ट (क्रोम):
  eval($_=`... `);printf($x=`... `,... );//#%q&'%q&'%q&'%q&'''''''''''''"""...
• PHP:
  eval($_='... ');printf($x='... ',... );//#`q&%`q&%`q&%`q&%''''''''''''"""...
• अजगर 2:
  ... _="""... """;... q="""...''''''''''''""";print(_.format(Q,_,q[0:-12]+R,"%"))
• अजगर 3:
  ... _='''... ''';... q='''...""""""""""""''';print(_.format(Q,_,q[0:-12]+R,"%"))

मैंने इसे फिर से काम किया है, मुझे आशा है कि मैंने यहाँ कुछ भी नहीं छोड़ा है। मेरे पास अभी भी जो किंग के स्कोर के पास कहीं भी जाने का एक तरीका है ...

Answer 3

जेली , और एम , 2 ⁶ /14 = 4.57

1Ɗṙ@“1Ɗṙ@ȮṾ”ȮṾ

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

इसे M में आज़माएं!

Ɗṙ@ȮṾ1“Ɗṙ@ȮṾ1” जेली में

1Ɗṙ@ȮṾ“1Ɗṙ@ȮṾ” एम में

Comments

मुझे यकीन नहीं है कि चारकोल एक उचित रानी के रूप में गिना जाता है

— एचपीविज़

@ H.PWiz मैं यह कहते हुए एक टिप्पणी जोड़ने वाला था। मैं

— १nan:

@ l4m2 क्या आप चारकोल कार्यक्रम को एक उचित रानी मानते हैं? मैं नहीं तो हटा दूंगा।

— डायलन

मुझे लगता है कि यह QuinePHP में पसंद है?

— l4m2

@ l4m2 यकीन नहीं, मैं PHP नहीं जानता। यह मुझे लगता है कि सबसे ASCII पाठ के लिए काम करता है

— dylnan

Answer 4

अजगर 2 और अजगर 3 , 2 ⁶ /61 = 1.05

s='s=%r;print(s%%s[::(1/2>0)*2-1])';print(s%s[::(1/2>0)*2-1])

इसे पायथन 2 में आज़माएं!

इसे पायथन 3 में आज़माएं!

जो राजा को धन्यवाद दिया 12 बाइट्स बचाए।

अजगर 2 प्रिंट

s=')]1-2*)0>2/1(::[s%%s(tnirp;r%=s';print(s%s[::(1/2>0)*2-1])

पायथन 3 प्रिंट

s='s=%r;print(s%%s[::(1/2>0)*2-1])';print(s%s[::(1/2>0)*2-1])

यह इस तथ्य का उपयोग करता 1/2है .5जो पायथन 3 में और 0पायथन 2 में है।

Answer 5

बैश / GolfScript, 72 बाइट्स, स्कोर 2 ⁶ /72 = 8/9 (~ 0.888 ...)

.~0 () 
{ 
    declare "-f" @* ".~0" " ()
 "+@n.;
    echo '.~0;'
}
.~0;

पहले दो पंक्तियों पर एक एकल अनुगामी स्थान समाहित करता है।

इसे बैश में ऑनलाइन आज़माएं।
इसे गोल्फस्क्रिप्ट में ऑनलाइन आज़माएं।

" लिखो एक पॉलीक्वाइन " चुनौती के लिए @ jimmy23013 के जवाब का बस संशोधन । जो संशोधन किया गया था, वह तीसरी पंक्ति के बाद अनुगामी स्थान को हटा रहा था और बदल रहा \n"+@n.;था \n "+@n;।

बैश 1 और 2 जैसी लाइनें छापेंगे:

.~0 ()    <- Trailing space
{         <- Trailing space

और गोल्फस्क्रिप्ट इस तरह लाइनों 1 और 2 को प्रिंट करेगा:

.~0 ()   <- No trailing space
 {       <- Both leading and trailing space

यहां आधार कार्यक्रम, बैश आउटपुट और गोल्फस्क्रिप्ट आउटपुट क्रमशः नई लाइनों के साथ बदल दिए गए हैं \n:

.~0 () \n{ \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;
.~0 () \n{ \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;
.~0 ()\n { \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;

      ^^^ Note the difference here