बैकैंडेड तारीफ

Question

यह चुनौती मेरी पहली गूढ़ भाषा, बैकहैंड के उत्सव में बनाई गई है !

बैकहैंड एक गैर-रेखीय सूचक प्रवाह के साथ एक आयामी भाषा है। सूचक एक समय में तीन कदम चलता है, केवल हर तीसरे निर्देश को निष्पादित करता है।

कार्यक्रम 1..1..+..O..@समाप्त होने से पहले 1 + 1 और आउटपुट 2 जोड़ देगा। मध्यवर्ती निर्देश छोड़ दिया जाता है, तो 1<>1()+{}O[]@ठीक यही कार्यक्रम है।

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

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

लेकिन रुको , यह सब नहीं है! जब आपके कार्यक्रम की व्याख्या इस तरह से की जाती है, तो परिणामी कोड को नीचे दिए गए में से एक का उत्पादन करना चाहिए:

• (Mostly) works
• Turing complete
• 'Recreational' (उद्धरण 'या तो हो सकते हैं ", लेकिन दोनों नहीं)
• Perfectly okay
• Only a few bugs

उदाहरण के लिए, यदि आपका स्रोत कोड है code 2 backhand, तो प्रोग्राम ce cankb od2ahdको इन वाक्यांशों में से एक का उत्पादन करना चाहिए।

परीक्षण के मामलों:

"1  1  +  O  @"  -> "11+O@"
"1O+1@"          -> "11+O@"
"HoreWll dlo!"   -> "Hello World!"
"abcdefghijklmnopqrstuvwxyz" -> "adgjmpsvyxurolifcbehknqtwz"
"0123456789"     -> "0369"  (not "0369630369")
"@"              -> "@"
"io"             -> "io"  (Cat program in Backhand)
"!?O"            -> "!?O" (Outputs random bits forever in Backhand)
"---!---!"       -> "-!-----!"

और , बेशक, बैकहैंड में लिखा गया एक संदर्भ कार्यक्रम ( यह थोड़ा छोटा लग सकता है ठीक है, मुझे लगता है कि मैंने इसे ठीक कर लिया है)।

नियम।

• मानक ढीले निषिद्ध हैं
• पहले कार्यक्रम के इनपुट में केवल मुद्रण योग्य ASCII और newlines (यानी बाइट्स 0x20- 0x7Eसाथ ही 0x0A) शामिल होंगे
• आप यह चुन सकते हैं कि आपका दूसरा प्रोग्राम आपके पहले बाइट्स से या UTF-8 वर्णों द्वारा परिवर्तित किया गया है या नहीं।
• दूसरा कार्यक्रम:
  • मामला मायने नहीं रखता है, इसलिए pErFectLy OKayयदि आप चाहें तो आपका आउटपुट हो सकता है ।
  • व्हाट्सएप / लीडिंग व्हाट्सएप की कोई भी राशि (न्यूलाइन, टैब, स्पेस) भी ठीक है।
  • दूसरा कार्यक्रम पहले की तरह ही भाषा होना चाहिए, हालांकि जरूरी नहीं कि एक ही प्रारूप (कार्यक्रम / कार्य) हो
  • मुझे अतिरिक्त वाक्यांशों पर टिप्पणियों से सुझाव शामिल करने की खुशी है (जब तक कि वे बहुत कम न हों)
• जैसा कि यह कोड-गोल्फ है , आपका उद्देश्य आपकी भाषा के लिए सबसे कम उत्तर प्राप्त करना है!
• दो हफ्तों में, मैं सबसे कम बैकहैंड उत्तर के लिए 200 इनाम दूंगा।

Comments

सैंडबॉक्स (हटाए गए)

— जो किंग

सुझाए गए टेस्टकेस: "---!---!"(या कोई भी स्ट्रिंग जहां अंतिम वर्ण एक से अधिक बार दिखाई देता है)

— TFeld

जब आपके कार्यक्रम को खुद इस अंदाज में व्याख्यायित किया जाता है - क्या व्याख्या की जाती है?

— 15

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

— एनसीएम

@ngm हां। -----

— user202729

Answer 1

आर , 187 बाइट्स

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g=function(x,n=nchar(x),i=c(1:n,(n-1):1,2:n),j=seq(1,3*n-2,3),k=i[j][1:which(i[j]==n)[1]])cat(substring(x,k,k),sep='') 

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

अंत में एकल स्थान की आवश्यकता होती है ताकि \nप्रोग्राम को स्वयं पर लागू करने पर कभी प्रिंट न हो।

व्याख्या

भाग 1:

Ungolfed:

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g <- function(x) {
  n <- nchar(x)                      # number of characters in string
  i <- c(1:n, (n - 1):1, 2:n)        # index: 1 to n, n-1 back to 1, 2 to n
  j <- seq(1, 3 * n - 2, 3)          # every third element of i
  k <- i[j][1:which(i[j] == n)[1]]   # the elements of i at indices j, up to the first appearance of n
  cat(substring(x, k, k), sep = "")  # extract from x the characters at indices k, and paste them together
}

भाग 2:

जब यह पूरे कार्यक्रम पर कार्य करता है, तो फ़ंक्शन इसका उत्पादन करता है:

cat('Perfectly okay')#=ni(ncr)=1,-:2)=q,n,,i]:i(j=[]assi(k)e' 

Answer 2

पायथन 2 , 163 130 127 121 115 99 96 बाइट्स

i=input() ###
print(i+i[-2:0:-1]+i)[:len(i)*(len(i)%3%2or 3):3]  

#'p lr+yi  n'ottk(ca'eyPf'er)

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

आउटपुट:

int #rt+-01i:n)l(%2 : 
print('Perfect' + # 33o3ie*(l)]:2i(i
#(p=iu)#pni[:-+[ei(n)%r)]
'ly okay')

Answer 3

पर्ल 6 , 101 86 बाइट्स

वाह, -25 बाइट्स ने नॉवेलनहोफ को धन्यवाद दिया कि पहले कार्यक्रम में काफी सुधार हुआ

##
{S:g/(.).?.?/$0/}o{.comb%3-1??.chop~.flip~S/.//!!$_} #
#}{ "" s( kM ro os wt  l )y.

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

मैं उम्मीद कर रहा हूं कि अधिक लोग इस तरह के रिबाउंड का फायदा उठाएंगे। बैकहैंडेड प्रोग्राम है

#{g.?//{o%1.o.iS/!}
{"(Mostly) works"}#_!.~l~h?-bco0?.(:
#S/).$}.m3?cpfp//$ #        .

जो सिर्फ टिप्पणी करने के लिए {"(Mostly) works"}।

Answer 4

05AB1E , 43 40 38 37 बाइट्स

-2 बाइट्स (40 → 38) @Emigna की बदौलत ।

„€€Ã€„Ѐ€µ'€Ý)\[ûDN3*©è  ?®IgD#<ÖNĀ*#

इसे ऑनलाइन आज़माएं । (पुनश्च: से भाषा स्विच 05AB1E (विरासत) को 05AB1E परीक्षण मामले के लिए 0123456789पुराने संस्करण में तेजी से होता है, लेकिन यह पहले शून्य संख्या आदानों के लिए गलत परिणाम दिखाता है।।)

'बैकहैंडेड' कार्यक्रम बन जाएगा:

„ÃеÝ[N© I#N#

जो perfectly okayफुल लोअरकेस में आउटपुट करेगा ।

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

स्पष्टीकरण आधार कार्यक्रम:

„€€Ã€           # Push the string "the pointed"
„Ѐ€µ           # Push the string "dm one"
'€Ý            '# Push the string "been"
     )          # Wrap the entire stack in a list
      \         # And remove that list from the stack again
[               # Start an infinite loop
 û              #  Palindromize the string at the top of the stack
                #   i.e. "1O+1@" becomes "1O+1@1+O1" the first iteration,
                #        and "1O+1@1+O1O+1@1+O1" the next iteration, etc.
  D             #  Duplicate the palindromized string
 N3*            #  0-indexed index of the loop multiplied by 3
    ©           #  Save it in the register (without popping)
     è?         #  Index into the string and print the character
  Ig            #  If the length of the input is exactly 1:
     #          #   Stop the infinite loop
 ®  D <Ö        #  If the value from the register is divisible by the length - 1
          *     #  And
        NĀ      #  The 0-indexed index of the loop is NOT 0:
           #    #   Stop the infinite loop

स्पष्टीकरण 'बैकहैंडेड' कार्यक्रम:

„ÃÐµÝ           # Push the string "perfectly okay"
     [          # Start an infinite loop
      N©        #  Push the index, and store it in the register (without popping)
          I     #  Push the input (none given, so nothing happens)
           #    #  If the top of the stack is 1, stop the infinite loop
            N   #  Push the index again
             #  #  If the top of the stack is 1, stop the infinite loop

चरण दर चरण निम्न होता है:

1. „ÃеÝ: STACK हो जाता है ["perfectly okay"]
2. [: अनंत लूप प्रारंभ करें
3. (पहला लूप पुनरावृत्ति) N©: स्टैक बन जाता है["perfectly okay", 0]
4. (पहला लूप पुनरावृत्ति) I: ["perfectly okay", 0]इनपुट रहता है क्योंकि कोई इनपुट नहीं है
5. (पहला लूप पुनरावृत्ति) #: स्टैक बन जाता है ["perfectly okay"], और लूप जारी रहता है
6. (पहला लूप पुनरावृत्ति) N: स्टैक बन जाता है["perfectly okay", 0]
7. (पहला लूप पुनरावृत्ति) #: स्टैक बन जाता है ["perfectly okay"], और लूप जारी रहता है
8. (दूसरा लूप पुनरावृत्ति) N©: स्टैक बन जाता है["perfectly okay", 1]
9. (दूसरा लूप पुनरावृत्ति) I: STACK रहता है ["perfectly okay", 1]क्योंकि कोई इनपुट नहीं है
10. (दूसरा लूप पुनरावृत्ति) #: स्टैक बन जाता है ["perfectly okay"], और लूप टूट जाता है क्योंकि 1(सत्य)
11. स्टैक के ऊपरी भाग को स्टेप्ड के रूप में लागू करता है: perfectly okay

टीआईओ सक्षम पर डीबगर के साथ यहां चरण देखें।

मेरा यह 05AB1E टिप देखें (अनुभाग कैसे शब्दकोश उपयोग कैसे करें? ) को समझने के लिए क्यों „€€Ã€„Ѐ€µ'€Ýकर रहे हैं the pointed, dm oneऔर beenऔर „ÃеÝहै perfectly okay।

---

पुराना 38-बाइट संस्करण:

„€€Ã€„Ѐ€µ'€Ý)\ giqë¬?[ûDN>3*©è?®Ig<Ö#

इसे ऑनलाइन आज़माएं । (पुनश्च: से भाषा स्विच 05AB1E (विरासत) को 05AB1E परीक्षण मामलों के लिए 0123456789और @पुराने संस्करण में तेजी से होता है, लेकिन यह अग्रणी शून्य या एकल चार जानकारी के साथ नंबर आदानों के लिए गलत परिणाम दिखाता है।।)

'बैकहैंडेड' कार्यक्रम बन जाएगा:

„ÃÐµÝ q?D3èIÖ<®©>û¬i\€€„€€€€')gë[N*?g#

(जहां qकार्यक्रम से बाहर निकलता है और बाकी सभी चीजों को नहीं बनाता है।)

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

Comments

निश्चित रूप /से `\` होना चाहिए?

— एमिग्ना

बचत के N>3*©बजाय का उपयोग करना XU2. मुझे यह भी लगता है कि लूप में सभी मुद्रण करने का कोई तरीका होना चाहिए, जो और भी अधिक बाइट्स को बचाएगा।

— Emigna

@Eigna हाँ, / होना चाहिए था \ .. और -2 के लिए धन्यवाद। मुझे वास्तव में लग रहा है कि इसे और आगे बढ़ाया जा सकता है। यह हर 3 मान को वापस उछालने सहित आधार कार्यक्षमता के लिए लंबे समय तक लगता है।

— केविन क्रूज़सेन

@Emigna बहुत बदसूरत है, लेकिन [ûDN3*©è?®IgD#<ÖNĀ*#अगर-के बिना पहले से है, जो लूप के साथ- इफ -की तुलना में 2 बाइट्स छोटा है। दुर्भाग्य से, हमें अभी भी qबैकहैंडेड प्रोग्राम की आवश्यकता है, इसलिए यह 38 बाइट्स भी होगा । लेकिन मुझे लगता है कि ब्रेक को निश्चित रूप से सिंगल-चार इनपुट, इंडेक्स 0 और एक ही समय में लंबाई -1 द्वारा विभाज्यता को ध्यान में रखते हुए सुधार किया जा सकता है ..

— केविन क्रूज़सेन

Answer 5

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

p='r'#i  n  t  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  # 
s=input();S=s+s[-2:0:-1]+s
print S[:len(~-len(s)%3and S or s):3]

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

Answer 6

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

प्रारंभिक प्रयास। बहुत संतोषजनक नहीं है।

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/(g=p=>(c=y[p])?m++%3?g(p+d):y[p+1]?c+g(p+d):c:g(p-d-d,d=-d))(m=0,d=1)

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

जब कोड स्वयं द्वारा संसाधित किया जाता है, तो निम्नलिखित वर्ण अलग-थलग हो जाते हैं:

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/…
^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^

जो देता है:

f=>"Perfectly okay"//…

Answer 7

जेली , 34 बाइट्स

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€

एक पूर्ण प्रोग्राम या मोनडिक लिंक जो पात्रों की एक सूची को स्वीकार करता है जो प्रिंट या पैदावार (क्रमशः) करता है।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

बैकहैंड-पार्स कोड तब है:

Jȧ“N2s]Ỵ»ị@€

एक पूर्ण कार्यक्रम या निलादिक लिंक प्रिंटिंग या उपज (क्रमशः) ट्यूरिंग पूरा ।

कैसे?

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€ - Main Link: list of characters   e.g. 'abcd'
J                                  - range of length                      [1,2,3,4]
 ŒḄ                                - bounce                         [1,2,3,4,3,2,1]
    `                              - use as both arguments of:
   ȧ                               -   logical AND [x AND x = x]
      “”                           - literal empty list of characters
     ȯ                             - logical OR [when x is truthy: x OR y = x]
        N                          - negate  }
         N                         - negate  } together a no-op
             ¡                     - repeat this...
            2                      - ... two times:
          ŒḄ                       -   bounce                       [1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1]
              3                    - literal three
               s@                  - split into (threes)            [[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1]]
                 ”]                - literal ']' character
                   ȧ               - logical AND [']' is truthy so a no-op]
                    Z              - transpose                      [[1,4,1,4,1,4,1,4,1],[2,3,2,3,2,3,2,3],[3,2,3,2,3,2,3,2]]
                     Ỵ             - split at new lines [no newline characters exist in this list of ints so effectively wrap in a list]
                      Ḣ            - head [undo that wrap]
                       Ḣ           - head [get the first of the transposed split indices]
                                   -                                [1,4,1,4,1,4,1,4,1]
                         `         - use as both arguments of:
                        »          -   maximum [max(x, x) = x]
                          Q        - de-duplicate                   [1,4]
                            ⁸      - chain's left argument (the input)
                           ị       - index into it                  "ad"
                               11€ - literal eleven for €ach (of input)
                             ȧ@    - logical AND with swapped args [[11,11,...,11] is truthy]
                                   -                                "ad"
                                   - (as a full program implicit print)

बैकहैंड-पार्स कोड तब है:

Jȧ“N2s]Ỵ»ị@€ - Main Link: no arguments
J            - range of length (of an implicit 0, treated as [0]) -> [1]
  “N2s]Ỵ»    - compression of "Turing complete"
 ȧ           - logical AND [[1] is truthy] -> "Turing complete"
           € - for each character in the list of characters:
          @  -   with swapped arguments (an implicit 0 is on the right, so f(0, "Turing complete"))
         ị   -     index into
             - (as a full program implicit print)

Answer 8

रूनिक एनकाउंटर , 294 बाइट्स

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                                  /{\!?   =ka:{;!?=ka\
v   R                         R {{R:ak=?!\:$:'@=?!;{:/
v/?!/:$:'@=?!;}:ak= ?!;}:ak=?!\}\        }
y\=ka:L                      }{ /        }
\iuakrU      y<<              !  }}}L {{{L

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

असम्पीडित (और लगभग पठनीय) संस्करण:

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                               ;           /                                 \
/y<<         R                         R {{R:ak=?!\:$:'@=?!;{:ak=?!\{:ak=?!\{/
RiuakrR:ak=?!/:$:'@=?!;}:ak= ?!/}:ak=?!\}\        }                ;
\y<<  U                               }{ /        }
      \                                !          L                     }}}L

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

यह ... लगभग उतना ही है जितना मुझे मिल सकता है।

आगे इसे संपीड़ित करने के लिए विभिन्न लूप स्वैपिंग बिंदुओं को संभालने के लिए उन्हें अन्य सामानों से टकराने के बिना एक तरीके की आवश्यकता होगी। पहली पंक्ति (जो कि केवल एक भाग के लिए इनपुट के रूप में स्वयं को पारित करने की आवश्यकता है) को अलग रहने के लिए आवश्यक है: पूरी स्ट्रिंग दूसरी पंक्ति में समस्या पैदा करने ( _आवश्यक रिक्त स्थान के लिए) के बिना फिट नहीं हो सकती है :

Needed string:
>; "  O  n  l  y  _  a  _  F  e  w  _  B  u  g  s
Best fit:
>; "  O  n  l  y  _  a  _  F  e  w/{_\!?   =ka:{;!?=ka\
Collision:                             ↑

यही कारण है कि ?से दूर ले जाया जा सकता !है जो अपने आप से दूर ले जाया जा सकता \है और स्वीकार्य संदेशों में से कोई भी इस स्थिति में इन तीन वर्णों के किसी अनुमति देते हैं।

इसका विकल्प प्रवाह पुनर्निर्देशन का उपयोग करना होगा, लेकिन इससे निम्न रेखा पर समस्या उत्पन्न होती है:

Last usable character:
            ↓
>"Only a Few Bugs"@
/.../
ur         }{L
              ↑
Earliest available free space:

जैसा कि हमें मुख्य कार्यक्रम में लूप स्विच से बचना है।

ज्ञात पहलु:

• बहुत बड़े इनपुट्स। रूनिक की आईपी स्टैक सीमा के कारण, बहुत बड़े इनपुट स्ट्रिंग्स को धक्का देने से आईपी पूरा होने से पहले समाप्त हो जाएगा। यह अतिरिक्त आईपी को कम करके और उन्हें मर्ज करके कम से कम किया जा सकता है (उदाहरण के लिए, यह संभालता है abcdefghijklmnopqrstuvwxyzलेकिन अपने स्वयं के स्रोत की संपूर्णता नहीं)। और कितने मर्ज होते हैं इसकी परवाह किए बिना एक सीमा होती है। के रूप में इनपुट के 58 बाइट्स के लिए संभाल कर सकते हैं (इसके अलावा, आईपी की संख्या बढ़ाने के लिए और अधिक स्थान का उपयोग किए बिना उन्हें मर्ज करने के लिए कैसे प्राप्त करने की आवश्यकता है)। लूप-रिटर्न लाइन पर दो और आईपी प्रविष्टियाँ फिट कर सकते हैं ( असम्पीडित संस्करण में Uशुरू होने वाली लाइन के दाईं ओर \y<<, या y<<संपीड़ित संस्करण में ऊपर एक लाइन पर छोड़ दिया गया ) इनपुट अधिकतम लंबाई को बढ़ाकर 78 कर देता है।
• रिक्त स्थान के साथ इनपुट स्ट्रिंग के लिए रिक्त स्थान बचना आवश्यक है (जैसे 1\ \ 1\ \ +\ \ O\ \ @)। यह भाषा के इनपुट पार्सिंग की एक सीमा है।
• किसी भी संख्या के साथ पूर्णांक की तरह दिखने वाले स्ट्रिंग्स से युक्त इनपुट की आपूर्ति नहीं कर सकते 0(जैसे कि जब स्टैक पर एक नंबर में बदल जाता है, तो 0खो जाता है)। फिर से, भाषा के इनपुट पार्सिंग की सीमा।

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

प्रवेश:

1. 4 निर्देश बिंदुओं को मिलाएं
2. इनपुट पढ़ें, वर्णों में विराम, एक नई रेखा जोड़ें, रिवर्स, मुख्य लूप दर्ज करें।

मुख्य लूप (कुछ भी जो स्टैक को पॉप करता है एक डुबकी से पहले होता है):

1. ढेर के ऊपर प्रिंट करें
2. न्यूलाइन से तुलना करें। सच: स्विच लूप और घुमाए गए स्टैक दो बार छोड़ दिया।
3. से तुलना करें @। सच: समाप्त। (समाप्त कमांड निष्पादित)
4. स्टैक सही घुमाएँ
5. न्यूलाइन से तुलना करें। सच: समाप्त। (सही कमांड निष्पादित)
6. स्टैक सही घुमाएँ
7. न्यूलाइन से तुलना करें। सच: स्विच छोरों और बारी बारी से ढेर बाईं ओर।
8. स्टैक सही घुमाएँ
9. पाश के शीर्ष पर लौटें

द्वितीयक लूप:

• मुख्य लूप के समान, केवल बाएं घूमने के साथ दाएं घुमाएं

Comments

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

— जो किंग

आपका दूसरा प्रोग्राम कुछ भी प्रिंट नहीं करता है। यह सिर्फ त्रुटियों

— जो राजा

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

— जो राजा

* इसे फिर से पढ़ने की कोशिश करता है। * ... नहीं, अभी तक यह नहीं देखा ... * एक और बार कोशिश करता है। क्राइस्ट, मैं इसे बिल्कुल भी ऐसा नहीं समझता था । मैं "के रूप में जब अपने कार्यक्रम इसे पढ़ने के इनपुट के रूप में अपने स्वयं के स्रोत कोड पढ़ता है "

— Draco18s नहीं रह गया है एसई पर भरोसा करता है

@JoKing क्या यह सही है?

— Draco18s अब SE