बहुभाषाविद में भाषा जोड़ें

239

यह एक उत्तर-चेनिंग चुनौती है, जिसमें प्रत्येक उत्तर पिछले उत्तर पर बनता है । मैं "सबसे पुराने" द्वारा धागे को छांटने की सलाह देता हूं ताकि उस क्रम के बारे में सुनिश्चित किया जा सके जिसमें पद बने हैं।

नोट : यह काफी लंबे समय तक चलने वाली चुनौती बन गई है, और नए उत्तर पोस्ट करना काफी मुश्किल है। इस प्रकार, इस चुनौती के लिए अब एक चैट रूम उपलब्ध है, यदि आप किसी संभावित उत्तर के किसी विशेष भाग पर सलाह चाहते हैं, तो ऐसी भाषाओं के लिए विचार रखें जिन्हें जोड़ा जा सकता है, या पसंद किया जा सकता है। अगर आपको कुछ पूछना या कहना हो तो बेझिझक ड्रॉप करें!

काम

N वें कार्यक्रम में चलाना चाहिए प्रस्तुत किया जाना n विभिन्न भाषाओं; विशेष रूप से, प्रस्तुत किए जाने वाले पिछले कार्यक्रमों में जोड़ी गई सभी भाषाएं, प्लस एक और। इस सवाल के जवाब में इस्तेमाल की जाने वाली पहली भाषा में चलने पर कार्यक्रम का उत्पादन 1 होना चाहिए, 2 दूसरी भाषा में चलने पर, और इसी तरह। उदाहरण के लिए, पहला उत्तर 1 पायथन 3 में चलने पर मुद्रित हो सकता है, और दूसरा उत्तर 1 आउटपुट कर सकता है जब पायथन 3 और 2 में चलाया जाता है जब जावास्क्रिप्ट में चलाया जाता है; इस मामले में, तीसरा उत्तर 1 आउटपुट के लिए होगा जब पायथन 3 में चलाए जाएंगे, 2 जब जावास्क्रिप्ट में चलाया जाएगा, और 3 जब किसी अन्य भाषा में चलाया जाएगा।

अतिरिक्त नियम

  • आपके प्रोग्राम को बिना सोचे-समझे या क्रैश किए चला जाना चाहिए। चेतावनियाँ (और अन्य stderr आउटपुट) स्वीकार्य हैं, लेकिन प्रोग्राम को सामान्य रूप से बाहर निकलना चाहिए (जैसे प्रोग्राम के अंत तक चलने से, या कमांड के माध्यम से जैसे exitकि सामान्य प्रोग्राम समाप्ति करता है)।

  • आउटपुट केवल पूर्णांक होना चाहिए, लेकिन अनुगामी newlines ठीक हैं। अन्य अपरिहार्य स्टडआउट आउटपुट की भी अनुमति है। उदाहरण: बीफ़ुंज -93 में दुभाषिया का नाम और संस्करण , ज़ेफायर में मुद्रित स्ट्रिंग के बाद का स्थान । कुछ भाषाएं मुद्रण की दो विधियाँ प्रदान करती हैं - स्थान की अनुगामी और उसके बिना; इस मामले में बिना अनुगामी स्थान का उपयोग किया जाना चाहिए।

  • प्रत्येक उत्तर पिछले उत्तर की तुलना में 20% या 20 बाइट्स (जो भी बड़ा हो) से अधिक नहीं होना चाहिए। (यह थ्रेड अप स्पैमिंग जैसी भाषाओं के उपयोग को रोकने के लिए है, और कम से कम छोटी मात्रा में गोल्फ को प्रोत्साहित करने के लिए है।)

  • एक ही भाषा के विभिन्न संस्करणों का उपयोग करने की अनुमति है (हालांकि स्पष्ट रूप से उन्हें अलग-अलग संख्याओं को प्रिंट करना होगा, इसलिए आपको पॉलीग्लॉट में संस्करण की जांच करने की आवश्यकता होगी)। हालाँकि, आप एक भाषा सुविधा का उपयोग नहीं कर सकते हैं जो भाषा का संस्करण नंबर लौटाती है। ठीक उसी भाषा को दोहराना, स्पष्ट रूप से, असंभव है (जैसा कि कार्यक्रम को निर्विवाद रूप से दो अलग-अलग संख्याओं में से एक को प्रिंट करना होगा)।
  • कुछ पॉलीग्लॉट प्रतियोगिताओं में प्रतिबंधित होने के बावजूद अत्यधिक टिप्पणी के दुरुपयोग जैसी तरकीबें यहां ठीक हैं।
  • आपको अपने स्वयं के लेखन के लिए एक गाइड के रूप में पिछले उत्तरों का उपयोग करने की आवश्यकता नहीं है (यदि आप चाहें तो पूरे कार्यक्रम को फिर से लिख सकते हैं, जब तक कि यह कल्पना का अनुपालन करता है); हालाँकि, आपके उत्तर को अधिकांशतः पिछले उत्तर पर आधारित करने की अनुमति दी जाती है और संभवतः समाधान बनाने का सबसे आसान तरीका है।
  • आप एक पंक्ति में दो उत्तर प्रस्तुत नहीं कर सकते। बीच में किसी और को पोस्ट करने दो। यह नियम तब तक लागू होता है जब तक कि जीत की शर्त पूरी नहीं हो जाती।
  • जैसा कि इस चुनौती के लिए अन्य प्रतियोगियों को उन्हीं भाषाओं में पोस्ट करने की आवश्यकता होती है जो आप हैं, आप केवल उन्हीं भाषाओं का उपयोग कर सकते हैं जिनके साथ एक नि: शुल्क कार्यान्वयन होता है (हालांकि यह एक पुलिस और लुटेरे प्रतियोगिता थी)।
  • उस स्थिति में जहां किसी भाषा में एक से अधिक दुभाषिया हों, आप किसी भी दी गई भाषा के लिए कोई भी दुभाषिया चुन सकते हैं, जब तक कि सभी कार्यक्रम जो उस भाषा में सफलतापूर्वक चलने के लिए हैं, उस दुभाषिया में ऐसा करें। (दूसरे शब्दों में, यदि कोई प्रोग्राम एक से अधिक दुभाषिया में काम करता है, तो भविष्य के पोस्ट उन दुभाषियों में से किसी एक भाषा के लिए दुभाषिया की "विशेष पसंद" के बजाय "लॉकिंग" पोस्ट के बजाय चुन सकते हैं।)
  • यह चुनौती अब भाषा की पसंद के बारे में नए PPCG नियमों का उपयोग करती है : आप भाषा, या भाषा दुभाषिया का उपयोग कर सकते हैं, भले ही यह प्रश्न से नया हो। हालाँकि, आप एक भाषा / दुभाषिया का उपयोग नहीं कर सकते हैं जो प्रश्न की तुलना में नया है अगर a) भाषा को बहुभाषाविद या b के उद्देश्य से डिज़ाइन किया गया था) भाषा इस प्रश्न से प्रेरित थी। (इसलिए नई डिज़ाइन की गई व्यावहारिक प्रोग्रामिंग लैंग्वेज लगभग निश्चित रूप से ठीक होने जा रही हैं, जैसा कि असंबंधित एसोलैंग हैं, लेकिन ए पीयर ट्री जैसी चीजें , जो इस प्रश्न से प्रेरित थीं, पर प्रतिबंध लगा दिया गया है।) ध्यान दें कि इससे डिज़ाइन की गई भाषाओं की वैधता नहीं बदलती है। बहुविकल्पी के लिए जो इस प्रश्न से पुराने हैं।
  • ध्यान दें कि जीत की स्थिति (नीचे देखें) को डिज़ाइन किया गया है ताकि श्रृंखला को तोड़ना (यानी किसी और के लिए आपके द्वारा किसी भाषा के उपयोग के माध्यम से जवाब देना असंभव हो जाए, जो आगे की भाषाओं के साथ पॉलीग्लॉट के लिए कठिन है) आपको जीतने से अयोग्य घोषित कर देगा। उद्देश्य यह है कि जब तक हम कर सकते हैं तब तक चलते रहें, और यदि आप जीतना चाहते हैं, तो आपको उसका सम्मान करना होगा।

उत्तर प्रारूप

जैसा कि सभी उत्तर एक दूसरे पर निर्भर करते हैं, एक सुसंगत उत्तर प्रारूप होना सहायक होने वाला है। मैं आपके उत्तर को कुछ इस तरह से प्रारूपित करने की सलाह देता हूं (यह श्रृंखला की दूसरी कड़ी के लिए एक उदाहरण है):

2. जावास्क्रिप्ट, 40 बाइट्स

(program goes here)

इस कार्यक्रम के प्रिंट 1 अजगर 3 में, और 2 जावास्क्रिप्ट में।

(यदि आप कार्यक्रम, पॉलीग्लॉटिंग तकनीकों आदि को समझाना चाहते हैं, तो उन्हें यहां रखें)

विजय की स्थिति

एक बार 14 दिनों के लिए कोई नया जवाब नहीं आया, तो विजेता वह होगा जिसने दूसरा सबसे नया उत्तर पोस्ट किया होगा , यानी सबसे बड़ा पॉलीगोट जो साबित किया गया है कि श्रृंखला को नहीं तोड़ा गया। उसके बाद श्रृंखला का विस्तार अभी भी बहुत स्वागत है, हालांकि!

विजेता चांस है , उत्तर 194 (TemplAt) देखें ।

भाषा सूची

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

polyglot  answer-chaining 
— stasoid
स्रोत
3
उन लोगों के लिए जो हटाए गए पोस्ट देख सकते हैं: सैंडबॉक्स पोस्ट यहां था ।
5
पिछले कार्यक्रम को कॉपी करने की कोई आवश्यकता नहीं है, हालांकि निश्चित रूप से आप इसे एक गाइड के रूप में उपयोग कर सकते हैं; खरोंच से कार्यक्रम को फिर से तैयार करने में अधिक समय लगने की संभावना है! जवाब देने के लिए कोई ज़रूरत नहीं है; सबसे पुराना क्रमबद्ध करने से पहले से ही सभी उत्तर दिखाई देंगे।
3
@ ais523 मुझे लगता है कि इसका क्या मतलब था कि नए उत्तरों में नए कोड के साथ लिंक की कोशिश होनी चाहिए?
— ब्लू
5
मुझे लगता है कि हमें एक स्क्रिप्ट की आवश्यकता है जो कोड के एक हेक्स डंप लेती है और स्वचालित रूप से सभी भाषाओं में इसे चलाती है ...
— mbomb007
3
यह एक अलग प्रकार की चुनौती के रूप में पोस्ट किया गया वर्सेटाइल पूर्णांक प्रिंटर है । (प्रेरणा?) अंतिम जवाब (वर्तमान में) स्कोर करेगा 0.0127, केवल Sp3000 की 30 भाषा प्रस्तुत द्वारा पीटा जाएगा ... :)
— स्टीवी ग्रिफिन

जवाबों:

80

नोट: यदि आप इसे पहली बार देखते हैं, तो आप सबसे पुराने द्वारा क्रमबद्ध करना चाह सकते हैं

17. जूलिया (128 बाइट्स)

#v`16 "<" 6/b0\ .q@#;n4"14""
#>3N9@15o|R"12"*^
#=|
print((1/2and 9 or 13)-(0and+4)^1<<65>>62);# =#;print(17)
#gg99ddi2` |1|1+6

अंतिम पंक्ति पर दो ईएससी हैं, पहली से पहले gऔर एक के बाद 2। यह अधिक गोल्फ हो सकता है, लेकिन चीजें वी और पायथ के लिए धन्यवाद नहीं गड़बड़ हो गईं।

प्रिंट 1 में पायथन 3, वी में 2, मिंकोलंग में 3, में 4> <> 5, पायथन 2 में 5, एसएमबीएफ में 6, जाप में 7, रेटिना में 8, पर्ल में 9, बेफुज में 93, बीफुंज में 11। -98, विखंडन में 12, रूबी में 13, टर्टल में 14, हेयस्टैक में 15, पायथ में 16 और जूलिया में 17 हैं ।

संकेत:

  • चौथी पंक्ति की शुरुआत पायथन 2/3, पर्ल, रूबी है। अंत जूलिया है, #=बहुस्तरीय टिप्पणियों के लिए धन्यवाद (ध्यान दें कि जूलिया के पास नहीं है and/or)।
  • V है <ESC>gg99ddi2<ESC>, जो निश्चित रूप से गोल्फ है, लेकिन V इसे ऑनलाइन आज़माने के लिए परेशान कर रहा है ! चूंकि दुभाषिया काफी धीमा है।
  • मिंकोलंग और हैस्टैक पहले स्थान पर आते हैं v। Befunge-93 और -98 नहीं है, और एक पर निर्भर है b।
  • रेटिना चौथी पंक्ति में रिक्त स्थान और 1s की संख्या को गिनता है, और V रेटिना के लिए कॉन्फ़िगरेशन में छिपाता है (यानी बैकटिक से पहले)।
  • @ ETHproduction के संकेत के अनुसार, Japt एक स्ट्रिंग में अधिकांश कोड को छिपाने के लिए बैकटिक्स का उपयोग करता है।
  • विखंडन है R"12"*।
  • SMBF को <.पहली पंक्ति, और अंतिम में गोल्फ दिया गया है 6।
— Sp3000
स्रोत
24
हालांकि बाकी सबका कोड कहां गया है
— अल्फी गुडाक्रे
13
159 बाइट्स से 128 बाइट्स? वाह, यह कुछ उत्कृष्ट गोल्फ है!
— गायों का क्षय 15
6
अच्छा, 2 ^ 7 बाइट्स
— टॉस
7
वाह ... अविश्वसनीय! हम हर भाषा के लिए एक नया स्पष्टीकरण ऊपर लिखने के लिए करने जा रहे हैं जब सभी ने कहा और किया है ;-)
— ETHproductions
4
@AlfieGoodacre "आपको अपने स्वयं के लेखन के लिए एक गाइड के रूप में पिछले उत्तरों का उपयोग करने की आवश्यकता नहीं है (यदि आप चाहें तो पूरे कार्यक्रम को फिर से लिख सकते हैं, जब तक कि यह कल्पना का अनुपालन करता है)"
— mbomb007
52

23. हेक्सागोनी , 186 बाइट्स

क्षमा करें यदि यह योजना गड़बड़ करती है ...

#v`16/"<"6/b.q@"(::):::  (22)S#;n4"14"
#>3N6@15o|> ^*ttt*~++~~~%
#=~nJ<R"12";
#[

print((1/2and 9 or 13)-(0and+4)^1<<65>>62)#46(89999+++++!)=#print(17)#0\32=""<0]#echo 21
#8␛dggi2␛` |1|6

Represent का प्रयोग शाब्दिक ESC वर्ण को दर्शाने के लिए किया जाता है।

प्रिंटों:

हेक्सागोनी में 23, अंडरलोड में 22, निम में 21, प्रील्यूड में 20, रेंग में 19 ( यहां परीक्षण योग्य ), कार्डिनल में 18, जूलिया में 17, पाइथ में 16, हेस्टैक में 15, टर्टलएड में 14, रूबी में 12, विखंडन, बीफुंज -98 में 11, बीफ्यूंज -93 में 10, पर्ल में 9, रेटिना में 8, जाप में 7, एसएमबीएफ में 6, पायथन 2 में 5, 4 में> <>, मिंकोलंग में 3, विम / वी में 2 , और पायथन 3 में 1।

अनलिंक की गई भाषाओं change languageमें जाने के लिए, हेक्सागोनी लिंक के ऊपरी दाएं बटन पर क्लिक करें।

इस प्रारूप में हेक्सागोनी पठनीय (सभी पर) नहीं है। हमें इसे हेक्सागोनल रूप में देखने की जरूरत है।
ध्यान दें कि 2 ईएससी अक्षर ␛एस के साथ बदल दिए गए हैं ताकि आप उन्हें देख सकें - उन्हें नजरअंदाज किया जाता है, इसलिए कार्यक्रम में कोई अन्य नहीं हैं:

        # v 1 6 / " < " 6
       / b . q @ " ( : : )      A lot more readable, right?? No?
      : : : ( 2 2 ) S # ; n
     4 " 1 4 " # > 3 N 6 @ 1
    5 o | > ^ * t t t * ~ + +
   ~ ~ ~ % # = ~ n J < R " 1 2
  " ; # [ p r i n t ( ( 1 / 2 a
 n d 9 o r 1 3 ) - ( 0 a n d + 4
) ^ 1 < < 6 5 > > 6 2 ) # 4 6 ( 8   | Note that the 0s below can be replaced
 9 9 9 9 + + + + + ! ) = # p r i    | With anything (except "`" or " "), 
  n t ( 1 7 ) # 0 \ 3 2 = " " <     V as far as Hexagony is concerned
   0 ] # e c h o 2 1 # 8 ␛ d g
    g i 2 ␛ | 1 | 6 . . . . .    <-- the ␛ represents an esc
     . . . . . . . . . . . .         character
      . . . . . . . . . . .
       . . . . . . . . . .       A "." is a no-op
        . . . . . . . . .
                ^
                | Mirror wraps to here, going NW

हेक्सागोनी से अपरिचित लोगों के लिए , 6 आईपी हैं, जो 6 कोनों पर शुरू होते हैं। केवल 1 एक बार में सक्रिय होता है, और उपयोग करके स्विच किया जाता है #][। मेमोरी मॉडल इस कार्यक्रम के लिए उतना महत्वपूर्ण नहीं है, लेकिन भविष्य में समझने के लिए आवश्यक हो सकता है। आपको यह जानने की आवश्यकता है कि 1 इंट एक "मेमोरी एज" (कम के लिए एमई) में संग्रहीत है, और '"}{सक्रिय होने वाले एमई को बदल दें।

\/|_>< दर्पण हैं जो कार्यक्रम के प्रवाह को नियंत्रित करते हैं।

यह इस तरह काम करता है:

पहली पंक्ति निष्पादित:

#       A no-op (sets active IP to 0, the currently active one)
 v      letter chars set the ME to their ASCII value - so ME is now 118
  16    Like Labyrinth, 0-9 multiplies ME by 10 and is added - ME now 11816
    /   A mirror that sends IP going NW by wrapping to the bottom

नीचे (स्निपेट लंबवत रूप से फ़्लिप किया गया ताकि आप नीचे पढ़ सकें):

    .   
   .    A series of no-ops. The IP is going NW now,
  .     because of the mirror on the top.
 .
|       Another mirror. This one sends the IP NE, into the h
 h      sets the ME to 104, the ASCII value for h
  #     104 % 6 == 2, so IP 2 is now active instead of 0

दाहिना किनारा:

        8  IP #2 is moving SW, starting in the right corner 
       i   Sets the ME to 105
      <    Mirror. Sends the IP going due West
    ""     These change the Active ME - just know that the new edge is 0
   =       Changes the MP (more in specs) - effectively a no-op used to fill space
\32        pushes 23, and mirrors up NE to the !

प्रासंगिक कोड का अंतिम बिट:

!          Prints the current value of the ME as an int. Success!
 20(R~     Does things to the ME - irrelevant now
      @    Ends the program!

ध्यान देने योग्य बातें:

  • हेक्सागोनी निष्पादित करने से पहले सभी एस और `एस को छोड़ देता है, इसलिए उन पर कोई भी परिवर्तन हेक्सागोनी को प्रभावित नहीं करेगा
  • मुझे कोड को पैड करने की आवश्यकता थी ताकि यह 8 वीं के बजाय 9 लंबाई के षट्भुज के रूप में व्याख्या की जाएगी - 169 से नीचे या 217 प्रासंगिक वर्णों के ऊपर सावधान गोल्फिंग करें
  • इस वजह से, ~~~और 0अंत में 2 एस कोड को कोई नुकसान नहीं पहुँचाया जा सकता है
  • =""सिर्फ पिछले एक तो यह है कि एक नया ME संशोधित किया जा सकता से दूर मुझे ले जाता है। उन्हें अन्य पात्रों के साथ प्रतिस्थापित किया जा सकता है जो हेक्सागोनी कार्यक्रम ( 'उदाहरण के लिए) को कोई नुकसान नहीं पहुंचाते हैं
  • यह तकनीकी रूप से बेफ़ुज 93 स्पेक्स के साथ कम्फर्टेबल नहीं है, क्योंकि यह कोड के बाउंडिंग बॉक्स को 80 से 25 क्रैकर्स तक सीमित करता है। हालाँकि, अधिकांश इंटरप्रेटर्स इस कल्पना को अनदेखा करते हैं (जैसे कि TIO), इसलिए मुझे व्यक्तिगत रूप से नहीं लगता कि यह एक बड़ी डील है। यदि आप करते हैं, तो एक टिप्पणी छोड़ने के लिए स्वतंत्र महसूस करें। (अगर वास्तव में मैं इसे बदलना चाहता हूं, तो मैं कोशिश करूंगा)
  • आशा है कि अब बहुत मुश्किल नहीं है।
— MildlyMilquetoast
स्रोत
1
यह आसानी से सही किया अगर सबसे पागल कार्यक्रम प्रवाह बन सकता है। मैं कुछ पागल @ ## विधि के माध्यम से आकार 8 हेक्सागोन के साथ इसे करने के करीब था, लेकिन एक बार मैंने कोशिश की कि 9 बहुत आसान था। इसके अलावा, TIO का v1 बहुत तेज़ी से काम करता है, लेकिन आप भाषाओं को आसानी से स्विच नहीं कर सकते।
— MildlyMilquetoast
मैं आगे लेबिरिंथ का सुझाव दूंगा, लेकिन मैं वह करना चाहता हूं।
— MildlyMilquetoast
मैं खुद इस तरह का कुछ भी लिखने के लिए कुशल नहीं हूं, लेकिन इस बीच मैं क्यूबिक्स के पॉप अप होने का इंतजार कर रहा हूं।
— पावेल
@ तिरछा मैं उस भाषा से परिचित नहीं हूँ। मुझे लगता है कि यह 3 डी है। अच्छा लग रहा है। वहाँ भी कुछ funges कि 3 डी हैं, एक दिलचस्प इसके अतिरिक्त हो सकता है
— MildlyMilquetoast
मुझे संदेह है कि जब तक हम अभी भी इस तरफ की लंबाई पर हैं, तब तक इस प्रवाह को बनाए रखना सबसे आसान है, और जब हम अगले आकार तक जाते हैं तो हेक्सागोनी कोड को फिर से लिखते हैं। 3 डी भाषाओं के संबंध में, ट्रेफुंग को फिट होने के लिए काफी आसान होना चाहिए, यह मानते हुए कि मौजूदा भाषाओं में से कोई भी फॉर्मफीड को देखकर घबराता नहीं है। (इसके अलावा, क्यूबिक्स को पहले भी पोस्ट किया गया था लेकिन हटा दिया गया क्योंकि पोस्टर को लगा कि यह बहुत मुश्किल हो सकता है; हेक्सागोनी और क्यूबिक्स को एक साथ बनाए रखना काफी भ्रामक हो सकता है ...)
52

50. बैश, 1024 बाइट्स

#16  "(}23!@)" 3//v\D(@;'[af2.qc]GkGGZ'#)"14";n4
#/*` "[!PPP(22)SP(>7 7*,;68*,@;'1,@ ␉␉␉␉ q
#>␉
# >36!@␉
#`<`
#<]+<[.>-]>[
#{
#z}
#
#=<xR+++++[D>+++++++L+++<-][pPLEASE,2<-#2DO,2SUB#1<-#52PLEASE,2SUB#2<-#32DOREADOUT,2DOGIVEUPDOiiipsddsdoh@O6O4/]>+.-- -. >][
#Rx%>~~~+ +~*ttt*.x
#D>xU/-<+++L
#R+.----\).>]|
#[#[/v/v(/0l0v01k1kx0l0ix0jor0h0h1d111x0eU0bx0b0o1d0b0e0e00m1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10vx0v0l111111^_)  0046(8+9+9+9+9+=!)
###|
'\';echo 50;exit;';print((eval("1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or"'x"or'({({1})({1}[(0)])}{1}\{1})'#}#(prin 45)(bye)|/=1/24=x<$+@+-@@@@=>+<@@@=>+<?#d>+.--./
__DATA__=1#"'x"//
#.\."12"__*'
###;console.log 39
""""#//
=begin //
#ssseemeePaeueewuuweeeeeeeeeeCisajjapppp/*/
#define z sizeof'c'-1?"38":"37"
#include<stdio.h>
main(  )/*/
#()`#`\'*/{puts(z );}/*'``
<>{# }//
#}
disp 49#//
#{
1}<>//
$'main'//
#-3o4o#$$$
#< >"3"O.
=end #//
"""#"#//
#}
#|o51~nJ;#:p'34'\
#ss8␛dggi2␛ `|1|6$//''25  =#print(17)#>27.say#]#print(47)#]#echo 21#ss*///nd^_^_Z222999"26

और सीखना चाहते हैं? पॉलीगोट चैट की कोशिश करो !

उन्हें ऑनलाइन कोशिश करो!

हमेशा की तरह, मैंने स्टैक एक्सचेंज की सीमाओं के कारण शाब्दिक टैब को ␉शाब्दिक ईएससी अक्षर के साथ बदल दिया ␛। आप ऊपर TIO लिंक के "इनपुट" बॉक्स से प्रोग्राम का आसानी से मिल सकने योग्य संस्करण प्राप्त कर सकते हैं।

मंद होना

इस कार्यक्रम के प्रिंट 50 बैश में, 49 सप्टक में, 48 Deadfish ~, में 47 लिली में, 46 Cubix में, 45 PicoLisp में, 44 alphuck में, 43 जालीदार में, 42 बुराई में, 41 brainf में ***, 40 मिनिमल में -2D, 39 CoffeeScript में, 38 सी में, 37 सी ++, में 36 Labyrinth में, 35 INTERCAL में, 34 रेल में, 33 घटना में, 32 चक्कर में, 31 मॉड्यूलर SNUSP में,30 व्हाइटस्पेस, में 29 उत्प्रेरक में, 28 ब्रेन-आलोचना में, 27 पर्ल 6, में 26 05AB1E में, 25 पिप में, 24 Thutu में, 23 Hexagony में, 22 लादना में, 21 निम में, 20 प्रस्तावना में, 19 Reng में , कार्डिनल में 18 , जूलिया में 17 , पाइथ में 16 , हेस्टैक में 15 , टर्टलड में 14 , रूबी में 13 , विखंडन में 12 , बेफुनेज -98 में 11 , बेफुज -93 में 109 पर्ल 5, में 8 रेटिना में, 7 Japt में, 6 SMBF में, 5 अजगर 2, में 4 में> <>, 3 Minkolang में, 2 वी / विम में, और 1 अजगर 3 में।

सत्यापन

अधिकांश भाषाओं का परीक्षण उपर्युक्त परीक्षण चालक द्वारा किया जाता है। सामान्य चार दोषियों को अलग से परीक्षण की आवश्यकता है:

  • हादसा अपने आधिकारिक दुभाषिया, ऑफ़लाइन का उपयोग करके परीक्षण किया गया था;

  • डेडफिश ~ को इसके आधिकारिक दुभाषिया, ऑफ़लाइन का उपयोग करके भी परीक्षण किया गया था;

  • मॉड्यूलर SNUSP का परीक्षण यहां ऑनलाइन किया गया था ;

  • रेंग का परीक्षण यहां ऑनलाइन किया गया था ।

व्याख्या

मैं भाषाओं को जोड़ने के लिए विभिन्न लीडों को देख रहा था। एक संभावना #लाइन टिप्पणियों के साथ एक भाषा खोजने की थी जो "स्क्रिप्टिंग भाषा" लाइन में जुड़ सकती है (जो पर्ल, पायथन 2 और 3, और रूबी को संभालती है)। मुझे एक उपयुक्त भाषा के बारे में सोचने में थोड़ा समय लगा जो कि पहले से मौजूद लोगों के साथ वाक्यविन्यास-संगत हो सकती है, हालाँकि।

यह पता चला है कि जवाब मुझे उम्र के लिए चेहरे पर घूर रहा था। यदि आप ऊपर दिए गए TIO लिंक पर क्लिक करते हैं, तो यह पॉलीग्लॉट टेस्ट ड्राइवर को खोलेगा, जो बैश में लिखा है। तो इस समय, मेरे पास "बैश - टीआईओ नेक्सस" कहने वाला एक टैब था। आपने सोचा होगा कि यह एक संकेत होगा, लेकिन जाहिर है मैं इसे याद कर रहा हूं। एक बोनस के रूप में, बैश एक स्क्रिप्टिंग भाषा भी है, इसलिए "स्क्रिप्टिंग भाषा लाइन" शब्द अभी भी उपयुक्त है।

बैश प्रोग्राम दूसरी स्क्रिप्टिंग भाषाओं की तरह ही शुरू होता है। हालाँकि, इसे उनसे अलग करने का एक सरल तरीका है; एकल-उद्धृत स्ट्रिंग्स में, \अधिकांश भाषाओं में एक एस्केप चरित्र है, लेकिन बैश में नहीं। इसलिए हम अन्य भाषाओं से bash कोड छिपा सकते हैं '\'…';, जो कि Perl, Python और Ruby में एक विकृत कथन (कोई प्रभाव नहीं) है, लेकिन इसे bash में निष्पादित किया गया है। echo 50;exitबैश कार्यक्रम को समाप्त करने के लिए एक काफी सरल तरीका है। हां तकरीबन।

यहां सबसे बड़ी समस्या यह है कि दौड़ने पर exit, मौजूदा लाइन के अंत तक पार्सिंग जारी रखना चाहिए (भले ही यह प्रश्न में कोड को निष्पादित नहीं करता है), इसलिए हमें यह सुनिश्चित करने की आवश्यकता है कि बाकी हिस्सों पर कोई सिंटैक्स त्रुटियां नहीं हैं रेखा। हमारे पास 'बस एक है उसके बाद exit;(और नहीं हो सकता) तुरंत मिलान किया गया। बाद में लाइन पर, '…'स्क्रिप्टिंग भाषाओं से कुछ ब्रेन-फ्लैक कोड को छिपाने के लिए उपयोग किया जाता है, लेकिन यह इसे बैश से अनहाइड कर देगा। नतीजतन, हमें यह बदलने की जरूरत है कि हम कोड को छिपाने के लिए किस प्रकार के स्ट्रिंग शाब्दिक का उपयोग कर रहे हैं, एकल-उद्धृत से डबल-उद्धृत स्ट्रिंग में जा रहे हैं। or"'"पर्ल, पायथन या रूबी को परेशान किए बिना चाल चलता है (जैसा कि बाएं हाथ का तर्क हर मामले में सत्य है)।

अब हमारे पास एक बेजोड़ दोहरी बोली है जो भविष्य की रेखा पर फैली हुई है। कम से कम एक अन्य भाषा को परेशान किए बिना इसे बंद करना काफी कठिन था; हम वास्तव में क्या करते हैं कि हम कोड को दोहरे उद्धरण से बैश से छिपाने के तरीके को बदल दें, बाद की लाइन पर पायथन / रूबी टिप्पणी में एक बेजोड़ एकल उद्धरण के लिए, और उसके बाद लाइन के अंत में एकल उद्धरण को बंद करें।

पायथ और 05AB1E

दोहरे उद्धरण चिह्नों के साथ गड़बड़ करना उन भाषाओं को भी परेशान करता है जो कोड, पायथ और 05AB1E को छिपाने के लिए दोहरे-उद्धृत स्ट्रिंग्स का उपयोग कर रहे थे। हमारे द्वारा उपयोग की जाने वाली मुख्य चाल यह सुनिश्चित करने के लिए है कि हमारे द्वारा जोड़े गए प्रत्येक दोहरे उद्धरण में जल्द ही एक और डबल उद्धरण हो, ताकि कम से कम कोड का खुलासा हो सके। (यह __DATA__लाइन पर अतिरिक्त दोहरे उद्धरण की व्याख्या करता है , जो बैश के लिए आवश्यक नहीं है।) पायथ \एक बच चरित्र के रूप में उपयोग करता है ; इसका मुख्य कारण यह है कि इसने स्कैपिंग भाषाओं में तार के साथ खिलवाड़ करने के लिए मुझे जो दायरा सीमित कर दिया था, उसने मुझे ऊपर दी गई विधि का उपयोग करने के लिए मजबूर कर दिया (क्योंकि मैं आसानी से \बैश और सब कुछ के बीच व्यवहार में अंतर का उपयोग नहीं कर सका। अन्य)। 05AB1E में, बाहर' भागने चरित्र के रूप में कार्य करता हैतार, और यह होने से बच प्रमुख "नहीं होगा। इसलिए मैंने एक बेकार पैडिंग कैरेक्टर रखने की ज़रूरत को खत्म कर दिया (अपने सामान्य रूप से चूकना x; यह उन चीजों को पढ़ने में आसान बनाता है!) जो "'"कंस्ट्रक्शन के अंदर उपयोग किए जाते हैं, वे बैश कोट्स की शैलियों के बीच बदलने के लिए उपयोग किए जाते हैं।

प्रस्तावना

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

इससे भी बदतर, वर्तमान पहली पंक्ति (जिसे मैं वास्तव में फिर से लिखना नहीं चाहता था) कुछ कठिन सीमाएं रखती हैं जहां पर कोष्ठक दिखाई दे सकते हैं। यह एक नॉनजेरो अंक (उनमें से दो, वास्तव में!) के साथ शुरू होता है, और जल्द ही एक प्रारंभिक कोष्ठक द्वारा पीछा किया जाता है। Prelude में यह एक लूप है, और Prelude में कंट्रोल फ्लो पर जल्दी से लूप करने से कई अलग-अलग समस्याएँ पैदा होती हैं (ज्यादातर क्योंकि वे कम होने के बजाय अधिक कोड चलाने का कारण बनती हैं)। जैसे, मुझे उस कोड को छोड़ने के लिए किसी अन्य लाइन पर 0-इट्रिजन लूप खोलने की बुरी तरह से आवश्यकता थी। mainसी कार्यक्रम के लिए लाइन अत्यधिक उपयुक्त है, लेकिन हम जहां मिलान बंद कोष्ठक है के साथ बहुत सावधान रहना चाहिए; बहुत दूर सही और पर बेजोड़ ब्रैकेट#R+लाइन परेशानी का कारण होगी, बहुत दूर छोड़ दिया और यह पर्याप्त कोड बाहर टिप्पणी नहीं करेगा। (यह ध्यान रखें कि एक पंक्ति में एक कोष्ठक खोलने से एक समापन कोष्ठक oa भिन्न रेखा से मेल खा सकता है।)

एक बार ऐसा करने के बाद, हमारे पास इंसिडेंट लाइन पर एक ओपनिंग कोष्ठक में चिपकाने के लिए बस पर्याप्त जगह है, और हम अंततः कार्यक्रम के पहले कुछ पात्रों को सुरक्षित रूप से प्राप्त कर चुके हैं। हालाँकि, कोष्ठक प्लेसमेंट में अंतर का अर्थ यह है कि कुछ हादसे / व्हर्ल कोड वास्तव में Prelude में चलते हैं, स्टैक को दूषित करते हैं। इसे रोकने की कोशिश करने के बजाय, मैंने व्हर्ल के कुछ शून्य को दाईं ओर आगे बढ़ाया, जिससे उन्हें फिर से काम करने का प्रस्ताव दिया गया।

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

घटना

Prelude अपने आप में काफी कठिन था, लेकिन Prelude और हादसा एक ही समय में काम करना बुरा था। प्रेल्यूड ने कोड पर बहुत सारी बाधाओं को रखा जो मुझे स्वतंत्र रूप से चीजों को घूमने से रोकते थे, और इस तरह से आकस्मिक टोकन निर्माण को गोल्फ के लिए कठिन बना दिया। उदाहरण के लिए, प्रस्तावना को वास्तव में केवल 0सही की जरूरत है, लेकिन यह 00एक असफल टोकन बनने की वजह से है, कुछ ऐसे टोकन जिन्हें हम हादसा कार्यक्रम के हिस्से के रूप में चाहते थे (क्योंकि अगर दो टोकन ओवरलैप होते हैं, तो वे दोनों खारिज कर दिए जाते हैं, और) 00एक टोकन हम खुद ओवरलैपिंग के अलावा चाहता था) ओवरलैपिंग किया गया था। मुझे एक चौथी प्रति बनाने और इसे टोकन के रूप में माना जाने से रोकने के लिए दोनों को बाहर करना पड़ा।

अधिक सूक्ष्म टोकन ;'और ␠␠(अर्थात दो अंतरिक्ष वर्ण) हैं। मुद्दा यह है कि इन दोनों दिखाई है इससे पहलेkG कि कार्यक्रम की शुरुआत के लिए कूद करने के लिए इस्तेमाल किया जा रहा है, और इस प्रकार (कार्यक्रम के केंद्र बिंदु को तोड़ने के अलावा) हादसा के नियंत्रण प्रवाह टूट जाएगा।

␠␠इसे तोड़कर इसकी एक प्रति निकालना व्यवहार्य नहीं लगता है। ओवरलैपिंग के माध्यम से इसे हटाने से यह संभव हो सकता है ( ␠=यह एक आशाजनक संभावित ओवरलैप है), लेकिन यह सिर्फ एक चौथी प्रति जोड़ने के लिए लगभग निश्चित रूप से कम क्रिया है, जो कि मैंने यहां किया है।

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

कोड के 1 किब में 50 भाषाएं

यह @MistahFiggins द्वारा बताया गया था कि मेरा 1025-बाइट सबमिशन एक तरह से नैटर होगा यदि यह 1024 बाइट्स (विशेष रूप से पचासवीं भाषा अपने आप में एक मील का पत्थर है)। इसके लिए कहीं न कहीं बचत की जरूरत है। इस मामले में, मैंने डेडफिश ~ में तीन बाइट्स बचाए, दो अतिरिक्त बाइट्स की लागत पर हादसा टोकन को सही ढंग से बनाने के लिए इस्तेमाल किया, और इस तरह कार्यक्रम को 1024 बाइट्स तक लाया।

इससे पहले, फॉर्मूला जो डेडफिश ~ कोड का इस्तेमाल किया गया था (2) + 2) the + 10 × 1 + 2 = 48। नया फॉर्मूला (3²-2) 1-1 भी 48 उत्पादन कर रहा है। आश्चर्यजनक रूप से, ऐसा नहीं है डेडफ़िश ~ में लिखने के लिए बहुत कम, काफी सरल होने के बावजूद।

यह हमें .008192 का एक वीआईपी स्कोर भी देता है । न केवल यह एक नया रिकॉर्ड है, यह अपने आप में एक अच्छी तरह से गोल संख्या भी है (जो, जाहिर है, सूत्र के इनपुट के रूप में अच्छे गोल संख्या होने का परिणाम है)।

— समुदाय
स्रोत
2
TIO> _> (ईमानदारी से, रेंग के निर्माता) के नहीं होने के लिए क्षमा करें
— Conor O'Brien
@ कोनोरो ब्रायन पिंग डेनिस? इसके अलावा, ais523, आपको एक सिंगल बाइट को बंद करने की कोशिश करनी चाहिए;)
— MildlyMilquetoast
1
puts(z )यदि आप स्वैप करते हैं (और Pपंक्ति 2 में आप जगह में कटौती कर सकते हैं , तो धन्यवाद कि आपने अपने द्वारा बनाए गए प्रस्ताव को छोड़ दिया है। इस जवाब पर ब्रावो। # 50in1k
— संभावना
1
जैसा कि होता है, मैंने एक अलग बाइट को गॉल्फ़ किया। अब यह 1024 पर है। वास्तव में मैं इसे बदलना नहीं चाहता हूं :-) शायद बाद में दिए गए जवाब से हमारे पास कुछ बचत हो सकती है; बहुत अधिक होने की संभावना है (जैसे कि पुराना पुराना हादसा होने की संभावना है / जो अब जरूरत के आस-पास पड़े हुए हैं)।
6
@ ais523 सहमत हुए। यह उत्तर हमेशा 1024 बाइट्स के लिए होता था।
— चांस
38

37. सी ++ (जीसीसी), 776 बाइट्स

#  1"16" 2//v\(;@#/;n4"14"
#/*`3 auaaZ<>16/"<"6/b.q@")(22)S#  ␉␉␉␉ 
#yy␉;36!@
# ␉
#=␉>
#[#yy#yy0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#`<`␉|
print((eval("1\x2f2")and( 9 )or(13 ))-(0and 4)^1<<(65)>>(62))or'(\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"*␉
""""#//
=begin␉//
#*/
#include<iostream>␉
int main()  /*/
#()"`#"\'*/{std::cout<<37;}/*'"`"
$'main'␉//
#-3o4o#$$$
<>3N.<>␉//
#xx
#x%~~~+␉+~*ttt*.x
#xx
=end   #//
"""#"#//
#0]#echo 21#/(\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE)  ap
#_~nJ|#o51\   
#0␛dggi2␛`␉|1|6$//''25  >>>>>#>27.say# =#print(17)#^_^_7LEintndus({})!<>+]/*///Z222999/3!@"26

␉एक शाब्दिक टैब है, ␛एक शाब्दिक ईएससी चरित्र; स्टाॅक एक्सचेंज अन्यथा कार्यक्रम को समाप्त कर देगा। यदि आप इस पर काम करना चाहते हैं, तो मैं नीचे TIO लिंक के "इनपुट" बॉक्स से प्रोग्राम को कॉपी करने की सलाह देता हूं।

उन्हें ऑनलाइन कोशिश करो!

मंद होना

इस कार्यक्रम के प्रिंट 37 सी ++, में 36 Labyrinth में, 35 INTERCAL में, 34 रेल में, 33 घटना में, 32 चक्कर में, 31 मॉड्यूलर SNUSP में, 30 श्वेत रिक्ति में, 29 उत्प्रेरक में, 28 ब्रेन-आलोचना में, 27 पर्ल 6 में , 26 में 05AB1E, 25 में पिप, 25 में थुटू, 24 में हेक्सागोनी, 22 में अंडरलोड , 21 में निम, 20 में प्रील्यूड, 19 में रेंग, 18 में कार्डिनलजूलिया में 17 , पायथ में 16 , हेस्टैक में 15 , टर्टलड में 14 , रूबी में 13 , विखंडन में 12 , बेफुनेज -98 में 11 , बेफुज -93 में 10 , प्रतिपद 5 में 9 , रेटिना में 8 , जाप में 7 , 6 SMBF, में 5 अजगर 2, में 4 में> <>, 3 Minkolang में, 2 वी / विम में, और 1 अजगर 3 में।

सत्यापन

अधिकांश भाषाओं का परीक्षण ऊपर दिखाए गए परीक्षण चालक द्वारा किया जाता है। आप यहां रेंग और मॉड्यूलर SNUSP का परीक्षण कर सकते हैं ; आवश्यकतानुसार वे क्रमशः 19 और 31 का उत्पादन करते हैं।

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

यहां पर है इंसीडेंट टोकन प्रोग्राम । आदर्श रूप से मैं टोकन को कम करना चाहूंगा क्योंकि वे पढ़ने में थोड़ा कठिन हैं, "केंद्र" टोकन को इंगित करते हैं, और इसे परीक्षण चालक में शामिल करते हैं। लेकिन मैं वास्तव में नहीं जानता कि विभिन्न कार्यक्रमों को क्रमिक पूर्णांक प्रिंट करने के अलावा और कुछ कैसे करना है, इसलिए मैंने जहां तक ​​प्राप्त किया है, यह है।

मैंने स्पष्ट हादसे की समस्याओं को हल करने का प्रयास किया है, जैसे शुरुआत और अंत कूदने के बाद टोकन और कुछ भी जो असंगत लग रहा था, लेकिन मैंने टोकन को 0oकेंद्र में रखने के लिए संतुलित नहीं किया है। मुझे वास्तव में यकीन नहीं है कि केंद्र को निर्धारित करने के लिए तर्क क्या है। मुझे उम्मीद है कि @ ais523 वहाँ मदद करेगा। 7LEintndus({})!<>+यदि कोड में इस 4 शामिल करने के लिए नहीं है तो अंत में यह स्ट्रिंग सभी टोकन होगा। .केंद्र टोकन समायोजित करने के लिए इन सभी को हटाया जा सकता है (और हेक्सागोनी संरेखण के लिए बदल दिया गया है )।

मैं कोड के माध्यम से चलने के लिए अगले या दो दिन बाद इस पोस्ट को अपडेट करने जा रहा हूं, (यह मानते हुए कि हादसा बाइट काउंट पर जाए बिना सत्यापित / तय किया जा सकता है)। लेकिन अब यह बहुत देर हो चुकी है, और मैं ज्यादातर इसे बाहर निकालना चाहता था इससे पहले कि मुझे समस्या की तरह एक और भूलभुलैया का समाधान करना पड़े। : पी

व्याख्या

C ++ कोड कैसे काम करता है।

मुझे लगता है कि ज्यादातर लोग C ++ से काफी परिचित हैं, इसलिए मैं बहुत विस्तार में नहीं जाऊंगा। ब्लॉक टिप्पणी के रूप में आते हैं /* comment */। रेखा की टिप्पणी के रूप में आते हैं //comment। उत्तर का उत्पादन करने के लिए C ++ द्वारा उपयोग किया जाने वाला वास्तविक कोड है int main() {std::cout<<37;}। और लाइब्रेरी जिसे STDOUT के साथ प्रयोग करने के लिए उपयोग किया जाता है, इस कथन द्वारा संदर्भित है #include<iostream>।

/ * टिप्पणियाँ दुर्व्यवहार * /

मेरे लिए, C ++ की कहानी मेरे ब्रेन-फ्लैक उत्तर पर वापस जाती है।

आखिरकार # 28 खोजने के बाद, मैंने PPCG में पोस्ट किए गए कुछ अन्य पॉलीग्लॉट्स का अध्ययन करने के लिए निर्धारित किया और उन सभी अध्ययनों ने मुझे कुछ आसान उत्तरों के लिए प्रेरित किया (इनमें से अधिकांश अभी भी उपलब्ध हैं यदि कोई और इच्छुक है)। लेकिन इससे भी महत्वपूर्ण बात, मैं सामान्य रूप से पॉलीग्लॉट्स के बारे में एक निष्कर्ष पर आया था: बड़े पॉलीग्लॉट दो व्यापक श्रेणियों में से एक में आते हैं: #दुरुपयोग या /*टिप्पणी का दुरुपयोग करें।

यह किसी भी तरह से एक तथ्य या प्रतिबंध नहीं है, लेकिन एक व्यक्तिगत मानसिक रूपरेखा है जिसने मेरे अगले कई जवाबों को निर्देशित किया है।

यहाँ से मैंने तर्क दिया कि अगर यह दुनिया का सबसे बड़ा बहुविकल्पीय बनना था, जिसे मैं वर्तमान में होना चाहता हूं, तो यह सबसे अच्छा होगा यदि यह दोनों टिप्पणी परिवारों से टिप्पणी का दुरुपयोग कर सकता है। इसलिए मैंने एक /*टिप्पणी भाषा को शामिल करने का एक तरीका खोजा और ज्यादातर व्यक्तिगत परिचित होने के कारण सी परिवार की ओर धकेल दिया।

सी ++ प्रारंभिक परीक्षण

इसके लिए मेरी आरंभिक विचार प्रक्रिया C # का उपयोग करना था क्योंकि ज्यादातर मेरी परिचितता के कारण और C # के लिए पहली बाधा एक ऐसी स्थिति में पॉलीग्लॉट हो रही थी जहां यह एक ऐसी रेखा को स्वीकार कर सकती थी जो #बिना शुरू नहीं होती थी अन्यथा स्क्रिप्टिंग भाषाओं द्वारा कोड के रूप में व्यवहार नहीं किया जाता था। । रेल उत्तर, कई बाइट के साथ-साथ उत्तोलन करने वाले उत्तर जो इस तक जाते हैं, ने इस टुकड़े को हल किया।

इसके बाद समस्या आई कि पहला /*कमेंट ब्लॉक कैसे शुरू किया जाए । मुझे पता था कि रेखा #को पर्ल, रूबी और पायथन के लिए अदृश्य रहने के लिए लाइन शुरू करनी होगी , लेकिन जो कुछ भी /*C # द्वारा पढ़ा जाएगा उससे पहले आया था । मैंने #regionपहली बार एक C # टैग का प्रयास किया , लेकिन यह 2 डी भाषाओं के लिए बहुत ही हास्यास्पद था। C ++ दर्ज करें।

C ++ में कई प्रीप्रोसेसर निर्देश हैं जो सभी के साथ शुरू होते हैं #, जो 2 डी भाषाओं के लिए कई विकल्प देते हैं। लेकिन यह पता चला कि उनमें से सभी कम से कम एक भाषा के साथ असंगत थे, और सी ++ में कोड स्पेस में होने के कारण, मेरे पास काम के सीमित साधन थे। हताशा और हताशा से बाहर, मैंने इस तथ्य में ठोकर खाई कि सी ++ #टिप्पणी ब्लॉक से पहले सिर्फ एक ही स्वीकार करेगा । ठीक है, जो भी हो, यह व्यावहारिक है। इसलिए मैं अनुमान के साथ आगे बढ़ा कि #/*पॉलीग्लॉट में पहले तीन पात्रों के रूप में काम कर सकता था।

मूल सत्यापन का दूसरा भाग यह सुनिश्चित करना था कि वास्तविक प्रिंट विवरण अन्य कोड के साथ खुशी से रह सकता है। मैं ब्रेन-फ्लैक के उत्तर से जानता था कि जाप अन-एस्केप नहीं किया {गया था और यह कहने के लिए C ++ की आवश्यकता थी int main() {std::cout<<37;}और C ++ अपने कोड के बीच में Japt के भागने चरित्र की अनुमति नहीं देगा। इस बार मैं इस बात के लिए भाग्यशाली था कि अगर मैं इस कथन के लिए जाप के शाब्दिक स्ट्रिंग से बाहर निकल गया, तो भी जाप खुशी से उसी परिणाम का उत्पादन करेगा।

इस बीच, ब्रेन-फ्लैक {}या तो पसंद नहीं आया , लेकिन मैं फिर से भाग्यशाली था कि सी ++ #अपने int main()और {std::cout<<37;}बयानों के बीच ठीक था , घुंघराले ब्रेसिज़ को ब्रेन-फ्लैक के परिप्रेक्ष्य से बाहर टिप्पणी करने की अनुमति दी।

इसलिए, C ++ की मुख्य समस्याएं सैद्धांतिक रूप से हल करने योग्य साबित हुईं, मैंने सभी त्रुटियों को हल करने की कठिन प्रक्रिया शुरू की।

2 डी लैंडस्केप

इस उत्तर का सबसे कठिन हिस्सा पॉलीग्लॉट की शीर्ष दो पंक्तियों के पुनर्निर्माण से दूर था। और सबसे महत्वपूर्ण समस्या थी *। अंडरलोड एक *से पहले की अनुमति नहीं देगा (। यह इसे खाली स्टैक पर गणित के संचालन के रूप में मानता है, जो यह महसूस करता है कि एक त्रुटि है। इसलिए बहुभुज को एक (पूर्व की आवश्यकता थी /*लेकिन C ++ इसे अनुमति नहीं दे सकता था। तो समाधान हमें एक सी + + लाइन टिप्पणी //करने के लिए पहली पंक्ति पर छिपाने के लिए था (और फिर एक के साथ दूसरी पंक्ति शुरू #/*।

इसके बाद, Befunge को वास्तव में /कुछ विभाजित किए बिना विचार पसंद नहीं आया, लेकिन मौजूदा Begunge जवाब का अध्ययन करने के बाद 16/"<"6/b.q@मैंने एक नंबर के विचार पर ठोकर खाई और एक स्ट्रिंग आगे एक साथ धमाका हुआ //। यह काम किया है और मुझे नहीं पता कि सी ++ इस के साथ क्यों ठीक है लेकिन यह स्वीकार कर रहा है # 1"16" 2क्योंकि यह प्रारंभिक वक्तव्य है। मैं इस पर सवाल नहीं उठा रहा हूं, लेकिन मुझे पता है कि इसके काम करने के लिए रिक्त स्थान आवश्यक हैं।

लाइन वन

जाप जगह-जगह संवेदनशील हो गया था और वास्तव में शीर्ष पंक्ति पर अपने बैकटिक आधारित स्ट्रिंग में प्रवेश करना नहीं चाहता था, इसलिए यह और पिप का बैकटिक दूसरी पंक्ति में चले गए, जिससे लाइन 1 पर बहुत सारे भाषाई जिम्नास्टिक हो गए।

  • पिप को पंक्ति 1 का अधिकांश भाग पसंद नहीं आया, इसलिए #टिप्पणी को इंगित करने के लिए पहले के बाद एक दूसरा स्थान रखा गया ।
  • (के लिए लादना एक पूर्ववर्ती साथ Japt से बाहर भाग निकले किया जा सकता था \।
  • #Turtlèd में एक कूद टर्मिनेटर है, इसलिए इसकी आवश्यकता थी, लेकिन Pyth इसे एक त्रुटि समाप्त करने वाला लूप मानता है, इसलिए Pyth को शून्य के / बाद एक विभाजन की आवश्यकता थी#
  • मुझे यकीन नहीं है कि @पहली पंक्ति में अब क्या हो रहा है, लेकिन पाइथ और जैप्ट की तरह लगता है कि यह उपस्थिति से बेहतर है, हालांकि @पाइथ के प्रलेखन के अनुसार एक सार्थक चरित्र नहीं है।
  • और ऐसा लगता है कि पहले ;को बिना परिणाम के इस बिंदु पर हटाया जा सकता है, इसलिए मुझे यकीन नहीं है कि अब वहां क्या हल किया जा रहा था, हालांकि मुझे संदेह है कि यह संबंधित था। लेकिन ऐसा लगता है कि भविष्य के समाधान उस एक को छोड़ कर एक बाइट को बचा सकते हैं।
  • <> <और Turtlèd दोनों मूल रूप से पहले की तरह ही काम करते हैं <> <पहले पर दर्शाते हैं #और लाइन एक के अंत तक लपेटते हैं। और Turtlèd कूदता है #जैसे मैंने उल्लेख किया और "14"स्ट्रिंग के साथ समाप्त होता है जो इसे प्रिंट करता है।

2 डी मार्ग

इन मुद्दों को हल करने के साथ, अगला चरण 2D भाषाओं को रूट कर रहा था। पहले प्रारंभिक vको पूर्ववर्ती होने के कारण बेफंग्स द्वारा अनदेखा किया गया था #, लेकिन हेस्टैक और मिंकोलंग को नीचे भेजा गया था। अब, प्रारंभिक स्थान 3 आयाम के साथ मिंकोलंग को भेजने का प्रयास करता है, जिसका प्रलेखन समय आयाम के रूप में संदर्भित करता है।

मिनोलंग के तीसरे आयाम पर त्वरित: मेरे लिए यह एक मिसनोमर के बारे में है जिसे इस समय आयाम को कॉल करना वास्तव में मेरे लिए अस्थायी से अधिक स्थानिक लगता है। मुझे वास्तव में यह तब तक नहीं मिला जब तक मुझे यह लिंक नहीं मिला जो अवधारणा को दिखाता है, और यह 3 डी शतरंज बोर्ड की कई परतों की तरह लगता है। मेरा विश्वास है कि इस तरह से 3 डी भाषाएँ आम तौर पर संचालित होती हैं। लेकिन जैसा कि यह मेरे लिए एक नई अवधारणा थी, मैंने सोचा कि मैं इस जानकारी को दूसरों के लिए बाहर फेंक दूंगा।

इसलिए मिंकोलंग की कई परतों को समाप्त करके लाइनों को सीमांकित किया गया है $$$जिसमें मैंने यहां रेल कोड के अंत में फेंक दिया है #-3o4o#$$$:। अब, मिंकोलंग अंतरिक्ष को मारता है और सबसे पहले >अंदर <>3N.<> ␉//आता है और सही आउटपुट 3 पर जाता है। #>इस लाइन को शुरू करने की अनुमति नहीं दी जा सकती क्योंकि यह एक पर्ल 6 टिप्पणी ब्लॉक को समाप्त करने का प्रयास करेगा, इसलिए एसएमबीएफ और मस्तिष्क <के #लिए संतुलन के बजाय इसका उपयोग किया जाता है। -Flak। हालाँकि, यह एक ब्रेन-फ्लैक स्टैक स्वैप प्रक्रिया है, इसलिए <>मिंकोलंग टर्मिनेट के बाद ब्रेन-फ्लैक के सही उत्तर पर वापस स्वैप करने के लिए दूसरे सेट का उपयोग किया जाता है।

लैब्रिंथ समान रूप से अंतरिक्ष के खिलाफ टकराता है, लेकिन यह लैब्रिंथ को स्तंभ 1 में नीचे ले जाने का कारण बनता है। इसके बाद यह पंक्ति 2 में बदल जाता है जहां यह 3एक और दीवार से टकराकर नीचे जाता है , जिससे यह फिर से दक्षिण की ओर मुड़ जाता है और ;जिससे 3 को पॉपअप हो जाता है। । फिर कार्यक्रम ठीक उसी तरह जारी रहता है, जहां 36 जमा हो जाते हैं और मुद्रित हो जाते हैं, अंत में @बाहर निकलने से पहले । यह पथ जितना होना चाहिए, उससे अधिक लंबा है, लेकिन मैंने पाया कि प्रस्तावना एक सामान्य बाइट का उत्पादन करेगी, इससे पहले कि यह सामान्य 20 आउटपुट हो अगर !यह अब दिखाई देने वाली पंक्ति की तुलना में बाईं ओर आगे नहीं था। इसलिए मैंने इसे और सही कर दिया, क्योंकि मेरे पास ऐसा करने के लिए जगह थी।

इसके बाद, हेडस्टैक की रूटिंग बदल गई क्योंकि /अब vलाइन 1 पर आने से पहले और रेंग की तरह इसका रास्ता दर्शाता है। सौभाग्य से, रेंग शांति से नहीं बल्कि सहवास करता है। एक अड़चन यह थी कि हेन्स्टैक की सुई |रेंग में एक परावर्तक थी, इसलिए #रेंग सही ढंग से रेंग को समाप्त करने के लिए सुई के ऊपर कूद ( ) की तरह एक बेन्फेज का उपयोग करता है।

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

अंत में, कार्डिनल के शुरुआती बिंदु को %पहले से ही घने शीर्ष दो पंक्तियों में lumped होने की कोई विशेष आवश्यकता नहीं थी। इसलिए मैंने इसे पायथन के तार पर ले जाया। इसके कई कोड पथ भी अब बंधे हैं x, जो इसके पॉइंटर की गति को समाप्त करता है।

पंक्ति 2 और 3

यहां एकमात्र महत्वपूर्ण बदलाव यह है कि सभी :एक या किसी अन्य कारण से बाहर हो गए। शायद Prelude की (जरूरतों या शायद यह सरल बाइट गिनती की समस्याएं थीं - शायद दोनों। दूसरी बात यह है कि ट्रिगर का जंप कोड वापस चला गया और जैसा कि रीब्रांड किया गया auaaZ। मेरे पास Befunge के कोड पथ को पूरा करने के लिए जगह थी और यह सबसे अच्छा लग रहा था। इसके अलावा <यह टुकड़ा SMBF के निम्नलिखित को संतुलित करने के लिए है >। वित्तीय रूप से, ”दूसरी पंक्ति के अंत के पास अकेला 05AB1E की स्ट्रिंग को बनाए रखने के लिए है। इसके अलावा, yyलाइन 3 पर भूलभुलैया के लिए सिर्फ भराव पात्र हैं।

बिग स्ट्रिंग ईसोलंग्स

शीर्ष दो लाइनों को हल करने के साथ, फुलर-पार्सिंग एसोलैंग्स में खुदाई शुरू करने का समय था, और पिप एक समस्या थी। यदि आपको याद है कि हम {std::cout<<37;}जैप स्ट्रिंग से बाहर निकलने से घुंघराले ब्रेसिज़ को निपटाते हैं, तो जाट इसे कोड मानते हैं। खैर, पिप एक ही स्ट्रिंग सिंटैक्स का उपयोग कर रहा है और कोड के रूप में इस लाइन को पसंद नहीं करता है और पिप में जप के समान स्ट्रिंग की घोषणा के समान विकल्प हैं। दोनों 'एक चरित्र स्ट्रिंग को घोषित करने के लिए एकल का उपयोग करते हैं, दोनों एक ही भागने की घोषणा का उपयोग करते हैं \और दोनों "स्ट्रिंग पहचानकर्ता के रूप में स्वीकार करेंगे। इसलिए पिप को यह विश्वास दिलाना मुश्किल था कि यह एक स्ट्रिंग थी बिना जाप के भी ऐसा ही था।

यह पता चला है कि जाप में एक शोषक अंतर था - हालांकि #अगले चरित्र की एस्की कीमत लेता है। तो, #"`Japt / pip string को समाप्त कर देगा, फिर Japt को "एक नया स्ट्रिंग शुरू करने के लिए Pip को बताते हुए, का asci मान लेने के लिए कहेंगे । "शायद एक बैकटिक बजाय किया गया सकता है, और शायद बेहतर होता है, लेकिन सोच के अपने लाइन स्ट्रिंग परिवर्तन का एक और बिंदु के रूप में अंदर पर एक अलग स्ट्रिंग पहचानकर्ता का उपयोग किया गया था। तो यहाँ एक और जगह है जहाँ आप सड़क के नीचे कुछ बाइट्स बचा सकते हैं।

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

अब, जाप और पिप दोनों ने इस बिंदु पर काम किया, लेकिन 05AB1E "कोड एक्सपोज़र को उत्पन्न करने वाली कुछ त्रुटि के कारण विफल हो गया । सौभाग्य से यह एक "पूरी चीज़ के चारों ओर एक और सेट लगाकर हल करना काफी आसान था , जैसे कि स्ट्रिंग जोड़तोड़ के सेट को छोड़ना "`#"\\'*/{std::cout<<37;}/*'"`"।

अंत में, रेखा अब इस तरह दिख रही है, int main() #/*"`#"\'*/{std::cout<<37;}/*'"`"जिसे अंडरलोड के साथ समस्या थी। लगातार *, एक और वाक्यविन्यास त्रुटि थी इसलिए मैंने इसे तुष्ट करने के लिए ()बीच में फेंक दिया *।

फ्रैजाइल एसोलैंग्स

अब बड़ी बाधा व्हाइट स्पेस थी। मैं यहां एक टन विस्तार में नहीं जाऊंगा क्योंकि अधिकांश व्हाट्सएप समाधान पहले से दिए गए स्पष्टीकरण में बनाया गया है, और मैं सिर्फ उन उदाहरणों पर चमकता हूं जहां व्हाट्सएप ने कुछ फैसले लेने के लिए मजबूर किया। मैं आपको भूलभुलैया देख रहा हूँ। हालांकि बड़ा बदलाव यह है कि व्हाट्सएप के आउटपुट का वास्तविक कोड 1-3 के बजाय 2-4 है। यह काफी हद तक लाइन 1 में जाप के कोड एक्सपोजर के कारण है।

थुटू को मूल रूप से इस लाइन के साथ समस्याएं थीं int main() #/*()"`#"\'*/{std::cout<<37;}/*'"`":। इसलिए, मैंने #टिप्पणी संकेतक के पीछे सभी समस्याओं को छिपाने के लिए पहले एक लाइनफीड में फेंक दिया और फिर /कोड के उजागर होने के बाद हर जगह अनुगामी के एक समूह को भेज दिया ।

इस बिंदु पर मैंने हेक्सागोनी को संरेखित किया और नई समस्या पाई। बहुत शुरुआत में कोड है, जो जीवन के रूप में शुरू # 1"16" 1कर दिया +में /+23!@अब स्पष्ट ढेर। इसलिए, मैंने अभी इसे हटा दिया +है और अब इसे 123 आउटपुट पाया है। यह ओपनिंग # 1"16" 2गैंबिट को बदलकर और हेक्सागोनी पीस को नीचे गोल्फिंग करके ठीक करना काफी आसान था /3!@।

व्हर्ल के कुछ परिवर्तन हुए, लेकिन यह ज्यादातर यह सुनिश्चित करने की बात थी कि 1s की सही संख्या व्हर्ल-हादसे की रेखा से पहले दिखाई दे। हादसा हालांकि एक टोकन था जो विशेष रूप से मुश्किल था। मैं की सटीक रूप से 3 प्रतियां था /*और */।

मैं शुरू *//*में कोड की किसी भी पुरानी जगह को फेंकना चाहता था ताकि प्रत्येक की 4 वीं कॉपी बनाई जा सके, लेकिन अंडरलोड ने *फिर से लगातार देखा , जो कि एक नहीं था। अंततः मैंने /इस पंक्ति के int main() /*अंत में इसे अंत करने के लिए फेंक दिया /*/, यह सोचकर कि मैं टोकन को ओवरलैप कर दूंगा, लेकिन मैं केवल दो टोकन में से एक की 4 प्रतियां बनाने में सफल रहा। ठीक ठीक। कि यह कैसे काम करता है। ओह ठीक है, मैं अभी /फाइनल में एक समान बनाऊंगा */ताकि वहां 4 भी बना सकूं। इसके बाद, मैंने अंतिम पंक्ति में इस स्ट्रिंग में कई घटना टोकन की 4 प्रति के साथ हेक्सागोनी नो-ऑप्स के एक झुंड को बदल दिया 7LEintndus({})!<>+।

निष्कर्ष

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

खुश कोडिंग।

— मोका
स्रोत
2
लगता है जैसे g++एक की आवश्यकता है .cpp, इसलिए मैंने कहा कि फ़ाइल एक्सटेंशन विशिष्ट अनुभाग के लिए। तब बस run-wrapper.shइसे संभालने के लिए उपयोग करना पड़ता था। मैं इसे संपादित करूँगा।
— Sn55Frog
1
मैं इसे एक आसान जोड़ के रूप में प्रतीकात्मक brainfuck जोड़ना चाहता हूं , लेकिन यूनिकोड वर्ण क्रैश
— python2
1
@SnoringFrog मैं के बारे में उसी तरह महसूस इमोजी
— संभावना
1
इसके अलावा, **अंडरलोड में एक वाक्यविन्यास त्रुटि नहीं है; यह सिर्फ बहुत सारे स्टैक का उपभोग करता है, जो मुझे लगता है कि उस समय उपलब्ध नहीं था (संभवत: क्योंकि आपने कॉलोन को बाहर निकाल दिया था)। आप पहले या उसके बीच कोष्ठक समूहों या कॉलोनों के साथ स्टैक को ऊपर कर सकते हैं, या कभी-कभी इसे कोष्ठक द्वारा कोड को अंडरलोड से छिपा सकते हैं।
2
@ ais523 C के बहुत शुरुआती दिनों में, ऐसे मामलों में समय बचाने के लिए जहां यह अनावश्यक था, प्रीप्रोसेसर तब तक नहीं चलाया गया जब तक कि पहली पंक्ति # के साथ शुरू नहीं हुई। लेकिन अगर आप नहीं चाहते कि आपकी पहली पंक्ति एक प्रीप्रोसेसर स्टेटमेंट हो, तो इसलिए आपको पहली पंक्ति के साथ शुरू करने के तरीके की आवश्यकता होगी # बिना इसे वास्तव में कुछ किए बिना, इसलिए आपके पास अशक्त निर्देश था। मैं दृढ़ता से पीछे की ओर कोड के साथ संगतता पर संदेह करता हूं जो इसे मानक में शामिल करने के लिए तर्क का उपयोग करता था।
— मुजेर
34

3. मिंकोलंग v0.15 (26 बाइट्स)

#>>>>>>>>v
print(1)#>3N.i2

इस कार्यक्रम के प्रिंट 1 अजगर 3, में 2 विम में, और 3 Minkolang v0.15 में

मुझे आशा है कि मैं एक 2d भाषा शुरू करने से चीजों को गड़बड़ नहीं करता

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

व्याख्या

#                     stops program from moving through time (really does nothing)
 >>>>>>>>             I can't use a space because then the program will move through time
         v            go down
         >            go right
          3N.         Outputs 3 and end program
                      Anything afterward is ignored since program has ended

विम किसी तरह मिन्कोलांग को अनदेखा कर देता है, इसलिए यह अच्छा है

और पाइथन के साथ वास्तव में कोई समस्या नहीं थी क्योंकि यह टिप्पणियों की अनदेखी करता है #

आगे...

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

— गायों का कुनबा
स्रोत
16
"समय के माध्यम से कदम" वाट?
— TuxCrafting
5
@ T @xCräftîñg Minkolang के 3 आयाम हैं (2d = normal, तीसरा वाला समय है)। टीबीएच, मुझे यह समझ में नहीं आता है, यह सिर्फ यह बताता है कि टीआईओ लिंक पर स्पष्टीकरण में
— गायों का क्षय
@ mbomb007 क्या आप वास्तव में बात कर रहे हैं?
— गाय नीम हकीम
1
@ T @xCräftîñg मुझे नहीं लगता कि मैं ऐसा कर सकता हूं
— dkudriavtsev
1
@ मुझे यह समझने में बहुत लंबा समय लगा
— TuxCrafting
34

5. पायथन 2 (35 बाइट्स)

#3N.;n4
print('1'if 1/2else'5')
#i2

इस कार्यक्रम के प्रिंट 1 अजगर 3, में 2 विम में, 3 Minkolang v0.15, में 4 में> <> और 5 अजगर 2 में।

यह ऑनलाइन बीटा की कोशिश करो!

पायथन 2 में, 1/2 0 है, जो एक मिथ्या मूल्य है, जो पायथन प्रिंट 5 बनाता है। पायथन 3 में, 1/2 0.5 है, जो एक सत्य मूल्य है, जो पायथन प्रिंट 1 बनाता है।

— betseg
स्रोत
1
मैं इसकी पुष्टि कर सकता हूँ कि यह मिंकोलंग में काम करता है
— गायों का
1
print('1'if 1/2else'5')1/2 के बीच की जगह के बिना मेरे सिस्टम पर टूट जाता है और
— Tasos Papastylianou
खैर, यह TIO पर दोनों संस्करणों के साथ काम करता है।
— betseg
28

4. <<> (29 बाइट्स)

#>>>>>>>>v;n4
print(1)#>3N.i2

यह कार्यक्रम 1 पायथन में 3, विम में 2 , मिंकोलंग में 3 v0.15 और 4 में> <> प्रिंट करता है।

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

कोड चलाया गया

#             - change direction to left
            4 - add 4 to stack
           n  - print as a number
          ;   - end the program

फिर भी एक और 2 डी भाषा।

Minkolang पर कोई प्रभाव नहीं पड़ता है क्योंकि यह दिशा परिवर्तन के बाद वर्ण जोड़ता है, किसी कारण से Vim द्वारा अनदेखा कर दिया जाता है। #पाइथन में एक टिप्पणी है ताकि कोई भी बदलाव न हो।

— नीला
स्रोत
28

28. ब्रेन-फ्लैक , 280 बाइट्स

#v`16/"<"6/b.q@"(::):::   (22)S#;n4"14"
#>3N6@15o|> ^*ttt*~++~~~%
#=~nJ<R"12";
#[
#`<`|
print((eval("1\x2f2")and (9) or (13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'#@46(8+9+9+9+9+=!)=#print(17)#]#echo 21#|/=1/24=x=90/
#8␛dggi2␛` |1|6$//''25  #>say 27#"26

␛ हमेशा की तरह एक शाब्दिक ईएससी चरित्र का प्रतिनिधित्व करता है।

इस कार्यक्रम के प्रिंट 28 ब्रेन-आलोचना में , 27 पर्ल 6 में , 26 05AB1E में , 25 पिप में , 24 Thutu में , 23 Hexagony में , 22 लादना में , 21 निम में , 20 प्रस्तावना में , 19 Reng (परीक्षण किया में यहाँ ), कार्डिनल में 18 , जूलिया में 17 , Pyth में 16 , Haystack में 15 , Turtlèd में 14 ,13 रूबी में , 12 विखंडन में , 11 Befunge-98 में , 10 Befunge-93 में , 9 पर्ल 5 में , 8 रेटिना में , 7 Japt में , 6 SMBF में , 5 अजगर 2 में , 4 में> <> , 3 में मिंकोलंग , 2 विम / वी में , 1 पायथन 3 में

सबसे पहले, मैं कहना चाहता हूं कि इस चुनौती में योगदान देने में सक्षम होने का क्या विशेषाधिकार है। मैंने केवल कुछ हफ्ते पहले कोड गोल्फ के बारे में सुना था और तब से अब तक मैं पूरी तरह से आदी हूं। पहली बात यह है कि जब मैंने पाया कि यह चुनौती कोड को चलाने की कोशिश की गई थी जैसा कि विभिन्न भाषाओं में है बस यह देखने के लिए कि क्या मुझे कुछ भी मिल सकता है, जिसके साथ मैं काम कर सकता हूं। यह तब था जब हम # 6 की तरह थे। मैंने ईमानदारी से सोचा कि यह चुनौती असंभव थी, लेकिन यहाँ हम (# 28 वाह!) हैं। उस समय मुझे जो कुछ मिला वह ब्रेन-फ्लैक आउटपुट 2 था। इसलिए मैंने इसे सीखने के लिए तैयार किया।

ब्रेन-फ्लैक इस तरह की चुनौती के लिए बहुत शानदार निकला क्योंकि यह सीखना काफी आसान है और यह किसी भी चरित्र को छोड़कर बहुत ज्यादा अनदेखी करता है (){}[]<>। #एक ही लाइन पर इसके बाद कुछ भी टिप्पणी करता है, इसलिए अंतिम प्रस्तुत करने का एकमात्र हिस्सा जिसे कभी ब्रेन-फ्लैक के लिए माना जाता था print((eval("1\x2f2")and 9 or 13)-(0and 4)^1<<65>>62)जिसे तब जोड़ा गया था ((())()<<>>)। तो जब मैं अजगर कोड के रूप में सोचने के लिए आया हूं, तो यह योजना बहुत ही बेहतर है।

मैंने ब्रेन-फ्लैक में पार्स बिट्स को पार्स करने के लिए संशोधित किया, ((() () ())()()<<()>>)जिसमें 2 स्टैक के बराबर है पहला 5 और दूसरा 3 जा रहा है। इसके बाद मैं 5 के साथ स्क्वेयर कर रहा हूं ({({})({}[()])}{})और परिणाम को 3 के साथ जोड़ रहा हूं ({}{})। यह स्क्वैरिंग और जोड़ना एक स्ट्रिंग में पायथन के दृष्टिकोण से चल रहा है। मैं यहां पायथन के तर्क को समझने का दावा नहीं कर सकता, लेकिन मुझे पूरा विश्वास है कि इस स्ट्रिंग का अन्यथा अन्य भाषाओं द्वारा सार्थक तरीके से मूल्यांकन नहीं किया जा रहा है, केवल कुछ अपवादों के साथ।

जाप, यह पता चला है, कोड युक्त के रूप में एक स्ट्रिंग के भीतर घुंघराले ब्रेस की व्याख्या करता है, लेकिन ये इस स्ट्रिंग में \प्रत्येक के साथ पहले बाहर निकलने के लिए काफी आसान थे {। लेकिन यह बाइट गिनती तक फूला हुआ था। ऐसे जीवन है।

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

05AB1E को पायथन स्ट्रिंग में मेरा पहला प्रयास पसंद नहीं आया, जिसे दोहरे उद्धरण चिह्नों में संलग्न किया गया था, लेकिन हर कोई अपने उद्धरणों का उपयोग करने के लिए सहमत नहीं था। वहां कोई बड़ी बात नहीं।

इस बिंदु पर हेक्सागोनी एकमात्र भाषा बची थी, और मैं जाहिर तौर पर अगले हेक्स आकार की सीमा से आगे था, इसलिए यह गंदा होने का समय था। /^23!@Hexagony कोड है और मैं इसके बारे में काफी उत्साहित हूं, क्योंकि मुझे लगता है कि यह भविष्य अतिरिक्त बहुत आसान बना देंगे। इस छोटे से टुकड़े को मूल रूप से किसी भी कोड को काटे बिना अजगर स्ट्रिंग में कहीं भी ले जाया जा सकता है। यह पूर्ण स्ट्रिंग है बस इसलिए हम सभी एक ही पृष्ठ पर हैं '(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'। /यहाँ एसई से Hexagony के पथ सेट -> NW डब्ल्यू करने के लिए> इस स्ट्रिंग ई नीचे है, जो हम साथ छूट की एक बहुत कुछ है। (पूर्ववर्ती \बचना है/थुट्टू बीटीडब्ल्यू के लिए)। यहाँ मेरा विचार यह है कि यदि आप परिवर्तन करते हैं, तो संभावनाएँ हैं कि आप कुछ बिंदु पर इस तार से गुजरेंगे और आप कोड पथ को पकड़ने और उचित निष्कर्ष पर भेजने के लिए स्ट्रिंग के भीतर हेक्सागोनी टुकड़े को स्लाइड कर सकते हैं। बस इस बात का ख्याल रखें कि जाप \और के बीच न आएं {। यदि आपको इससे परेशानी है, तो @स्ट्रिंग के दाईं ओर बस एक और हेक्सागोनी समाधान से बचा है, और अन्य भाषाओं के परिणाम के बिना हटाया जा सकता है। और यदि आप विपरीत दिशा में जाने वाले हेक्सागोनी के कोड पथ को पकड़ने के लिए होते हैं, तो आप निश्चित रूप से @!32^\इसके बजाय उपयोग कर सकते हैं /^23!@। इसके अलावा, आप देख सकते हैं कि मेरे समाधान ने हटा दिया===2बाइट सीमा के तहत चीजों को रखने के लिए कोड से। किसी ने यहाँ उल्लेख किया है कि यह हेक्सागोनी के संरेखण के लिए था और मुझे इसकी कोई आवश्यकता नहीं थी।

Finially, यहाँ कोड कोड का एक छोटा टुकड़ा है जो कोडगुल्फ़ की खोज करते समय मिला है जो पाठ की एक पंक्ति को हेक्सागोनी पठनीय षट्भुज में परिवर्तित करता है ताकि आप डिबग कर सकें। मुझे यकीन है कि बहुत से लोग इस बारे में जानते हैं, लेकिन मैंने इसे यहां पोस्ट नहीं किया था, इसलिए यह किसी और की भी मदद कर सकता है। निष्पक्ष चेतावनी, आपको बैकटिक्स और गाड़ी के रिटर्न को हटाने के लिए इनपुट को बदलना होगा और साथ ही कुछ के लिए शाब्दिक बच को स्वैप करना होगा जो कोड को एक सुंदर हेक्सागोन में लाने के लिए कोड प्राप्त करने के लिए सामान्य मात्रा में जगह लेता है।

PS जब मैं इसे लिख रहा था, तब मुझे एहसास हुआ कि मुझसे गलती हुई है। मैंने माना था कि मैं हेक्सागोनी की मेमोरी एज को क्लियर ^कर रहा हूं, लेकिन जाहिर है कि मैं इसे नो-ऑप से रिप्लेस कर सकता हूं। यदि आप इस खंड में हेरफेर करने की कोशिश करते हैं, तो यह ^संभवतः होना चाहिए +। मैं स्पष्ट रूप +से इस से पहले से गुजर रहा था , लेकिन भविष्य के पॉलीग्लॉटर्स इतने भाग्यशाली नहीं हो सकते हैं।

शुभ लाभ!

— मोका
स्रोत
मैं मतदान से पहले रंडन और स्पष्टीकरण की प्रतीक्षा कर रहा था, लेकिन रंडाउन अच्छा लग रहा है, इसलिए मैं स्पष्टीकरण की प्रतीक्षा करते हुए वोट करूंगा :-)। मुझे लगता है कि सभी अतिरिक्त backslashes Thutu में एक वाक्यविन्यास त्रुटि से बचने के लिए कर रहे हैं? इसके अलावा, दिलचस्प दृष्टिकोण जहां आपने अपना कोड जोड़ा, जिसका मैं अनुमान लगा रहा हूं कि हेक्सागोनी के साथ कुछ करना है। पूरी व्याख्या देखकर अच्छा लगेगा। (इसके अलावा, PPCG में आपका स्वागत है!)
और अब मैं स्पष्टीकरण देखता हूं; मुझे इसे पढ़कर बहुत अच्छा लगा। "पायथन कोड" वास्तव में कई स्क्रिप्टिंग भाषाओं (पायथन, पर्ल 5, रूबी) द्वारा उपयोग किया जाता है, लेकिन वे सभी व्याख्या करते हैं andऔर orउसी तरह से, इसलिए आपके कोड को स्क्रिप्टिंग भाषाओं में कोड टिप्पणी करने का तरीका है, लेकिन ब्रेन-फ्लेम काम नहीं करता है। उन सभी में।
1
धन्यवाद @ ais523 आपने मेरे कोड के स्थान का उल्लेख किया है। इसलिए, मुझे पता था कि मुझे ब्रेन-फ्लैक ऑपरेटरों को कहीं न कहीं स्क्रिप्टिंग भाषाओं में दिखाई देना था और मेरी शुरुआती, गलत धारणा यह थी कि यह नई लाइन पर आसान होगा। यह रेटिना के लिए काम नहीं करता था और मैं इसे और 2 डी भाषा की समस्याओं से निपटना नहीं चाहता था, यदि संभव हो तो मैं रेटिना को ठीक करने की कोशिश करता। मैं वर्तमान प्लेसमेंट में ठोकर खाने के लिए भाग्यशाली था।
— मौका
2
शानदार जवाब, और बहुत गहन व्याख्या! मैं यह सुनकर बहुत खुश हूं कि आप ब्रेन-फ्लैक का आनंद लेते हैं। : डी
— DJMcMayhem
25

38. सी, 804 बाइट्स

#  1"16" 3//v\(@#/;n4"14"
#/*`3 auaaZ<>16/"<"6/b.q@")(22)S#  ␉␉␉␉ 
#yy␉;36!@
# ␉
#=␉>
#[#yy#yy0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#`<`␉|
print((eval("1\x2f2")and( 9 )or(13 ))-(0and 4)^1<<(65)>>(62))or'(\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"*␉
""""#//
=begin␉//
#
#*/␉
#define␉z  sizeof 'c'-1?"38":"37"
#include␉<stdio.h>
int main()  /*/
#()`#`\'*/{puts(z);;}/*'``
$'main'␉//
#-3o4o#$$$
<>3N.<>␉//
#xx
#x%~~~+␉+~*ttt*.x
#xx
=end   #//
"""#"#//
#0]#echo 21#/(\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE)  ap
#_~nJ|#o51\   
#0␛dggi2␛`␉|1|6$//''25  >>>#>27.say# =#print(17)#^_^_7LEintndus({})!<>+]/*///Z222999/(3!@)"26

␉एक शाब्दिक टैब है, ␛एक शाब्दिक ईएससी चरित्र; स्टाॅक एक्सचेंज अन्यथा कार्यक्रम को समाप्त कर देगा। यदि आप इस पर काम करना चाहते हैं, तो मैं नीचे TIO लिंक के "इनपुट" बॉक्स से प्रोग्राम को कॉपी करने की सलाह देता हूं।

उन्हें ऑनलाइन कोशिश करो!

मंद होना

यह कार्यक्रम 38 में C, 37 में C ++, 36 में Labyrinth, 35 में INTERCAL, 34 में रेल, 33 में इंसीडेंट, 32 में Whirl, 31 में मॉड्यूलर SNUSP, 30 में Whitespace , 29 में Trigger, 28 में Brain-Flak का प्रदर्शन करता है। 27 में पर्ल 6, 26 में 05AB1E, 25 में पिप, 24 में थुटू, 23 में हेक्सागोनी, 22 में अंडरलोड , 21 में निम, 20 में प्रील्यूड, 19 में रेंग, 18कार्डिनल, में 17 जूलिया में, 16 Pyth में, 15 Haystack में, 14 Turtlèd में, 13 रूबी में, 12 विखंडन में, 11 Befunge-98 में, 10 Befunge -93, में 9 पर्ल 5 में, 8 रेटिना में, 7 में Japt, 6 SMBF, में 5 अजगर 2, में 4 में> <>, 3 Minkolang में, 2 वी / विम में, और 1 अजगर 3 में।

सत्यापन

अधिकांश भाषाओं का परीक्षण ऊपर दिखाए गए परीक्षण चालक द्वारा किया जाता है। आप यहां रेंग और मॉड्यूलर SNUSP का परीक्षण कर सकते हैं ; आवश्यकतानुसार वे क्रमशः 19 और 31 का उत्पादन करते हैं।

यहाँ हादसा टोकन का मेरा थोड़ा घुमा हुआ संस्करण है , जो थोड़ा कम गोल्फ वाला है लेकिन थोड़ा अधिक उपयोगी है।

व्याख्या

मैंने हमेशा छोटे बहुभुज बनाना पसंद किया है, लेकिन कभी भी यह उतना बड़ा नहीं है; मुझे लगा कि मुझे शायद इसे छोड़ देना चाहिए!

@ चांस के अद्भुत सी ++ उत्तर के बाद, सी अगली तार्किक पसंद थी, और इसे (कुछ पिछले उत्तरों की तुलना में) इसे जोड़ने के सापेक्ष आसानी से दिया, मैंने मौका मिलने पर इसके लिए जाने का फैसला किया!

मैंने C और C ++ के बीच अंतर बताने के लिए एक बहुत प्रसिद्ध चाल का इस्तेमाल किया; सी में एक वर्ण स्थिरांक का आकार 1 बाइट है, लेकिन सी में साइज एक इंट (कम से कम 16 बिट्स होने की गारंटी) है। यह कोड बहुत पोर्टेबल होना चाहिए (सिस्टम के लिए शायद बाइट का उपयोग करने के लिए बाइट का उपयोग करने के लिए एक इंट फिट करने के लिए छोड़कर) मैंने एक बेवकूफ गलती की है।

मैंने सबसे पहले printfसब कुछ इनलाइन के साथ करने की कोशिश की , लेकिन मल्टीपल ब्रैकेट्स जाप के लिए समस्या पैदा कर रहे थे, इसलिए मैंने लाइन को सरल बना दिया, जो इसे ठीक करने के लिए दिखाई दिया।

इसके बाद, कार्डिनल को यह पसंद नहीं आया, मैंने अनुमान लगाया कि प्रिंटफ के कारण %, इसलिए मुझे स्ट्रिंग्स में हेरफेर करने के लिए उस एक को हल करना था।

मेरा अगला प्रयास, एक स्ट्रिंग को असाइन करने की कोशिश करना, फिर सी व्यवहार पर दूसरी बाइट आकस्मिक को बदलना, बहुत लंबे समय तक समाप्त हो गया और अगले आकार पर हेक्सागोनी को धक्का दिया होगा; मैं इसे दोबारा इस्तेमाल करने से बचना चाहता था, जो मुझे अतिरिक्त पात्रों के भीतर रखकर निभाना था! इसके लिए मुझे हर बाइट की जरूरत थी, इसलिए मैंने @Chance द्वारा सुझाए गए बाइट-सेविंग बदलावों को लागू किया।

इसलिए मैंने उस सी कोड को थोड़ा नीचे कर दिया और ऊपर आ गया, puts(sizeof'c'-1?"38":"37");जिसमें लगभग काम किया गया था, सिवाय इसके कि अंडरलोड सीफॉल्टिंग था, संभवतः ब्रैकेट्स में जटिल अभिव्यक्ति के कारण।

Perl6 में >>मिलान करने के लिए आवश्यक अतिरिक्त को हटाने के बाद भी <<, मैं एक संक्षिप्त तरीके को एक चार सरणी असाइनमेंट में अधिक जटिल भाग को विभाजित करने के लिए पर्याप्त तरीका नहीं प्राप्त कर सका। इसलिए मैंने इसके बजाय प्रीप्रोसेसर का उपयोग करना समाप्त कर दिया।

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

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

मैंने अब इंसीडेंट का परीक्षण किया है, और यह काम करता है! @Chance और @LliwTelracs के लिए बहुत-बहुत धन्यवाद, जो मैंने महसूस किया है कि यह वेल्श नाम नहीं है, इसकी मदद से मुझे इसकी चपेट में आने में मदद मिली। इस वाक्य रचना हाइलाइटिंग देखें । मैंने उस ;टोकन को हटा दिया है जो टोकन से पहले दिखाई दे रहा था #yy। मैंने बयान के ;बाद केवल एक अतिरिक्त जोड़कर ऐसा getsकिया (मेरे पिछले प्रयास में प्रतिस्थापित किया गया था s(जो अब सी कार्यक्रम में बहुत अधिक दिखाई देता है, जो पिछले एक में किया था) "डिटोकेनिंग" स्ट्रिंग में एक के साथ ;, लेकिन यह निकला मैं वास्तव में हेक्सागोनी (धन्यवाद @ चांस) के लिए एक चरित्र छोटा है, इसलिए इस अंतिम पंक्ति में एक अतिरिक्त चरित्र जोड़ने के प्रयास के बाद, मैंने अभी इसे वापस बदल दिया और अतिरिक्त अर्धविराम को कहीं और जोड़ दिया)।

मैंने व्हाट्सएप को थोड़ा सा बदल दिया है ताकि सेंटिंग पर कुछ प्रयास करने के लिए कुछ अन्य टोकन बदल सकें, टैब लाइनफीड को फिर से टोकन कर सकें ( #includeपंक्ति के अंत में टैब को बीच में ले जाकर, इस प्रकार तीन टोकन बना सकते हैं), और defineलाइन में एक स्थान को स्थानांतरित करके ट्रिपल-स्पेस टोकन को डी-टोकन करें ।

अंत में, प्रारंभिक सबमिशन के एक दिन बाद, मैंने डरावनी प्रीप्रोसेसर चेतावनी की तह तक जाने का फैसला किया, जो कि जीसीसी ने उत्पन्न की (और जिससे क्लैंग विफल हो गई)। मैंने निर्धारित किया कि पहली पंक्ति में काम करने का कारण यह है क्योंकि यह प्रीप्रोसेसर से आउटपुट है जो मूल फ़ाइलनाम और लाइन नंबरिंग जैसी डीबग जानकारी प्रदान करता है। उन्हें पहली पंक्ति में पहला "2" पसंद नहीं था, क्योंकि इसका मतलब था "किसी दिए गए फ़ाइल में शामिल फ़ाइल से वापस लौटना", और जाहिर है कि यह असंभव है कि वहाँ कोई भी शामिल फाइलें नहीं हैं। इसे "1" में बदलने के बाद (सामान्य हेडर शुरू करें) कुछ भाषाओं को चोक कर दिया, मैंने इसे "3" (आंतरिक घटक हेडर शुरू) में बदल दिया, जिसने केवल हेक्सागोनी को तोड़ दिया, क्योंकि यह अब 2 पर निर्भर था। इसलिए हेक्सागोनी कोड की शुरुआत में मैंने एक ओपन ब्रैकेट जोड़ा(3 से 2 को कम करने के लिए, फिर रेटिना, प्रस्तावना और अंडरलोड को संतुष्ट करने के लिए हेक्सागोनी कोड )के अंत ( @) के बाद एक करीबी ब्रैकेट जो सभी अपेक्षित मिलान वाले ब्रैकेट्स को पूरा करता है। रेंग और मॉड्यूलर एसएनयूएसपी का पुन: परीक्षण करने से कोई समस्या नहीं हुई और हादसा टोकन सही लग रहा था, इसलिए मैंने अब इसे ठीक कर लिया था! मैंने इसे विभिन्न प्रकार के विदेशी आर्किटेक्चरों पर परीक्षण किया है और यह काम करता दिखाई देता है। मुझे पता है कि यह एक कोड गोल्फ के लिए महत्वपूर्ण नहीं है, और मुझे कोई आपत्ति नहीं होगी यदि भविष्य के प्रस्तुतकर्ताओं को बाइट की गिनती या जो कुछ भी (या यदि किसी के पहले से ही इस समाधान के आधार पर शुरू करना है और अपने को बदलना नहीं चाहते हैं तो उसे तोड़ना होगा बहुत अधिक), लेकिन एक अच्छा कारण है जो मैंने यह किया है - TIO के ऑब्जेक्टिव-सी कंपाइलर केवल क्लैंग का समर्थन करता है, इसलिए यह बहुत उपयोगी होगा यदि कोई भी इसे जोड़ना चाहता है!

इस बात को ध्यान में रखते हुए कि मैंने इनमें से अधिकांश भाषाओं का उपयोग नहीं किया है, मुझे आशा है कि मेरी सफलता अधिक नवागंतुकों को यह प्रयास करने के लिए प्रोत्साहित करेगी!

— Muzer
स्रोत
@LliwTelracs Huh, उनके जवाब में चांस से जुड़े सी प्रोग्राम में टोकन की सूची के लिए एक अलग आउटपुट था; #yy;; ^ _ ^ _
— मुजेर
त्रुटि है कि मैं प्रति मेरे कार्यक्रम के लिए मूल्य चिपकाने गया था तो यह टैब पहचान नहीं कर सके या निकल जाता था
— fənɛtɪk
@LliwTelracs बस अपने आप को टोकन का पता लगाने की कोशिश कर रहा है, ऐसा लगता है कि मुझे अब तीन बार दिखाई देने वाला अर्धविराम मिल गया है। मैं एक अतिरिक्त जोड़ सकता हूं सिवाय इसके कि मुझे नहीं लगता कि मैं बाइट को अलग कर सकता हूं क्योंकि यह हेक्सागोनी को भ्रमित करेगा। हम्म ...
— मुजेर
1
हादसा काम करता है!
— मुजेर
1
@ चांस मैंने अभी देखा है कि सी प्रीप्रोसेसर में पहली पंक्ति कैसे मान्य है, ऐसा लगता है कि यह डिबग जानकारी के लिए उपयोग किए जाने वाले प्रीप्रोसेसर से आउटपुट है। इसका मतलब है "अब लौट रहा है (2) नाम के साथ फाइल करने के लिए" 16 " पंक्ति 1"। मुझे लगता है कि यह 2 है जो क्लैंग चोक (और gcc चेतावनी) देता है क्योंकि यह पहली बार में किसी भी फाइल में नहीं गया, इसलिए इसमें से कुछ भी नहीं है। जब मुझे मौका मिले तो मैं इसे क्लैंग में भी संकलित करने के लिए इसे किसी और चीज़ में बदलने का प्रयोग कर सकता हूं। देखें gcc.gnu.org/onlinedocs/cpp/...
— Muzer
25

65. ALGOL 68 (जिन्न) , 1634 बाइट्स

#16  "(}+?23!@)-("//*\Dv;'[af2.q]PkPPX'#CO)"14";n4
#/*0|7//```"`   [-'][!(>77*,;68*,@;'1,@10␉␉11)(22)S␉␉(1 P''53'S^'q
#>␉
# 36!@␉`
#
#_>++++.>.}+?
#`<`
#<]}} +<[<.>>-]>[
#{
#z}
#
#=x<R+++++[D>+++++++59L+++<-][pPLEASE,2<-#2DO,2SUB#1<-#52DO,2SUB#2<-#32DOREADOUT,2PLEASEGIVEUPFACiiipsddsd4O6O@oh]>@@+.---@.>][
#x%+>+=ttt Z_*.
#D>xU/-<+++L
#R+.----\).>]|
#[#[(?2?20l0v0x1k1kMoOMoOMoOMoOMOO0l0ix0jor0h0h1d111x0eU0yx0y0moO1d0y0e0e00m1d0i0fx0g0n0n11MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOmOoMOo0moo0n0tx0t0moO0f0t0gOOM0g0f0h0j0j0i0001k1x0vx0v0l111111^_00)
[ "]56p26q[puts 59][exit]" ,'\[' ];#/s\\/;print"24";exit}}__DATA__/
#
###x<$+@+-@@@@=>+<@@@=>+<?#d>+.--.

#
'(((p\';a=a;case $argv[1]+${a:u} in *1*)echo 50;;*A)echo 54;;*)echo 58;;esac;exit;';print((eval("1\x2f2")and 9or 13)-(0and 4)^1<<(65)>>62)or"'x"or'{}{}{}{}({}<(((((()()())){}{})){}{})>){(<{}(({}){})>)}{}({}())wWWWwWWWWwvwWWwWWWwvwWWWwWWWWWWWWwWWWWwWWWWWWWwWWWWWWWW li ha '#}#(prin 45)(bye)46(8+9+9+9+9+=!)((("'3)3)3)"'
__DATA__=1#"'x"
#.;R"12"'
###;console.log 39
""""
=begin
<>{nd
#sseeeemPaeueewuuweeeeeeeeeeCis:ajjap*///;.int 2298589328,898451655,12,178790,1018168591,84934449,12597/*
#define p sizeof'p'-1?"38":"37"
#include<stdio.h>
main ( ){puts(p);}/*
print 61
#}
disp 49;
#{
}<>
$'main'3
#-3o4o#$$$
#<T>"3"O.s
=end
"""#"
#}
#s|o51~nJ;#:p'34'3\=#print (17)#>27.say#]#print(47)#]#echo 21# xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi ax fwwvwWWWwWWWWwvwWWwWWWwvwWWwWWWwvwWWwWWWwvwWWwwwwwwwwwwwWWWwWWWWWwWWWWWWWwWWWWWWWWWwWWWWWWWWWWWWWWWwWWWWWWWWWWWWwvm 
# sss8␛dggi2␛`|$// ''25  16*///~-<~-<~-<<<~-XCOprint("65")#s^_^_2229996#

वीआईपी स्कोर ( वर्सटाइल इंटेगर प्रिंटर ): .005949 (सुधार करने के लिए, अगली प्रविष्टि 1710 बाइट्स से अधिक नहीं होनी चाहिए)

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

मंद होना

इस कार्यक्रम के प्रिंट 65 ALGOL 68, में 64 पीड़ा में, 63 ब्रायन और चक, में 62 घास, में 61 संग्रह के, 60 Moorhens 2.0 में, 59 Tcl, में 58 KSH में, 57 वार में, 56 डीसी में, 55 मस्तिष्क में -फ्लैक क्लासिक, ज़ेडश में 54 , शॉव में 53 , गाय में 52 , असेंबली में 51 , बैश में 50 , ऑक्टेव में 49 , डेडफिश में 48 , ~, लिली में 47 , क्यूबिक्स में 46 , 45PicoLisp, में 44 alphuck में, 43 जालीदार में, 42 बुराई में, 41 brainfuck में, 40 कम से कम-2 डी में, 39 CoffeeScript में, 38 सी में, 37 C ++, 36 Labyrinth में, 35 INTERCAL में, 34 रेल में, 33 हादसा, में 32 चक्कर में, 31 मॉड्यूलर SNUSP, में 30 व्हाइटस्पेस में, 29 उत्प्रेरक में, 28 ब्रेन-आलोचना में, 27 पर्ल 6 में, 26 05AB1E में, 25 पिप में,24 Thutu, में 23 Hexagony में, 22 लादना में, 21 निम में, 20 प्रस्तावना में, 19 Reng में, 18 कार्डिनल में, 17 जूलिया में, 16 Pyth में, 15 Haystack में, 14 Turtlèd में, 13 रूबी में, 12 में विखंडन, 11 Befunge-98, में 10 Befunge -93, में 9 पर्ल 5, में 8 रेटिना में, 7 Japt में, 6 SMBF में, 5 अजगर 2, में 4 > <> में, 3Minkolang, में 2 वी / विम में, और 1 अजगर 3 में।

सत्यापन

अधिकांश भाषाओं का परीक्षण उपरोक्त ड्राइवर के साथ किया जा सकता है, लेकिन 6 भाषाओं का स्थानीय स्तर पर परीक्षण किया जाना है।

  • रेंग को यहां आउटपुट 19 पर परीक्षण किया जा सकता है ।

  • मॉड्यूलर एसएनयूएसपी को यहां आउटपुट 31 पर परीक्षण किया जा सकता है ।

  • टोकन के मैनुअल संतुलन के माध्यम से 33 का परीक्षण करने के लिए हादसे का सत्यापन किया गया।

  • इस दुभाषिया का उपयोग करते हुए डेडफिश ~ का स्थानीय रूप से 48 उत्पादन करने के लिए परीक्षण किया जा सकता है । ध्यान दें कि डेडफिश ~ स्टड पर खिलाए जाने वाले पॉलीग्लॉट को लेता है, लेकिन >>मानक आउटपुट के लिए कई संकेत देता है, जो किसी भी डेडफिश ~ प्रोग्राम को चलाने का अपरिहार्य परिणाम हैं।

  • इस दुभाषिया का उपयोग करके मूरहेंस 2.0 का उत्पादन 60 तक किया जा सकता है ।

ALGOL 68

ALGOL संभवतः प्रोग्रामिंग के शुरुआती दिनों से चार उच्च-स्तरीय प्रोग्रामिंग भाषाओं में से सबसे कम ज्ञात है - इस नेबुली भेद की शेष भाषाएं COBOL, FORTRAN, और लिस्प हैं। ALGOL उस समय अकादमिक और गणित के हलकों में बेहतर था, लेकिन आज आधुनिक भाषाओं पर इसके व्यापक प्रभाव के लिए जाना जाता है। वास्तव में, अधिकांश आधुनिक, व्यावहारिक भाषाओं को "अल्गोल-जैसे" के रूप में वर्णित किया जा सकता है, जिनमें से कम से कम सी नहीं है, जो निश्चित रूप से प्रभाव और डेरिवेटिव का अपना वंश है।

मैं ALGOL को शामिल करने के लिए बहुत उत्साहित हूं क्योंकि यह कंप्यूटर के इतिहास में एक और प्रमुख कदम है जिसे हम इस स्मारक में जोड़ते हैं जिसे हम एक बहुपत्नी कहते हैं। वह मस्त माल है।

ALGOL68 तीन प्रमुख ALGOL विनिर्देशों का नवीनतम है, अन्य ALGOL60 और ALGOL58 हैं। दिलचस्प बात यह है कि विनिर्देशन में एक निश्चित वाक्यविन्यास नहीं है, जिसका अर्थ है कि टोकन परिभाषित हैं, लेकिन वर्तनी नहीं। यह भाषा को अत्यधिक दुभाषिया पर निर्भर करता है क्योंकि किसी भी दिए गए दुभाषिए उदाहरण के लिए टिप्पणी ब्लॉक शुरू करने के लिए एक अलग प्रतीक का उपयोग कर सकते हैं। विनिर्देश ¢एक टिप्पणी ब्लॉक शुरू करने के रूप में वर्णन करता है । लेकिन क्योंकि ¢यह मूल रूप से 127 अससी कोड के बीच नहीं है, इसलिए यह उपलब्ध दुभाषियों के बीच टिप्पणी संकेतक के रूप में बहुत अधिक उपयोग नहीं करता है। खैर यह पता चला है कि जिन्न दुभाषिया मंत्र के ¢रूप में है #, जो कि सभी उद्घाटन है जो हमें पिछले चरित्र 1 को प्राप्त करने और एक बहुभुज बनाने की आवश्यकता है।

वास्तव में जिन्न के पास तीन टिप्पणी वाक्यविन्यास विकल्प हैं, अन्य दो होने coऔर comment, दोनों को बोल्ड में लिखे जाने के रूप में निर्दिष्ट किया गया है। हाँ, बोल्ड। यदि हम इटैलिक का उपयोग करते हैं, तो यह एक चर है। जिनी ने हल किया कि हमारे लिए फिर से सभी कैप्स में बोल्ड वर्तनी है। और जब COसे कहीं भी पॉलीग्लॉट में नहीं है, हमें पॉलीग्लॉट को पार्सर से छिपाने का एक आसान तरीका मिल गया है। यदि COकिसी भाषा के लिए सड़क की आवश्यकता होती है, तो हम अधिक क्रिया COMMENTसिंटैक्स पर स्विच कर सकते हैं ।

ALGOL में कोई भी लाइन टिप्पणी नहीं है - वे सभी ब्लॉक शैली हैं, जिसका अर्थ है कि उन्हें समाप्त करने की आवश्यकता है। पॉलीग्लॉट की प्रारंभिक स्थिति को देखते हुए, हमारी ALGOL ब्लॉक टिप्पणी को तुरंत खोला जाता है और पंक्ति 1 के अंत के पास समाप्त कर दिया जाता है क्योंकि टर्टल एक समान #रूप से एक कूद टोकन के रूप में उपयोग कर रहा है । Turtlèd को बहुत भाग्यशाली रूप से चरित्र Cऔर Oचरित्रों के माध्यम से चलने में कोई समस्या नहीं है, इसलिए पंक्ति 1 में हम ALGOL68 के लिए वसा ब्लॉक टिप्पणी शुरू करने के लिए COतुरंत दूसरे के तुरंत बाद सम्मिलित कर सकते हैं #।

बस यहीं से हमें COprint("65")कहीं जाना है। मैंने अंतिम पंक्ति चुनी क्योंकि मैंने दूसरी #टिप्पणी के साथ लाइन समाप्त करना पसंद किया था और मैं नहीं चाहता था कि टिप्पणी #अंतिम पंक्ति की शुरुआत में समाप्त हो । इसलिए हम अपने ALGOL प्रिंट स्टेटमेंट का पालन करते हैं #sऔर #पॉलीग्लॉट में अंतिम चरित्र के रूप में करते हैं। sमें #salphuck बाहर संतुलन के लिए के लिए है pप्रिंट में।

उत्तर 59 के साथ बहुभुज के अंत को खोलने और यह सब संभव बनाने के लिए @ ais523 के लिए धन्यवाद।

SMBF

हमने ALGOL की अंतिम टिप्पणी को समाप्त करने के लिए बहुभुज के अंत में एक अलग चरित्र जोड़ा, और SMBF पहले इसके उत्तर के लिए अंतिम चरित्र पढ़ रहा था। इसे मापने के लिए, मुझे इस कोड को लाइन 8 पर बदलकर दूसरे से अंतिम चरित्र को पढ़ने के लिए SMBF को बदलना [.>-]होगा [<.>>-]। यह एक SMBF निजी कोड ब्लॉक है क्योंकि BF का MP 0 पर है जब लूप शुरू किया जाता है।

उत्प्रेरक

इस बिंदु पर, मैंने SMBF के साथ कुछ अजीब व्यवहार को देखा और इसे इन कोड खंडों के बीच संबंधों के साथ करना था।

• घटना की छलांग गंतव्य: ^_^_

• ट्रिगर का जंप डेस्टिनेशन प्लस उत्तर: X222999

• ALGOL68 का जवाब: COprint("65")#s

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

एसएमबीएफ के माध्यम से चलने के बाद मैंने पाया कि अंत में ^ _ ^ _ के साथ समस्या समझदारी के कारण थी। ~-<~-<~-<<<~-अधिकांश पॉलीग्लॉट के विपरीत, गैर-निष्पादित पाश के पीछे समझदार कोड ( ) छिपा नहीं है। लेकिन समझदार कोड में कोई SMBF प्रिंट कोड शामिल नहीं है। यह सिर्फ स्मृति मूल्यों को बदल रहा था। यह सहज लग रहा था। तो फिर समस्या क्या थी? यह था कि BF के सामने एस.एम.

समझदार कोड कोड में पात्रों को बदल रहा है जिसे निष्पादित किया जा सकता है, और क्या आप अनुमान लगा सकते हैं कि अस्सी का पड़ोसी क्या ^है? यह है ]। समझदार बहुभुज के अंत में एक SMBF लूप टर्मिनेटर लगा रहा था, जिससे SMBF एक अनंत लूप में गिर गया। वह बुरा मोजो है।

कुछ विचार के बाद मैंने समस्या का 0 बाइट समाधान निकाला और Xअपने उत्तर ( 222999) से ट्रिगर के जंप गंतव्य ( ) को अलग कर दिया और पॉलीग्लॉट को समाप्त कर दिया ~-<~-<~-<<<~-XCOprint("65")#s^_^_2229996#। यह केवल इसलिए काम करता है क्योंकि कोई भी चरित्र ट्रिगर के कूदने के बाद लगातार प्रकट नहीं होता है जो कि ट्रिगर का जवाब नहीं है।

समेट रहा हु

यह सब इस दौर के बड़े बदलाव हैं। मैंने cलाइन 1 में बहुत चर्चा में कटौती करने के लिए एक मामूली बदलाव किया , लेकिन यह विशुद्ध रूप से गोल्फ परिवर्तन के लिए है।

शुभ लाभ!

घटना का विवरण

#<q>"3"O.s#<T>"3"O.sबैलेंसिंग के Tबजाय qअधिक कुशल होने के कारण डिटोकेनाइजिंग बन गया

<>{बन गया <>{nddetokenize करने ndऔर{␊

बीच में }}और अधिक सस्ते +में अलग #<]}} +<[<.>>-]>[करने के लिए एक जगह रखो }}+।

— मोका
स्रोत
25

2. वी (11 बाइट्स)

print(1)#i2

यह कार्यक्रम पायथन 3 में 1 प्रिंट करता है , और 2 वी में।

बस गेंद को लुढ़कने के लिए और जल्दी से मेरी पसंदीदा भाषा को मिश्रण में फेंकने के लिए। :)

यह बहुत सीधा सा जवाब है।

print(1)#

बस ऐसा होता है कि V में एक NOP होता है (मेरे लिए भाग्यशाली) फिर i2इन्सर्ट मोड में प्रवेश करता है और एक '2' सम्मिलित करता है। आप यहां V ऑनलाइन कोशिश कर सकते हैं

बेशक, अजगर में 

print(1)

प्रिंट '1', और 

#i2

एक टिप्पणी है।

— DJMcMayhem
स्रोत
2
यह वी या विम है? आपके द्वारा जोड़ा गया दुभाषिया तकनीकी रूप से "V" है।
— mbomb007
@ mbomb007 ठीक है, V लगभग पूरी तरह से पीछे की ओर संगत है, इसलिए इरादा विम था। मुझे लगता है कि यह तकनीकी रूप से V है। क्या बदलने में बहुत देर हो चुकी है?
— DJMcMayhem
2
वास्तव में नहीं, बस जवाब में शीर्षक संपादित करें।
— mbomb007
1
@ mbomb007 एक शाब्दिक ESC चरित्र यह करेगा (यही कारण है कि मुझे अपने प्रस्तुत करने में एक का उपयोग करना पड़ा)।
1
यह परीक्षण करने वालों के लिए ध्यान दें: आपको यह सुनिश्चित करने की आवश्यकता है कि आपके पास पिछले विम सत्र से किया गया क्लीपबोर्ड नहीं है।
— रेकिंग
24

20. प्रस्तावना, 167 बाइट्स

#v`16 "<" 6/b0\ .q@#;n4"14""
#>3N9@15o|R"12"*^*ttt*~++%
#=|
print((1/2and 9 or 13)-(0and+4)^1<<65>>62);#35(99999+++++!) =#;print(17)
#       ~nJ<
#
#gg99ddi2` |1|1+6

पिछली प्रविष्टि के रूप में एक ही स्थान पर शाब्दिक ESC वर्ण (के बीच #और g, और के बीच 2और `, अंतिम पंक्ति पर), क्योंकि आप विम मुद्रण योग्य पात्रों के साथ डालने मोड से बाहर नहीं ले जा सकते।

इस कार्यक्रम में प्रील्यूड में 20 , रेंग में 19 ( यहाँ परीक्षण योग्य ), कार्डिनल में 18 , जूलिया में 17 , पाइथ में 16 , हेस्टैक में 15 , टर्टलेड में 14 , रूबी में 13 , विखंडन में 12 , बेफुज -98 में 11 , 10 Befunge-93 में , 9 पर्ल में , 8 रेटिना में , 7 Japt में , 6 SMBF में ,5 अजगर 2 में , 4 में> <> , 3 Minkolang में , 2 विम / वी में , 1 अजगर 3 में , औरa partridgeमें एक नाशपाती के पेड़ ।

मौजूदा कोड बहुत अधिक रद्द कर देता है, जिसमें केवल प्रस्तावना शामिल है, जबकि केवल फाल्सी तर्कों के साथ छोरों और ढेर पर कुछ हेरफेर के बारे में हम परवाह नहीं करते हैं। और भी बेहतर, वहाँ सभी भाषाओं उन्हें है (के बीच में एक टिप्पणी है कि कोड में एक स्थान है #और =#पिछले प्रस्तुत करने की)। इसमें फिटिंग का कठिन हिस्सा केवल एक स्टैक के साथ और बाइट काउंट को उड़ाने के बिना संख्या उत्पन्न कर रहा था। यह प्रोग्राम एक लूप का उपयोग करता है जो प्रत्येक स्टैक तत्व में 45 जोड़ता है और इसे ASCII के रूप में आउटपुट करता है, इस प्रकार स्टैक पर 3 के ऊपर 5 रखकर हम 20आउटपुट के रूप में प्राप्त करते हैं। (नीटली, 20 प्रॉड्यूस में 19 की तुलना में 20 की संख्या के लिए एक आसान संख्या है, इसलिए उत्तर 19 पोस्ट किया जा रहा है वास्तव में मुझे थोड़ा मदद मिली है।)

भावी कार्यक्रमों में काम करने के लिए प्रस्तावना काफी आसान होनी चाहिए। किसी के लिए कुछ सलाह यह परेशानी का कारण बन सकती है: कोष्ठक को लंबवत रेखा न दें; सुनिश्चित करें कि आप कोष्ठक के बाहर विस्मयादिबोधक चिह्न की अनुमति नहीं देते हैं; और एक बार जब आपने कोष्ठक के बाहर अंक रख दिए हों, तो एक ही पंक्ति में अधिक कोष्ठक को आगे न रखें। गैप जिसे मैंने Prelude प्रोग्राम में रखा है, वह अभी भी खुला है, और ऐसा लगता है कि यह अन्य 1D भाषाओं के लिए एक उपयोगी स्थान हो सकता है (Prelude's की तरह 1½D, और इस कार्यक्रम में 1D भाषा की तरह अधिक कार्य करता है)।
नाइस, मुझे प्रील्यू के साथ पंच को हराएं :) मुझे वास्तव में लगता है कि ASCII-only V की :%sजगह संभव हो सकती है , लेकिन फिर भी यह थोड़ा मुश्किल है (और वी परीक्षण करने के लिए कष्टप्रद है)
— Sp3000
यदि आप :vim में कमांड शुरू करने के लिए a का उपयोग करते हैं, तो आपको एक गाड़ी वापसी की आवश्यकता होगी, जो कि अप्राप्य होने के लिए भी होता है। : /
— ज़ीवे
4
+ 10000000000 a partridgeएक नाशपाती के पेड़ में। लेकिन क्या यह 5 GOLDरिंग्स में छपता है?
— इनिबिस
23

30. व्हॉट्सएप , 296 बाइट्स

#v`16/"<"6/b.q@"(: ::T):  ␉␉␉␉ :(22)S#;n4"14"
#>3N6@15o|>␉^*ttt*~++~~~%
#=~nJ<R"12"; ␉
#[␉
#`<`|
print((eval("1\x2f2")and (9)or(13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{\/+23!@}[()])}\{})(\{}\{})'#46(8+9+9+9+9+=!)=#print(17)#]#echo 21#|/=1/24=x=90/
#8␛dggi2␛␉` |1|6$//''25  #>say␉␉ 27#T222999"26

Es शाब्दिक पलायन का प्रतिनिधित्व करता है।

Tab शाब्दिक टैब का प्रतिनिधित्व करता है।

इस कार्यक्रम के प्रिंट 30 व्हाइटस्पेस में , 29 उत्प्रेरक में , 28 ब्रेन-आलोचना में , 15 Haystack में , 14 Turtlèd में , 13 रूबी में , 12 विखंडन में 27 पर्ल 6 में , 26 05AB1E में , 25 पिप में , 24 Thutu में , 23 Hexagony में , 22 लादना में , 21 निम में , 20 प्रस्तावना में ,रेंग में 19 ( यहां परीक्षण), कार्डिनल में 18 , जूलिया में 17 , पायथ में 16 , , 11 Befunge-98 में , 10 Befunge-93 में , 9 पर्ल 5 में , 8 रेटिना में , 7 Japt में , 6 SMBF में , 5 अजगर 2 में , 4 > <> में , 3 Minkolang में , 2 वी / विम में , और 1 अजगर 3 में ।

व्हॉट्सएप एक सीमित चरित्र सेट के साथ एक और एसोलैंग है। यह केवल टैब, स्पेस और लाइन फीड को पढ़ता है।

इसलिए एक बार जब हम व्हाट्सएप नहीं पढ़ लेते हैं तो हम निम्नलिखित कोड के साथ छोड़ देते हैं:

[space][space][space][LF]
[space][LF]
[LF]
[LF]
[LF]
[space][space][space][space][space][LF]
[space][space][space][space]

और आउटपुट 30 का कोड यह है:

[space][space][space][tab][tab][tab][tab][space][LF]
[tab][LF]
[space][tab]

इसलिए मौजूदा कोड की शीर्ष 3 लाइनों को आवश्यकताओं को पूरा करने के लिए लाइनों के अंत में अतिरिक्त स्थान दिए गए थे। ध्यान दें कि पंक्ति 1 के टैब और अनुगामी स्थान, पंक्ति के मध्य में> <> की जरूरतों को समायोजित करने के लिए हैं।

यहां लाइन 2 का स्थान बदलकर टैब कर दिया गया। यह 2D भाषाओं के लिए एक स्थान के लिए समान रूप से कार्य करता प्रतीत होता है, लेकिन नेत्रहीन यह अब और पंक्तिबद्ध नहीं होता है। ¯ \ _ (ツ) _ / ¯

30 को आउटपुट करने के निर्देश के बाद, गेम को बाकी आवश्यक रिक्त स्थान मिल गए और लाइन बेकार की चीजों को करने और सही ढंग से संकलन करने के लिए खिलाती है।

श्वेत स्थान के पास निर्देश होते हैं कि एक लेबल के साथ कोड स्थान / गोटो को चिह्नित करें जो एक मनमाने ढंग से संख्या टैब और रिक्त स्थान के लिए अनुमति देता है, ताकि लंबी रेखा के रिक्त स्थान को काउच करने में मदद मिले। यह एक लाइन फीड के साथ भी शुरू और समाप्त होता है, जिससे हमें लाइन 3-6 में से कुछ लाइन फीड में मदद मिली।

अंतिम रेखा रेटिना को तोड़े बिना एक लाइनफीड नहीं हो सकती है, इसलिए इसके निर्देश कुछ मनमाना गणित और स्टैक हेरफेर करने के लिए हैं।

यहाँ स्थान, टैब और लाइनफ़ीड के साथ पूरा कोड हमारे नोटेशन से बदला गया है:

#v`16/"<"6/b.q@"(:[Space]::T):[Space][Space][Tab][Tab][Tab][Tab][Space]:(22)S#;n4"14"[LF]
#>3N6@15o|>[Tab]^*ttt*~++~~~%[LF]
#=~nJ<R"12";[Space][Tab][LF]
#[[Tab][LF]
#`<`|[LF]
print((eval("1\x2f2")and[Space](9)or(13))-(0and[Space]4)^(1)<<(65)>>62)or'(\{(\{})(\{\/+23!@}[()])}\{})(\{}\{})'#46(8+9+9+9+9+=!)=#print(17)#]#echo[Space]21#|/=1/24=x=90/[LF]
#8␛dggi2␛[Tab]`[Space]|1|6$//''25[Space][Space]#>say[Tab][Tab][Space]27#T222999"26[LF]

और यहाँ सिर्फ व्हॉट्सएप का एक टिप्पणी संस्करण है:

Push 30 onto the stack
[space][space][space][tab][tab][tab][tab][space][LF]

Output the number at the top of the stack
[tab][LF][space][tab] 

Jump to label null if the top of the stack is negative. (it's not)
[LF][Tab][LF]

Label this location as [Space]
[LF][Space][Space][Space][LF]

Add the top two items on the stack and replace them with the result. 
[Tab][Space][Space][Space]

Store the stack.
[Tab][Tab][Space]

संपादन: हेक्सागोनी रिक्त स्थान की तरह टैब को छोड़ने के लिए निकलता है, मेरे पिछले दावे के विपरीत। @ ais523 शाब्दिक पलायन और टैब के लिए खाते में @ केनी के हेक्सागोनाइज़र को अपडेट करने के लिए पर्याप्त था। टैब को नो-ऑप्स के रूप में पढ़ने के बारे में और शाब्दिक पलायन को बदलने के लिए मुझे इसे संशोधित करना पड़ा .क्योंकि ␛वर्ण अन्य वर्णों की तुलना में व्यापक है, जिससे हेक्स थोड़ा गलत हो गया है। यहाँ लिंक है ।

और यह हमारे सही वर्तमान हेक्स है:

          # v 1 6 / " < " 6 /
         b . q @ " ( : : : T )
        : : ( 2 2 ) S # ; n 4 "
       1 4 " # > 3 N 6 @ 1 5 o |
      > ^ * t t t * ~ + + ~ ~ ~ %
     # = ~ n J < R " 1 2 " ; # [ #
    < | p r i n t ( ( e v a l ( " 1
   \ x 2 f 2 " ) a n d ( 9 ) o r ( 1
  3 ) ) - ( 0 a n d 4 ) ^ ( 1 ) < < (
 6 5 ) > > 6 2 ) o r ' ( \ { ( \ { } )
  ( \ { \ / + 2 3 ! @ } [ ( ) ] ) } \
   { } ) ( \ { } \ { } ) ' # 4 6 ( 8
    + 9 + 9 + 9 + 9 + = ! ) = # p r
     i n t ( 1 7 ) # ] # e c h o 2
      1 # | / = 1 / 2 4 = x = 9 0
       / # 8 . d g g i 2 . | 1 |
        6 $ / / ' ' 2 5 # > s a
         y 2 7 # T 2 2 2 9 9 9
          " 2 6 . . . . . . .

अंत में, मैंने कुछ ज़रूरतमंद पात्रों को बाहर निकाल दिया, जो पहले से प्री-अप कोष्ठक और हेक्सागोनी हेक्सागोन्स को पंक्तिबद्ध करने के लिए जोड़ा गया था।

निम का कोड वापस से echo 21हैecho 5+5+11

हेक्सागोनी #@46अब है#46

हेक्सागोनी के कोड से वापस आ गया /+23!@=है/+23!@

प्रस्तावना का पैतृक संरेखण (9) or (13)बन गया(9)and(13)

खैर, यह सब मुझे मिल गया है। भाग्य आप सभी का साथ दे!

— मोका
स्रोत
1
मुझे लगता है कि मैंने सभी लिंक तय किए और I अंतरिक्ष में उन स्थानों को जोड़ा, जो मेरे कॉपी पेस्ट से उत्पन्न हुए थे। यह निश्चित नहीं है कि एसई में टैब्स होने के लिए टैब कैसे प्राप्त करें, टियो में कोड को भंग करना चाहिए। मुझे इस उत्तर में निर्देशों से अपना समाधान फिर से बनाना था, लेकिन किसी तरह 2 कम बिट्स के साथ समाप्त हो गया ... उफ़?
— संभावना
1
बस आपके स्पष्टीकरण में गलती देखी गई: गाड़ी वापसी (एएससीआईआई 13) लाइन फीड (एएससीआईआई 10) से एक अलग चरित्र है। अधिकांश भाषाएं (व्हॉट्सएप सहित) 10 के बारे में परवाह करती हैं, 13s की नहीं (और यह माना जाता है कि PPCG सबमिशन में एक लाइन ब्रेक सिर्फ एक ASCII 10 है, जब तक कि अन्यथा न कहा जाए, क्योंकि 13s आपके बाइट की संख्या को नहीं बढ़ाते हैं फायदा)।
1
ई के बाद पहली बार प्रतिबिंब के बाद एनडब्ल्यू आने के कारण आपकी हेक्सागोनी स्पष्टीकरण छवि गलत है ( प्रिंटe23 ) ;। उपरोक्त लिंक काम करता है ...?
— माइल्डलीवेटकास्ट
1
मैं इस निष्कर्ष पर पहुंचा हूं कि हेक्सागोनी के लिए TIO टैब वर्णों को रिक्त स्थान / नईलाइन्स के रूप में मानता है। वह छवि जिसे आप हेक्सागोनी प्रोग्राम प्रदान करते हैं, उसके बाहर निकलने पर कुछ भी नहीं है, लेकिन यदि आप इसका अनुसरण करते हैं (या इसे TIO में डालते हैं, तो टैब को .s के साथ बदल देते हैं )। हालाँकि, TIO में छवि में कोड को कॉपी करें, केवल प्रशिक्षण .s (वास्तविक कोड का हिस्सा नहीं) और सभी training को हटा दें । यह 23 प्रिंट करता है
— MildlyMilquetoast
1
वाह, धन्यवाद @ मिस्ताफिगिंस! ऐसा लगता है कि मैंने कुछ कटौतीत्मक त्रुटियां कीं और उन्हें मेरे स्पष्टीकरण के लिए प्रचारित किया। मैंने Hexagony स्पष्टीकरण, हेक्स आरेख, और Hexagonoizer पर्ल स्क्रिप्ट को ठीक किया है, साथ ही क्रॉस को सीधे Hexagony के खिलाफ परिणाम की जाँच की है। अब सब कुछ अच्छा होना चाहिए। अच्छा लगता है!
— मौका
23

100. ब्रेनबुल, 2953 बाइट्स

#16  "?63(o?23!*# #@"/*\DZZCv;'[af2.q]PkPPX)\('#CO"14"; */
#/*0|7//```"`  [>.>.])[-'][(>77*;,68*,@,1',;# l1011)(22)S\4n;iiipsddpsdoh coding:utf8ââââ(1P''53'S^'????!?!??!??!!!!???!?!??!!?!?!!!!!?!!!!?????!????????????????????!) (qx
#>â
# 36!@â`  e++++++::@ 
#~
#y
#`<`
#<<<#>>]}}+-[.+..]+-+<[<<.>>x>-]>[
#{
#x}
#2""/*\*
#=x<R+++++[D>+++++++q   L+++<-][pPLEASE,2<-#2FAC,2SUB#1<-#52FAC,2SUB#2<-#32FACREADOUT,2PLEASEGIVEUPFACs]>@@+.---@.>][
#x%+>+=ttt Z_*.
#D>xU/-<+++L
#R+.----\   \).>]4O6O@|
#[#[(?2?20l0v01k1kMoOMoOMoOMoO MOO0l0ix0jor0h0h1d111x0eU0y0yx0moO1d0y0e0e00m1d0i0fx0g0n0n11MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOmOoMOo0moo0n0tx0t0moO0f0t0gOOM0g0f0h0j0j0i0001k1x0vx0v0l111111^_0 )0\\
[  "]56p26q[puts 59][exit]" ,'\[999'];#/s\\/;print"24";exit}}__DATA__/
###x<$+@+-@@@@=>+<@@@=>+<?#d>+.--.<!\
'(wWWWwWWWWwvwWWwWWWwvwWWWw WWWWWWWWwWW/"78"oo@WWwWWWWWWWwWWWWWWWWwwwwvwWWWwWWWWwvwWWwWWWwvwWWwWWWwvwWWwWWWw              (([5]{})))â\';';print((eval("1\x2f 2")and 9or 13<< (65)>>65or 68)-(0and 4)^1<<(65)>>62)or"'x"or' {}{}{}{}({}<(((((()()())){}{})){}{})>)(({})5){}x{(x<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)wWW no no no no no no no no no no no no no no no no no no no no no no no no no no no no no no os sp '#}#(prin 45)(bye)46(8+9+9+9+9+=!)((("3'3)))"'a'[[@*3*74[?]*]*(<*.*\>]xxxxxxxxxxxxx)'# \\
__DATA__=1#"'x"
#.;R"12"'
###;console.log 39;'(******* **********819+*+@[*99[?]*]***|!)'
#\\
""""#\
' ( <><        (          )>  ){ ({}[()]  )}{\';      a=$(printf \\x00    );b=${#a};#\\
" }"';           ((   ( (';case "{"$ar[1]"}"${b} in *1)echo 54;;*4)echo 78;; *1*)echo 50;;*)echo 58;;esac;exit;# (((('))))#\
=begin
#p             +555/2+55x%6E2x
;set print "-";print 89;exit#ss 9
utpb now 70 dollar off!
utpb has been selling out worldwide!
#9999 9 seeeemPaeueewuuweeeeeeeeeeCis:ajjappppppp😆😨😒😨💬95💬👥➡
👋🔢🌚🌝🌝🌚🌚🌚🌚🌚

set ! 57
set ! 51
More 91 of thiset of re9
How much is it*/
#if 0
.int 2298589328,898451655,12,178790,1018168591,84934449, 12597
#endif//*
#1"" //*
#include<stdio.h> 
#defineâ x(d)â#d
#define u8 "38\0 "
main ( ) {puts( sizeof (0,u8)-5?u8"67":*u8""?"37":     x( 0'0  "'\"")[9]?"75":'??-'&1? "79":"77");"eg5""6 27""e ' Zing  ";}//*/
#if 0
#endif//* --... ...--
/*/
p=sizeof("9( 999 99\"    ); print'(''72'')';end!"            );main( ){puts(  "92");return(9-9+9 -9);}
#if 0â
#endif//* rk:start | print: "69" rk:end<(9    >5b*:,1-,@
print 61
#}
disp 49 ;9;
#{
}{}<>
$'main'3
#-3o4o#$$$
#<T>"3"O.</+++++++>/+++<-\>+++.---.
#<<<#>>> /
reg end="";print(85);reg s#++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-.
=end
;"""#"#xxxxxxxy"78"\++++>/<~#class P{        function:Main(a:String[] )~Nil{83->Print();} }
#}pS9^7^8^MUOUOF@:8:8\\
#s|)o51~nJ;#:p'34'3  \=#print(17)#>27.say#]# print(47) #]#echo 21#fwwwwwWWWwWWWWWwWWWWWWWwWWWWWWWWWwWWWWWWWWWWWWWWWwWWWWWWWWWWWWwvm>++++
#s8âdggi2âM`|$//''  1$6~-<~-<~-<<<~-COprint ("65")#asss^_^_#
#9 "25"  +/ *///X222999686#

वीआईपी स्कोर ( वर्सटाइल इंटेगर प्रिंटर ): .002953 (सुधार करने के लिए, अगली प्रविष्टि 3042 बाइट्स से अधिक नहीं होनी चाहिए)

मंद होना

यह कार्यक्रम 1 पायथन 3 में 2 , V / Vim में 2 , मिंकोलंग में 3 , 4 में <<>, 5 में पायथन 2, SMBF में 6 , जाप में 7 , रेटिना में 8 , पर्ल में 9 , पर्ल 5 में 10 , Befunge में 10 प्रिंट करता है। 93, 11 Befunge-98, में 12 विखंडन में, 13 रूबी में, 14 Turtlèd में, 15 Haystack में, 16 Pyth में, 17 जूलिया में, 18 कार्डिनल में, 19 Reng में, 20 प्रस्तावना में, 21निम, में 22 लादना में, 23 कॉफ़ीस्क्रिप्ट में 40 मिनिमल -2 डी में, 41 ब्रेनफॉक में, Hexagony, में 24 Thutu में, 25 पिप में, 26 05AB1E में, 27 पर्ल 6, में 28 ब्रेन-आलोचना में, 29 उत्प्रेरक में, 30 श्वेत रिक्ति में, 31 मॉड्यूलर SNUSP में, 32 चक्कर में, 33 घटना में, 34 रेल में , 35 INTERCAL, में 36 Labyrinth में, 37 में सी ++ 03, 38 C99, में 39 CoffeeScript में, 42 बुराई में, 43 जालीदार में, 44 alphuck में, 45 PicoLisp में, 46 Cubix में, 47 लिली में, 48 Deadfish ~, में 49 सप्टक में, 50 बैश में, 51 विधानसभा में, 52 गाय में, 53 भगाओ, 54 Zsh, में 55 ब्रेन-आलोचना क्लासिक में, 56 डीसी में, 57 वार में, 58 KSH में, 59 Tcl में, 60 Moorhens में, 61 संग्रह के, 62 घास में, 63ब्रायन और चक, में 64 पीड़ा में, 65 ALGOL 68, में 66 भूतल में, 67 सी 11 में, 68 पायथन 1, में 69 rk-लैंग में, 70 वाणिज्यिक में, 71 क्या में, 72 फोरट्रान में, 73 मोर्स में, 74 आर्चवे में 75 , सी ++ 11 में, 76 ट्रेफ्यूज -98 में 77 , सी ++ 14 में 77 , डैश में 78 , सी ++ 17 में 79 , क्लेन 201 में 80 , क्लेन 100 में 81 , ब्रेन-फ्ल्यू में 82 , ओबेक में 83 , 84 क्लेन 001, में 85 ZKL में, 86 Miniflak में, 87 एलिस इन, 88 PingPong में, 89 gnuplot में, 90 RunR में, 91 Cood में, 92 । ब्रेनबुल में 100C89 में, सेट में 93 , Emotinomicon में 94 , Emoji में 95 , EmojiCoder में 96 , मूल रूप से 97 , Archway2 में 98 , 99 में 99

सत्यापन

इसे ऑनलाइन आज़माएं! टीआईओ पर उपलब्ध भाषाएँ:

व्याख्या

मुझे विश्वास नहीं हो रहा है कि हमने इसे 100 भाषाओं में बनाया है। मैं बस इस प्रक्रिया में शामिल सभी को धन्यवाद देने के लिए समय निकालना चाहूंगा। यह एक मजेदार सवारी है और मुझे उम्मीद है कि आप लोगों के साथ 100 और जुड़ेंगे।

कुछ समय से ब्रेनबुल मेरी नजर में है। हालाँकि चूंकि ब्रेनबुल केवल दो संख्याओं का उत्पादन कर सकता है, 1और 0मैं इसे अब तक जोड़ नहीं पाया हूं (मैं 10 और 11 के आसपास नहीं था)।

ब्रेनबुल ब्रेनफैक की तरह है, केवल 256 पर लपेटने के बजाय 2 पर लपेटता है। ब्रेनबुल भी नहीं है -क्योंकि यह इसके साथ बेमानी है +। हमारा ब्रेनबुल कोड 100 आउटपुट के लिए काफी सरल है:

+.+..

ब्रेनफॉक के लिए आउटपुट मास्क करने के लिए हम एक लूप और एक माइनस जोड़ते हैं:

+-[.+..]

अब सभी आवश्यक वस्तुओं को कोड में जाने के लिए जगह ढूंढनी है। मेरी पसंद का स्थान +लाइन 8 पर ब्रेनफॉक कोड के शीर्ष स्तर पर पहला था। प्लस में स्थानापन्न करने के लिए हमने अपना कोड जोड़ा और +-+जो +ब्रेनफॉक में और ब्रेनबोल में एक नॉओप के रूप में कार्य करता है ।

+-[.+..]+-+

Cubix

मैंने अपना कोड क्यूबिक्स कैप्सूल से पहले रखा था, जिससे एक दर्पण पॉइंटर के रास्ते में चला गया। इसे ठीक करने के लिए मैंने कैप्सूल को आपत्तिजनक दर्पण के सामने कुछ कदम आगे बढ़ाया और सब ठीक हो गया।

हैरानी की बात यह है कि इस घटना को भी नहीं देखा।

— श्रीओटचिलिज्म ओ'जैसिक
स्रोत
असल में, ब्रेनबुल अरिबल टेक्स्ट को आउटपुट कर सकता है। यदि आप इसे -bतर्क पास करते हैं, तो यह बाइट्स में 1s और 0s का निर्माण करेगा और फिर वर्ण के रूप में आउटपुट करेगा।
— पावेल
1
@WheatWizard मैं पुष्टि करता हूं कि यह Archway2 में काम करता है।
— stasoid
1
बधाई! मैं वीआईपी स्कोर को सिर्फ 0.003 के तहत ही गिराता हूं।
— अर्जन जोहान्सन
1
मुझे कबूल करना है, जब आप मूल रूप से 100/101 के लिए इसे जोड़ने के बारे में पोस्ट करते हैं, तो मुझे नहीं लगता था कि हम कभी यहां पहुंचेंगे। यह काफी खतरनाक है।
— SnoringFrog
1
@stasoid मैं केवल वित्तीय वर्ष, TIO पर Archway प्राप्त करने पर काम कर रहा हूं।
— एमडी एक्सएफ
21

27. पर्ल 6 , 235 बाइट्स

#v`16/"<"6/b.q@"(::):::  (22)S#;n4"14"
#>3N6@15o|> ^*ttt*~++~~~%
#=~nJ<R"12";
#[
#`<`|
print((eval("1\x2f2")and 9 or 13)-(0and 4)^1<<65>>62)#@46(8+9+9+9+9+=!)=#print(17)#3]#echo 21#===2|/=1/24=x=90/
#8␛dggi2␛` |1|6$//''25  #>say 27#"26

␛ हमेशा की तरह एक शाब्दिक ईएससी चरित्र का प्रतिनिधित्व करता है।

इस कार्यक्रम के प्रिंट 27 पर्ल 6 में , 26 05AB1E में , 25 पिप में , 24 Thutu में , 23 Hexagony में , 22 लादना में , 21 निम में , 20 प्रस्तावना में , 19 Reng (परीक्षण किया में यहाँ ), 18 कार्डिनल में , 17 में जूलिया , 16 Pyth में , 15 Haystack में , 14 Turtlèd में , 13 रूबी में ,12 विखंडन में।, 11 Befunge-98 में , 10 Befunge-93 में , 9 पर्ल 5 में , 8 रेटिना में , 7 Japt में , 6 SMBF में , 5 अजगर 2 में , 4 में> <> , 3 Minkolang में , 2 विम / वी में , 1 अजगर 3 में , और (यह रूप में क्रिसमस) a partridgeमें एक नाशपाती के पेड़

इस जवाब के लिए स्टैक एक्सचेंज द्वारा उत्पन्न सिंटैक्स हाइलाइटिंग पूरी तरह से गलत है। #`<पर्ल 6 के कई मल्टीलाइन टिप्पणी मार्करों में से एक है, और #>इस प्रकार समाप्त होता है , इस प्रकार एकमात्र कोड जो वास्तव में पर्ल 6 में चलता है, बहुत सरल है say 27। मैंने इस विशेष टिप्पणी मार्कर को चुना क्योंकि <>अधिकांश भाषाओं में मेल खाने वाली जोड़ी नहीं है, और इस प्रकार बेजोड़ <भाषाएं जैसे रेटिना को नहीं तोड़ेंगी, जो इसे पार्स करने का प्रयास करती हैं।

मुझे पूरी तरह से यकीन नहीं है कि हेक्सागोनी किसी भी अधिक कैसे काम करता है। जब इसे तोड़ दिया, मैं वर्ण यह एक से उपयोग कर रहा था में से एक को बदल दिया +एक करने के लिए 0अगर यह मारा जा रहा था देखने के लिए; यह पता चला है, और यह तय कार्यक्रम को बदल देता है, लेकिन मुझे यकीन नहीं है कि क्यों (मुझे पता है कि यह #निष्पादन की रेखा के कारण टूट गया है , लेकिन यह स्पष्ट नहीं है कि क्यों +फिक्स चीजों को हटा रहा है )। (विचाराधीन चरित्र भी थुटू द्वारा पार्स किया गया है, लेकिन सौभाग्य से इससे थुटू कार्यक्रम के कामकाज पर कोई फर्क नहीं पड़ता, जैसा कि कार्यक्रम में उस बिंदु पर, कुछ भी जो पहले से नहीं है= को शाब्दिक रूप से काम में कॉपी है। स्ट्रिंग।) ध्यान दें कि 0and+4पिछली पंक्ति से बन गया0and 4, हेक्सागोनी के दृष्टिकोण से एक चरित्र को छोटा बनाने के लिए (हेक्सागोनी रिक्त स्थान नहीं देखता है); यह #|एक पिछली पंक्ति के बनने की भरपाई करने के लिए है#`<`|, जो हेक्सागोनी के दृष्टिकोण से एक वर्ण लंबा है (क्योंकि यह या तो बैकक्वाटर नहीं देखता है)। ध्यान दें कि कोड की अब केवल पांच बाइट्स हेक्सागोनी साइड की लंबाई का विस्तार करने और वर्तमान हेक्सागोनी कोड के बारे में सब कुछ तोड़ने से दूर है। मैं वैसे भी ऐसा करने की सिफारिश करूंगा और कोड के हेक्सागोनी अनुभाग को फिर से तैयार करूंगा; एक विस्तार के बाद सब कुछ फिट करने के लिए यह कठिन होने के बजाय शायद आसान होगा।

कुछ अन्य भाषाओं में भी बदलाव आया, जिनमें से ज्यादातर में पर्याप्त मजबूती थी कि मैं अंतिम पंक्ति में मनमाना कोड फिट कर सकूं। $//Japt में एक टिप्पणी मार्कर है जो बाद में लाइन पर रिक्त स्थान की अनुमति देता है, जोड में जोड़े गए प्रोग्राम को कम नाजुक बना देता है (इस बीच, इस प्रकार रेटिना के लिए है); यह पिछली प्रविष्टि में संबंधित पंक्ति से अलग तरीके से पार्स करता है, लेकिन एक तरह से यह उपयुक्त है। कार्डिनल भी पिछली प्रविष्टियों की तुलना में बहुत सरल है, लेकिन यह सिर्फ शुद्ध संयोग है कि कैसे सब कुछ लंबवत रेखाओं के साथ होता है, और परिवर्तन कोड के लिए है जो वैसे भी कुछ नहीं करता था।// यदि लाइन पर बाद में कोई समापन कोष्ठक हैं तो टूट जाता है और स्थान Japt में एक प्रकार का कोष्ठक बंद कर देता है)। रिक्त स्थान की एक जोड़ी पिप में एक टिप्पणी मार्कर है, जिसका अर्थ है कि पिप कोड को यहां काफी सरल बनाया जा सकता है। इसका अर्थ यह भी है कि हम 05AB1E को एक तुच्छ के लिए सरल बना सकते हैं "26। रेटिना को पांचवीं पंक्ति की जरूरत है कि वह एक कानूनी रेक्सक्स हो जो मिलान वाली चीजों (अनुगामी) पर अच्छा हो|

मान लें कि आप Hexagony फिर से करना (आप शायद करना होगा), सुरक्षित स्थानों पिछले तीन लाइनों के सभी पर कोड जोड़ने के लिए देखते हैं: 3में #3]#केवल Hexagony के लिए है (और आसानी से बदला); अंतिम पंक्ति पर #और उसके बीच का स्थान "भाषाओं के विशाल बहुमत द्वारा अनदेखा किया जाता है; और रेटिना के अलावा पांचवीं पंक्ति के अंत में कुछ भी नहीं है। (बहुत सारे अन्य स्थान हैं जहां कोड को जोड़ा जा सकता है, बहुत अधिक, लेकिन ये संभवतः सबसे सुविधाजनक हैं।)

— mbomb007
स्रोत
1
मैंने गलती से इस उत्तर को अस्वीकार कर दिया था और मैंने देखा कि जब मैंने अपने प्रतिनिधि को नीचे देखा था तो मैंने उसे 1. घटा दिया। क्या आप उत्तर को संपादित कर सकते हैं ताकि मैं अप-डाउन कर सकूं? : D
— betseg
4
@ बेत्सेग: मैंने हेक्सागोनी की थोड़ी और चर्चा की, बस आपके लिए।
2
इनाम पर बधाई! मैं इस पोस्ट को फिर से आगे बढ़ाना चाहता था: P
— FlipTack
मैं इसे उम्र के लिए जारी रखने की योजना बना रहा था, यह समय खोजने की कोशिश करने का एक मामला था। (मैं वास्तव में कुछ समय पहले पर्ल 6 में एक असफल प्रयास किया था, पहले श्रृंखला में, और इसे पोस्ट नहीं किया क्योंकि यह काम नहीं किया। सौभाग्य से, मैंने गलतियों से सीखा और यह इस समय काम करता है।)
21

31. मॉड्यूलर एसएनयूएसपी , 326 बाइट्स

कार्यक्रम

#v`16/"<"6/b.q@"(: ::T):  ␉␉␉␉ :(22)S#;n4"14"
#>3N6@15o|>␉^*ttt*~++~~~%
#=~nJ<R"12"; ␉
#[␉
#`<`|
print((eval("1\x2f2")and (9)or(13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{}[()])}\{})(\{}\{})'#46(8+9+9+9+9+=!)=#print(17)#]#echo 21#|/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
#8␛dggi2␛␉` |1|6$//''25  #>say␉␉ 27#T222999+/+23!@"26

हमेशा की तरह, ␛एक शाब्दिक ESC चरित्र है और ␉एक शाब्दिक टैब है।

मंद होना

इस कार्यक्रम के प्रिंट 31 मॉड्यूलर SNUSP, में 30 व्हाइटस्पेस में, 29 उत्प्रेरक में, 28 ब्रेन-आलोचना में, 27 पर्ल 6, में 26 05AB1E में, 25 पिप में, 24 Thutu में, 23 Hexagony में, 22 लादना में, 21 निम में , प्रील्यूड में 20 , रेंग में 19 , कार्डिनल में 18 , जूलिया में 17 , पायथ में 16 , हेस्टैक में 15 , टर्टलड में 14 , रूबी में 13 , विखंडन में 12 ,11 Befunge-98, में 10 Befunge -93, में 9 पर्ल 5 में, 8 रेटिना में, 7 Japt में, 6 SMBF में, 5 अजगर 2, में 4 > <> में, 3 Minkolang में, 2 वी में / विम, और 1 अजगर 3 में।

सत्यापन

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

उन्हें ऑनलाइन कोशिश करो!

लिंक भी ऊपर देखा ␛/ ␉-रूपित कोड ब्लॉक का उत्पादन करता है, और आपके लिए हेक्सागोन में कोड को प्रारूपित करता है:

          # v 1 6 / " < " 6 / b
         . q @ " ( : : : T ) : :
        ( 2 2 ) S # ; n 4 " 1 4 "
       # > 3 N 6 @ 1 5 o | > ^ * t
      t t * ~ + + ~ ~ ~ % # = ~ n J
     < R " 1 2 " ; # [ # < | p r i n
    t ( ( e v a l ( " 1 \ x 2 f 2 " )
   a n d ( 9 ) o r ( 1 3 ) ) - ( 0 a n
  d 4 ) ^ ( 1 ) < < ( 6 5 ) > > 6 2 ) o
 r ' ( \ { ( \ { } ) ( \ { } [ ( ) ] ) }
\ { } ) ( \ { } \ { } ) ' # 4 6 ( 8 + 9 +
 9 + 9 + 9 + = ! ) = # p r i n t ( 1 7 )
  # ] # e c h o 2 1 # | / = 1 / 2 4 = x
   = 9 [ < $ + @ + - @ @ @ @ = > + < @
    @ @ = > + < ? # > + . - - . ] / #
     8 . d g g i 2 . | 1 | 6 $ / / '
      ' 2 5 # > s a y 2 7 # T 2 2 2
       9 9 9 + / + 2 3 ! @ " 2 6 .
        . . . . . . . . . . . . .
         . . . . . . . . . . . .
          . . . . . . . . . . .

तीन भाषाएँ गायब हैं: V बहुत धीमी है, और RIO और मॉड्यूलर SNUSP TIO पर स्थापित नहीं हैं। सौभाग्य से, तीनों में ऑनलाइन दुभाषिया हैं:

  • : आप / विम (2 इरादा उत्पादन) वी में कार्यक्रम का परीक्षण कर सकते यहाँ TIO पर।
  • यहां एक ऑनलाइन रेंग दुभाषिया (इरादा आउटपुट: 19) है ।
  • यहां एक ऑनलाइन मॉड्यूलर एसएनयूएसपी दुभाषिया (इरादा आउटपुट: 31) है । (यह सिर्फ एक SNUSP दुभाषिया के रूप में विज्ञापित है, लेकिन मॉड्यूलर SNUSP वह बोली है जो वास्तव में लागू होती है, जैसा कि @पूरे पृष्ठ के संकेतों द्वारा देखा जाता है ।)

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

व्याख्या

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

अन्य सभी परिवर्तन मॉड्यूलर एसएनयूएसपी कोड के अतिरिक्त के साथ करना है। ध्यान देने वाली पहली बात यह है कि एसएनयूएसपी $कार्यक्रम के पहले चरित्र पर अमल करना शुरू कर देता है, और एक 2 डी लैंगगॉज है जो प्रोग्राम के किनारे से जाने के बाद बाहर निकलता है, और इस तरह एसएनयूएसपी प्रोग्राम को लंबी लाइन के अंत में रखकर (अंदर) Thutu कोड, एक बिंदु पर जहां Thutu लगभग कुछ भी स्वीकार करेगा), हम यह सुनिश्चित कर सकते हैं कि SNUSP अन्य भाषाओं से कोई कोड नहीं देखता है, और अधिकांश अन्य भाषाएँ SNUSP के बारे में परवाह नहीं करेंगी। एक भाषा है कि किया देखभाल पर्ल 6, जो कोण कोष्ठक को पार्स है था, मैंने <इसे खुश रखने के लिए एसएनयूएसपी कोड के ठीक पहले रखा (क्योंकि कोष्ठक स्वाभाविक रूप से लगभग वैसे भी मेल खाते थे)। दूसरी भाषा जो SMBF की देखभाल करती है;.SMBF और SNUSP दोनों में आउटपुट, और हम अतिरिक्त आउटपुट नहीं बनाना चाहते हैं। सौभाग्य से, जैसा कि एसएमबीएफ द्वारा देखा गया है, इस कार्यक्रम के<.>>[…] एसएनयूएसपी कोड के बाद, अर्थात वर्तमान टेप तत्व 0. है। इसलिए एसएनएफएफ के दृष्टिकोण से वर्ग कोष्ठक में एसएनयूएसपी कोड को "टिप्पणी" इसे बाहर करना "संलग्न है।

कोड के लिए के रूप में, यह मॉड्यूलर SNUSP में स्थिरांक लिखने के लिए एक प्रसिद्ध चाल का उपयोग करता है जिसमें आप एक पंक्ति में बहुत सारी "प्रक्रिया शुरू" आदेश लिखते हैं और प्रभावी ढंग से आधार-फाइबोनैचि संख्या का एक प्रकार बनाते हैं। मूल विचार यह है कि +संख्या 1 को एनकोड करता है; @इसके बाद कोड द्वारा दर्शाई गई संख्या को एक साथ जोड़ता है, और इसके पहले वर्ण को घटाकर कोड द्वारा दर्शाई गई संख्या; और =एक नो-ऑप है (इस प्रकार @=इसके दाईं ओर संख्या दोगुनी हो जाएगी)। इस प्रणाली में, मैंने @@@@=+@@@=+#संख्या 48 के प्रतिनिधित्व के रूप में चुना ।

हालांकि यहाँ एक समस्या है; एसएनयूएसपी में स्थिरांक लिखने की मानक विधि कार्यक्रम की शुरुआत के पीछे नियंत्रण प्रवाह को छोड़ देती है, और एक ऑनलाइनर के साथ (जो मैं स्पष्ट कारणों के लिए यहां लिखना चाहता था), आईपी को किसी भी दिशा में इंगित करने के लिए सही लेकिन बदलने का कोई तरीका नहीं है। इसका मतलब है कि हम किसी भी तरह से आईपी को पाने के लिए पूरी तरह से निरंतर परिभाषा को पारित करने और सही करने के लिए जारी रखने वाले हैं, कार्यक्रम से बाहर निकलने के बिना (जो #सामान्य रूप से करेंगे)। इसे हल करने के लिए, मैंने सावधानी से उस संख्या की परिभाषा का उपयोग किया जिसके लिए +हमेशा से पहले था =। इसका मतलब यह है कि मैं दूसरी सेल को 48 पर सेट करने के लिए कोड लिख सकता हूं @@@@=>+<@@@=>+<#, इस ज्ञान में सुरक्षित हूं कि कोई भी >कमांड एक द्वारा छोड़ दी जाएगी@कमांड (और इस प्रकार हम टेप पॉइंटर का नियंत्रण रखते हैं)। इसके अतिरिक्त, हम जानते हैं कि फाइनल में #, पहले टेप सेल का अभी भी प्रारंभिक मूल्य होगा। इसलिए, हम पहले टेप सेल का उपयोग मार्कर के रूप में यह जानने के लिए कर सकते हैं कि क्या प्रक्रिया की परिभाषा से वापस लौटना है या क्या सही को जारी रखना है (हम ऐसा करते समय प्रक्रियाओं के एक टन के अंदर हैं, लेकिन हम प्रोग्राम को बंद करके बाहर निकल जाते हैं किनारे ताकि यह कोई फर्क नहीं पड़ता)।

इसलिए, अंतिम SNUSP कोड है $+@+-@@@@=>+<@@@=>+<?#>+.--.। $निशान कार्यक्रम की शुरुआत। +@+-पहले टेप तत्व को 1 पर सेट करता है ( ++-लेकिन, एक बार जब प्रक्रिया @रिटर्न के साथ शुरू होती है, तो यह कोड को -आगे से चलाना शुरू कर देगा , इस प्रकार टेप तत्व को वापस 0 पर सेट करना होगा। ?#प्रक्रिया केवल तभी समाप्त होती है जब पहला टेप तत्व नॉनजरो हो; इस प्रकार; हम अंततः #50 टेप सेट करने के बाद अंत में समाप्त होते हैं (निरंतर परिभाषा से 48, प्लस 2 के साथ प्लस 2, >+<जब बाद में दाईं ओर जा रहे हैं)) तो हम सभी >+.--.को ASCII कोड 51 ( 3) का उत्पादन करने की आवश्यकता है। 49 ( 1), और कार्यक्रम के किनारे से गिर जाते हैं ( ]एसएनयूएसपी में एक सेशन नहीं है, और /नियंत्रण प्रवाह को लंबवत रूप से दर्शाता है ताकि यह कार्यक्रम के शीर्ष किनारे से निकल जाए); यह बिट समझदारी से काम करता है।

20

11. Befunge 98 , 102 बाइट्स

#v;2^0;7||"<+0+0+0+<;n4
#v0#_q@
#>3N.
#|\w*
#8  ^1b0<
#|
#M`
print(None and 9or 1/2and 1or 5)
#jd5ki2

प्रिंटों:

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

स्पष्टीकरण:

#v          Skips the v, which would send the IP down
  ;         Unlike '93, where ; is a no-op, '98 skips to the next ;
            and doesn't execute anything in between
   2^0;     Not executed, unlike Befunge 93
       7|   Pushes 7 onto the stack, and then sends the IP up, because 7 is not 0
n0b1        n clears the stack, and #s are pushed until the stack is [0, 11, 1
    *.      multiplies the top 2 values of the stack to give 11, and prints it (yay!)
      _     Sends the IP right, because the top value of the stack is 0
       q    Ends the program (no-op for '93, which continues to @)

ध्यान देने योग्य बातें:

  • 0के बगल में bकोड की वर्तमान स्थिति में सख्ती से आवश्यक नहीं है, और ढेर मंजूरी दे दी है। यदि आवश्यक हो तो इसे हटाया जा सकता है, लेकिन भविष्य के संभावित कार्यक्रम के हिस्से के रूप में अन्य स्टैक हेरफेर के लिए अनुमति देता है।
  • _q@(यह इसके बिना काम नहीं करता, मुझे मत पूछो क्यों) रेटिना के हिस्से के रूप होती है। इसके अलावा q'98 कोड को एक tऑपरेशन चलाने देता है , जो आईपी को विभाजित करता है (7 के बजाय रेटिना प्रोग्राम प्रिंट 8 बनाने के साथ)
  • यह _एक सरल नहीं है >क्योंकि यह SMBF भाग को गड़बड़ कर देगा।

संपादित करें: बस एहसास हुआ कि भविष्य में कार्यक्रम को और अधिक लचीला बनाने के लिए _q@संभवतः @00(जहां 0s ~ कोई भी हो सकता है) होना चाहिए। हालांकि मैं अभी सभी लिंक बदलने के लिए बहुत आलसी (और थका हुआ) हूं। अंततः इसके आसपास मिलेगा ...

संपादित करें 2: मुझे यह जल्दी से 6 और उत्तर की उम्मीद नहीं थी। मुझे लगता है कि यह जैसा है वैसा ही रह रहा है। सभी को महान काम!

— MildlyMilquetoast
स्रोत
हे, मैंने अपना 11 वां उत्तर लिखा था, केवल यह महसूस करने के लिए कि यह पहले ही पोस्ट किया जा चुका था, अब मैंने इसे 12 वें उत्तर में बदल दिया :)
— गायों का निधन
कोई भी विचार क्यों विम को निष्पादित करने में इतना समय लगता है?
— MildlyMilquetoast
@ मिस्तफिग्गिन्स मुझे लगता है कि यह इसलिए है क्योंकि कोड को कीस्ट्रोक्स में बदलना है, लेकिन इसके अलावा, मुझे कोई सुराग नहीं है
— गायों का कोक
मैंने लिखा है कि विम दुभाषिया, और मुझे नहीं पता कि इसमें इतना समय क्यों लगता है। मैंने पहले कई प्रदर्शन मुद्दों पर ध्यान नहीं दिया है, लेकिन ऐसा इसलिए है क्योंकि मेरे V / Vim के अधिकांश उत्तर 40 बाइट्स से कम हैं। वास्तव में यकीन नहीं है कि यह क्या कारण है, लेकिन बहुत से लोग इस बारे में शिकायत कर रहे हैं।
— DJMcMayhem
20

35. इंटरसेल (C-INTERCAL), 631 बाइट्स

#v`16/"<"6/b.q@"(: ::Q):  ␉␉␉␉ :(22)S#;n4"14"
#>3N6@15o|>␉^*ttt*~++~~~%
#= >␉1#v#v0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#[␉
#`<`|
print((eval(" 1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or' (\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1111|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"␉*
""""#//
=begin␉//
$'main'//
#-3o4o#␉
=end   #//
"""#"#//
#0]#echo 21#/ (\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE) a
#   +/Jn~
#8␛dggi2␛`␉|1|6$//''25  >>>#>27.say# =#print(17)#$nd^_^_.]Q222999/+23!@1#"26

␉एक शाब्दिक टैब है, ␛एक शाब्दिक ईएससी चरित्र; स्टाॅक एक्सचेंज अन्यथा कार्यक्रम को समाप्त कर देगा। यदि आप इस पर काम करना चाहते हैं, तो मैं नीचे TIO लिंक के "इनपुट" बॉक्स से प्रोग्राम को कॉपी करने की सलाह देता हूं।

उन्हें ऑनलाइन कोशिश करो!

मंद होना

इस कार्यक्रम के प्रिंट 35 INTERCAL, में 34 रेल में, 33 घटना में, 32 चक्कर में, 31 मॉड्यूलर SNUSP में, 30 श्वेत रिक्ति में, 29 उत्प्रेरक में, 28 ब्रेन-आलोचना में, 27 पर्ल 6, में 26 05AB1E में, 25 पिप में , थुटु में 24 , हेक्सागोनी में 23 , अंडरलोड में 22 , निम में 21 , प्रील्यू में 20 , रेंग में 19 , कार्डिनल में 18 , जूलिया में 17 , पाइथ में 16 ,15 Haystack, में 14 Turtlèd में, 13 रूबी में, 12 विखंडन में, 11 Befunge-98 में, 10 Befunge -93, में 9 पर्ल 5 में, 8 रेटिना में, 7 Japt में, 6 SMBF, में 5 अजगर 2 में, 4 > <> में, 3 Minkolang में, 2 वी / विम में, और 1 अजगर 3 में।

सत्यापन

अधिकांश भाषाओं का परीक्षण ऊपर दिखाए गए परीक्षण चालक द्वारा किया जाता है। आप यहां रेंग और मॉड्यूलर SNUSP का परीक्षण कर सकते हैं ; आवश्यकतानुसार वे क्रमशः 19 और 31 का उत्पादन करते हैं। मैंने आधिकारिक दुभाषिया का उपयोग करते हुए अपने सिस्टम पर स्थानीय रूप से घटना का परीक्षण किया।

ध्यान दें कि मैंने छिपे हुए पात्रों को स्पॉट करना आसान बनाने के लिए परीक्षण चालक में कुछ बदलाव जोड़े; विभिन्न NUL बाइट्स कुछ भाषाओं में कार्यक्रम के आउटपुट में क्रेप थे। मैंने तय किया है कि यह शायद एक समस्या नहीं है, क्योंकि) क) सबमिशन की एक विस्तृत श्रृंखला इसे कर रही है, और बी) बीफुन्ज दुभाषियों को अतिरिक्त एनयूएल बाइट्स जोड़ना प्रतीत होता है, भले ही कार्यक्रम में कुछ भी नहीं निकलता है, जब तक कि मैं (जब तक कि मैं इसका मतलब नहीं हूं 'कुछ छूट गया), इसलिए यह युगों से चला आ रहा है और संभवतः इस बात का हिस्सा है कि दुभाषिया कैसे काम करता है। (ध्यान दें कि अभी भी NUL बाइट्स का उत्पादन करने वाली भाषाएँ - Befunges और Minkolang - ने इस सबमिशन के लिए अपना कोड नहीं बनाया है।)

पिछला रेल सबमिशन क्रैश के माध्यम से बाहर निकलता है, जिसे अस्वीकृत कर दिया जाता है, लेकिन यह आसानी से ठीक हो जाता है ( #रेल कार्यक्रम के अंत में जोड़कर और हेक्सागोनी को मिलान करने के लिए समायोजित) और इसलिए मैंने इसे एक बड़ी समस्या नहीं माना। इस समाधान में रेल सही ढंग से बाहर निकलती है।

व्याख्या

INTERCAL कोड कैसे काम करता है

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

इस प्रकार, हम प्रोग्राम को स्पष्ट रूप से बाहर निकालकर केवल चल रही फ़ाइल के अंत में कचरा रोक सकते हैं (कुछ भी जो किसी भी तरह से आवश्यक है, क्योंकि कार्यक्रम के अंत तक बिना किसी स्पष्ट निकास आदेश के पहुंच जाता है)। कार्यक्रम की शुरुआत को संभालना अधिक दिलचस्प है, और एक पार्सर बग का शोषण करता है। आप 20% संभावना के साथ DO %20 READ OUT #8आउटपुट के लिए कुछ लिख सकते हैं VIII(और अन्यथा कुछ भी नहीं)। जहाँ तक मैं बता सकता हूँ, C-INTERCAL दूसरी पंक्ति पर अकेला% पार्स करता है क्योंकि पहली कमांड के चलने के लिए 0% संभावना है, और इस प्रकार यह हर बार नहीं चलने पर लगातार समाप्त होता है। (मुझे यकीन नहीं है कि यह इसे इस तरह से पार्स क्यों करता है, लेकिन संकलित कोड को देखने से यह एक यादृच्छिक संख्या उत्पन्न करता है और इसकी तुलना 0.) करता है।

यहां बताया गया है कि बाकी पॉलीग्लॉट के चारों ओर फिट करने से पहले INTERCAL कार्यक्रम कैसे देखा जाता है:

DO,1<-#2
DO,1SUB#1<-#52
DO,1SUB#2<-#32
DOREADOUT,1
PLEASEGIVEUP

यह काफी सरल है: एक 2-तत्व सरणी को त्वरित करें; तत्वों को क्रमशः 52 और 32 (दशमलव) पर सेट करें (INTERCAL का स्ट्रिंग एन्कोडिंग सबसे अच्छा छोड़ दिया गया है; मैं भूल गया हूं कि यह कैसे काम करता है और यह पता लगाने के लिए विभिन्न प्रयोग करने थे कि ये संख्याएं क्यों सांकेतिक हैं 35); इसे मानक आउटपुट पर पढ़ें; और प्रोग्राम से बाहर निकलें। मैंने विनम्र बातचीत के लिए स्वीकार्य सीमा में रहते हुए, कार्यक्रम के अंत में कचरे के लिए एक नया बयान शुरू करते हुए, GIVE UP बयान को समाप्त करने के लिए अंत में एक अतिरिक्त कृपया जोड़ा। बेशक, तैयार उत्पाद में INTERCAL बिलकुल नहीं दिखता है; मैं समझाता हूँ कि हम क्यों जाते हैं।

Sतों के भार के तहत दफन

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

हालांकि, हमारे पास ^कार्यक्रम के अंत में दो अक्षर हैं, जो अंडरलोड कोड को निष्पादित करते हैं; इसलिए, Sअगर हम इसके बारे में कुछ नहीं करते हैं, तो वैसे भी निष्पादित होने जा रहे हैं। मैं इसे दूसरे चरित्र में बदल सकता था, लेकिन यह तय किया कि कोड की सुरक्षा करना आसान था ताकि यह अर्थहीन हो जाए। aअंडरलोड में एक स्ट्रिंग से बच जाता है (जिसका अर्थ है कि ^, स्ट्रिंग को निष्पादित करने पर, हानिकारक दुष्प्रभावों का उत्पादन करने के बजाय इसे फिर से अनसेक कर देगा)। हम पहले से ही एक है aमें sayपर्ल 6 कोड (जो कोड की इस व्यवस्था में, असंबंधित परिवर्तन की वजह से वास्तव में पर्याप्त है) में इस्तेमाल किया। हालाँकि, ताकि लोगों को उस पर भरोसा न करना पड़े, मैंने एक और जोड़ाaलाइन के अंत में (मुझे वैसे भी एक पात्र चाहिए था जो बनाने के लिए अन्यथा रिक्त स्थान दिखाई देगा, और क्योंकि हेक्सागोनी को पैडिंग की आवश्यकता है क्योंकि यह ध्यान दें कि हेक्सागोनी इस कार्यक्रम में तय करना काफी आसान था, और वास्तव में नहीं है; अलग से चर्चा की जरूरत है)। इसलिए अंडरलोड कोड थोड़ा कम नाजुक है जितना कि हो सकता था।

बहुत सारे काम और भ्रम की स्थिति से बाहर निकलें

आह, प्रस्तावना। आम तौर पर सबसे कठिन भाषा नहीं है, लेकिन यह निश्चित रूप से इस समय था। दो वास्तविक समस्याएं हैं: एक यह है कि एक लंबी लाइन पर अतिरिक्त कोष्ठकों को जोड़ने से प्रील्यू प्रोग्राम के नियंत्रण प्रवाह में गड़बड़ी होने का खतरा रहता है (जैसा कि वे एक whileलूप के बराबर बनाते हैं ), और एक बस उन्हें रोकने की समस्या है ऊपर खड़ी (जो लाइनों पर व्हॉट्सएप के सबसे अधिक यादृच्छिक घूमने के लिए जिम्मेदार है)। ध्यान दें कि व्हॉट्सएप ने मुझे कुछ परेशानी भी दी, लेकिन यह कार्यक्रम व्हॉट्सएप के दृष्टिकोण से पिछले एक के बराबर है, इसलिए यह "व्हॉट्सएप को तोड़ने के बिना प्रस्ताव को ठीक करें" का एक मामला था।

मुझे इस बात पर भी यकीन नहीं है कि प्रिल्यूड वास्तव में इस बिंदु पर कैसे काम करता है। इसके लिए कई फ़िक्सेस हैं, जैसे नीचे-बाएँ कोने के पास 0, लेकिन वे स्पष्ट रूप से उस तरह से काम नहीं करते हैं जैसे मैंने उन्हें इरादा किया था। (जूलिया कोड भी रेखा के नीचे तक जाकर समाप्त हो गया क्योंकि इसके printकथन में कोष्ठक से निपटना वास्तव में कठिन था।) शायद हमें अभी इसे एक रहस्य छोड़ना होगा।

विखंडन रिएक्टर में टूट

यद्यपि उपरोक्त परिवर्तन काफी सूक्ष्म समस्याओं के लिए थे, जिन्हें ठीक करना कठिन है, एक बहुत अधिक स्पष्ट समस्या है; DOREADOUTरेगेक्स से मेल खाता है R...O, और इस तरह विखंडन से चौथे चक्र पर अवांछित उत्पादन का उत्पादन होगा, जो कि अपेक्षित उत्पादन के उत्पादन के लिए पर्याप्त समय नहीं है 12। और INTERCAL में केवल एक निर्देश है जो आउटपुट का उत्पादन करता है (जब तक कि आप दुर्घटना को आउटपुट के रूप में नहीं गिनते)। इसके लिए एक फिक्स यह है कि व्हाट्सएप को आपस में जोड़ने की कोशिश की जाए READऔर OUTहमें आउटपुट को इंटरसेप्ट करने का समय दिया जाए, लेकिन इससे व्हॉट्सएप नाराज हो जाता है। इसलिए थोड़ी देर के लिए, मुझे लगा कि यह कार्यक्रम असंभव था; R, L, U, और Dविखंडन में संभावित रूप से चल रहा है समस्याग्रस्त कोड के सभी सक्षम सभी प्रवेश बिंदुओं रहे हैं, और, और INTERCAL कीवर्ड अपरकेस में होना चाहिए।

हालांकि, एक तय है, और एक काफी आश्चर्यजनक है। अंतर्राष्ट्रीयकरण के प्रयास के तहत, C-INTERCAL वास्तव में अंग्रेजी और लैटिन दोनों के समर्थन के साथ कई भाषाओं में कीवर्ड स्वीकार करता है। हम Sइस तरह से बच नहीं सकते , लेकिन हम बच सकते हैंO ; FACके लिए एक पूरी तरह से अच्छा विकल्प है DO, और इसी LEGERE EXतरह के रूप में एक ही बात का मतलब है READ OUT। (इस प्रकार कार्यक्रम अंग्रेजी और लैटिन के मिश्रण में समाप्त हो गया, लेकिन यह ठीक है; यह शायद ही किसी भी कम पठनीय बनाता है।) इस तरह, हम खुशी से नीचे दाएं कोने में विखंडन को पागल कर सकते हैं, और बस इसे किसी भी उत्पादन नहीं करने देते हैं। उत्पादन। हम इसके बजाय समाप्त करने के लिए वास्तविक विखंडन कोड को बदल सकते हैं*;, जो केवल एक धागे के बजाय पूरे कार्यक्रम को पूरा करता है; यह कोड काफी तेज़ी से चलता है, इसलिए यह कार्यक्रम से बाहर निकलता है इससे पहले कि सभी आवारा प्रवेश बिंदुओं को किसी भी नुकसान को करने का समय हो।

बुनना 6, पर्ल 6

अगली समस्या: पर्ल 6 टिप्पणियाँ मिलान <और द्वारा काम करती हैं >। INTERCAL का असाइनमेंट ऑपरेटर है <-। सौभाग्य से, यह अतिरिक्त उद्घाटन कोष्ठक जोड़ता है , इसलिए मैं सिर्फ कुछ क्लोजिंग ब्रैकेट्स को प्रोग्राम में एक अनपर्सड लोकेशन में रद्द करने के लिए जोड़ सकता था (इस मामले में पिप कोड के बाद)।

हालाँकि, मैं कार्यक्रम के व्हॉट्सएप बजट को बदलना नहीं चाहता था, लेकिन जूलिया कोड (प्रील्यूड के लिए) को स्थानांतरित करके अंतिम पंक्ति में एक अतिरिक्त स्थान जोड़ दिया गया; मुझे एक को कहीं से हटाना था। डबल स्पेस पिप में एक टिप्पणी मार्कर है, इसलिए मैं शायद ही उन्हें बदल सकता हूं; एकमात्र शेष विकल्प में जगह है say 27। पर्ल 5 गोल्फर्स तुरंत सोचते हैं "अच्छी तरह से बस करते हैं say+27" (एकाकी +अक्सर आश्चर्यजनक रूप से काम में आता है!), लेकिन दुर्भाग्य से यह वैध पर्ल 6 वाक्यविन्यास नहीं है।

हालांकि, हम क्या कर सकते हैं, sayफ़ंक्शन सिंटैक्स से विधि सिंटैक्स में बदलना है। पूर्णांक शाब्दिक विधियों का एक गुच्छा है, जिसमें से एक को प्रिंट करना शामिल है, इसलिए 27.sayसमान लंबाई का पूरी तरह से मान्य कार्यक्रम है।

ईमानदार बनें? वहाँ मत रहो

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

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

दुर्भाग्य से, वर्ग कोष्ठक रेटिना के लिए सार्थक हैं; यह देखता है […<-#…और कहता है "इससे कोई मतलब नहीं है, आप उस सीमा को नहीं बना सकते क्योंकि <पहले नहीं आता है #"। सौभाग्य से, यह रणनीतिक रूप से रखे गए बैकलैश के साथ आसानी से ठीक हो जाता है।

कार्यक्रम का केंद्र-बिंदु

यह अंतिम उत्तर हुआ, और यह शायद अब से बार-बार होने वाला है; विभिन्न तार तीन बार बेतरतीब ढंग से घटित हुए, और हादसे की दृष्टि से कार्यक्रम के केंद्र के आसपास स्थानांतरित हो गए।

संभालने के लिए सबसे जरूरी टोकन था 1#, जो तीन बार प्रकट होता है यदि आप इन परिवर्तनों को भोलेपन #= >␉1#से करते हैं : तीसरी पंक्ति की शुरुआत में __DATA__=1#, और echo 21#। यह समस्या क्यों है? क्योंकि 1#तीसरी लाइन पर इसके #vठीक बाद ओवरलैप होता है, और दो ओवरलैपिंग टोकन के कारण दोनों में से कोई भी गिनती नहीं करता है। और #vटोकन है जिसे हम इन्कॉर्ड प्रोग्राम से पहले कोड के बारे में बताते थे! मैंने 1#इसे कार्यक्रम के अंत के पास एक अतिरिक्त स्थान पर चुपके से तय किया (केवल तीन वर्ण इसका अनुसरण करते हैं); कार्यक्रम के उस हिस्से को पार्स करने वाली कोई भी भाषा इसके साथ कुछ भी नहीं करती है।

इससे निपटने के लिए विभिन्न अन्य समस्याग्रस्त टोकन थे। एक युगल एकल पत्र थे, Pऔर U; मैं से हादसा कोड में भराव नहीं-ऑप्स के एक जोड़े को बदलने के माध्यम से इन के साथ पेश xकरने के लिए Pया Uक्रमश: एक चौथाई प्रति दे रही है। विखंडन कोड में परिवर्तन *एक टोकन के रूप में निकलता है , लेकिन विशेष रूप से, यह सामान्य रूप से अलग-अलग विभाजित होता है, दो बार हादसा कोड से पहले और केवल एक बार दिखाई देता है। इसे हटाने के बजाय, इसलिए, मैंने इसका उपयोग आंशिक LEकोड में दिखाई देने वाले नए टोकन को आंशिक रूप से संतुलित करने के लिए किया । यह कार्यक्रम के केंद्र को वापस ड्राइव करने के लिए पर्याप्त है0oटोकन। बेशक, कार्यक्रम में बदलाव से इसे परेशान करने की काफी संभावना है। (TIO पर इंसीडेंट पाने की मेरी कोशिश libdivsufsort के वहां उपलब्ध नहीं होने के कारण विफल रही, इसलिए ऐसा लग रहा है कि हम एक नए दुभाषिया से लाभान्वित हो सकते हैं, विशेष रूप से जावास्क्रिप्ट में ताकि यह ऑनलाइन चल सके। यदि आप रुचि रखते हैं, तो इस पर एक नज़र डालें। प्रश्न ।)

— समुदाय
स्रोत
1
वाह, यह चुनौती आश्चर्यजनक रूप से लंबी हो गई है। अच्छा काम!
— माइल्डलीवेटकास्ट
लैटिन ?! वाह, क्या बढ़िया हल है! मुझे पसंद है कि कोड कहता है कि 'कृपया छोड़ दें'। यह ऐसा है जैसे यह मुझे छोड़ने की हिम्मत कर रहा है।
— संभावना
19

1. पायथन 3 (8 बाइट्स)

print(1)

यह कार्यक्रम पायथन 3 में 1 प्रिंट करता है ।

पायथन 3 के साथ इसे शुरू करना क्योंकि मुझे पता है कि यह पॉलीग्लॉट्स के लिए अच्छा है और इसे कई अलग-अलग दिशाओं में ले जाया जा सकता है (साथ ही, मैं यह सुनिश्चित करना चाहता था कि पहला उत्तर एक अपेक्षाकृत सामान्य भाषा में था, बजाय एक बेतुका एसोलैंग के जो पॉलीग्लॉट के लिए कठिन है। साथ में)।

क्या 2 भाषा के लिए एक अच्छा विकल्प होगा (ताकि हम 2d स्थान शुरू करें)?
— गाय
तो इसका मतलब है कि अगला उत्तर 9 बाइट्स से अधिक नहीं हो सकता है? यह वास्तव में एक दूसरे के साथ आने के लिए मुश्किल होने वाला है।
— DJMcMayhem
1
@DJMcMayhem प्रत्येक उत्तर में 20% या 20 बाइट्स (जो भी बड़ा हो) से अधिक नहीं होना चाहिए
— गायों का क्षय
19

10. Befunge , 95 बाइट्स

#v02^0;7||"<+0+0+0+<;n4
#v0#@00
#>3N.
#|\w*
#8
#|
#M`
print(None and 9or 1/2and 1or 5)
#jd5ki2

अंतिम पंक्ति के बीच jऔर d(grr, @ ais523) पर शाब्दिक ESC वर्ण है । यह इस कोड में शामिल नहीं है। वास्तविक कोड प्राप्त करने के लिए, कृपया Try it onlineलिंक पर जाएं।

यह प्रिंट 1 अजगर 3, में 2 विम में, 3 Minkolang में, 4 <> में <, 5 अजगर 2, में 6 SMBF में, 7 Japt में, 8 रेटिना में, 9 पर्ल में, और 10 Befunge में।

यह कोड *रेटिना के .साथ और मिंकोलंग और एसएमबीएफ के साथ साझा करता है।

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

व्याख्या

वास्तविक कार्यक्रम

#v02^
    @
    .
    *



    t
    5
#v02^

अंतिम पंक्ति स्पष्टता के लिए लिखी गई थी ( Befunge खेल का मैदान चक्रीय है।)

#

ट्रम्पोलिन, स्कीप v

02^

पुश करें 0और फिर 2स्टैक में जाएं और ऊपर जाएं।

5t*.@

पुश 5, नो-ऑप, स्टैक ( 2और 5), प्रिंट, एंड प्रोग्राम में दो तत्वों को गुणा करें ।

— जंगवान मिन
स्रोत
1
यह SMBF को पहली बार एक नल बाइट प्रिंट करता है .।
— पुरकाकूदरी
@ Pietu1998 तय!
— जंगहवान मिन
अरे, यह मैं नहीं था जिसने एक ऐसी भाषा का उपयोग करने के लिए चुना था जहाँ कई महत्वपूर्ण आदेश गैर-अक्षर वाले वर्ण हैं ... (अन्य समाचारों में, मैं इस पॉलीग्लॉट में जोड़ने के लिए बेफ़ुज को एक मजबूत संभावना के रूप में विचार कर रहा था; यह अच्छी तरह से फिट बैठता है; अन्य भाषाओं। मुझे यह पसंद है कि आपने इसे कैसे किया, हालाँकि इसमें और अधिक फिट होने के लिए अच्छी तरह से संशोधन की आवश्यकता हो सकती है।)
@ ais523 मैं मानता हूं कि इस कोड को संशोधित करना मुश्किल हो सकता है। इसे कम करने के लिए, मैंने कुछ 0एस में यह संकेत करने के लिए रखा कि वे पात्र कुछ भी हो सकते हैं ( "<+0+0+0+<;n4भाग को छोड़कर ) और बीफुंज कोड के कुछ हिस्सों को चारों ओर ले जाया जा सकता है। और अगले व्यक्ति के लिए एक टिप: अधिकांश अक्षर बेफ़ुज में नो-ऑप हैं, इसलिए अधिक पंक्तियों को जोड़ने से बेफ़ुंज कोड को प्रभावित करने की संभावना नहीं है।
— जुंगवान मिन
बीफ्यूज -98 (या इसी तरह की अन्य फेज) जमा करने के बारे में सोचकर, क्योंकि वे काफी मात्रा में संचालन को जोड़ते हैं जो नियमित रूप से '93 'में नहीं हैं। हालांकि इसे फिट करना कठिन हो सकता है, और मुझे यह पता लगाने की आवश्यकता होगी कि अन्य सभी भाषाओं ने कैसे काम किया ताकि मैं उनके आसपास काम कर
— सकूं
19

21. निम (161 बाइट्स)

#v`16/"<"6/b.q@#;n4"14""
#>3N6@15o|> ^*ttt*~++ %
#=~nJ<R"12";
#[

print((1/2and 9 or 13)-(0and+4)^1<<65>>62)#46(89999+++++!)=#print(17)#]#echo 21
#8dggi2` |1|6

दो <ESC>एस, बीच 8dऔर 2`आखिरी लाइन पर। आप बता सकते हैं कि मेरे पहले वाले को जल्दी में रखा गया था, क्योंकि मैं आज सुबह उठा और मुझे एहसास हुआ कि मैं एक गुच्छा अधिक ले सकता हूं। मेरे पास 152 बाइट्स थे, लेकिन यह केवल पर्ल 5.24.0 में काम करता है, इसलिए TIO के साथ संगतता के हित में मैंने अभी के लिए मूल अभिव्यक्ति को रखा है।

प्रिंट 1 में पायथन 3, वी में 2, मिंकोलंग में 3, में 4> <> 5, पायथन 2 में 5, एसएमबीएफ में 6, जाप में 7, रेटिना में 8, पर्ल में 9, बेफुज में 93, बीफुंज में 11। -98, विखंडन में 12, रूबी में 13, टर्टल में 14, हेस्टैक में 15, पाइथ में 16, जूलिया में 17, कार्डिनल में 18, रेंग में 19, प्रील्यूड में 20 और निम में 21 हैं ।

ध्यान दें कि ideone.com पर निम संस्करण ०.११.२ का उपयोग करता है, जो बहुत पुराना है, क्योंकि यह कार्यक्रम #[ ... ]#२०१६ की शुरुआत में जोड़े गए बहुस्तरीय टिप्पणियों पर निर्भर करता है ।

कार्डिनल के विंडोज दुभाषिया के लिए धन्यवाद, मेरे वर्कफ़्लो में अब दो लैपटॉप और http.serverबीच में एक पायथन शामिल हैं ।

संपादित करें - कुछ और संकेत:

  • 8अंतिम पंक्ति के शुरू में यह रेटिना उत्पादन होगा बिना, पहले 8 मैचों के रेटिना की सीमा निर्धारित करने की है अन्यथा 2। ध्यान दें कि इसका मतलब है कि अंतिम पंक्ति regex को केवल दूसरी अंतिम पंक्ति में कम से कम 8 बार मिलान करने की आवश्यकता है, जैसा कि ठीक 8 के विपरीत है - मेरे ध्यान के दौरान मैंने रेटिना को सही पाने के लिए Prelude को संशोधित किया, लेकिन यह निकला कि अंत में अनावश्यक था ।
  • पहली पंक्ति के अंत में बेमेल बोली इतनी है कि पायथ बाकी कोड के लिए अमान्य सिंटैक्स के बारे में शिकायत नहीं करता है।
  • यदि आप दूसरी पंक्ति को संशोधित करते हैं, तो आपको 6@मिंकोलंग के लिए बदलना पड़ सकता है , जो कि प्वाइंटर को 6 रिक्त स्थान पर कूदने के लिए बनाता है ^।
  • अब की एक जोड़ी है [], इसलिए SMBF को हिट करने से पहले 0 सेल पर होना चाहिए [, या सेल को खाली करने के लिए इंटीरियर को वैकल्पिक करने की आवश्यकता है।

गोल्फ के लिए शायद अधिक है (यहां तक ​​कि अब मैं %कार्डिनल के लिए पहले एक आवारा जगह देखता हूं ), लेकिन मुझे वास्तव में सुबह के घने घंटे में गोल्फ को रोकना चाहिए।

— Sp3000
स्रोत
1
TIO अब कार्डिनल
— MildlyMilquetoast
19

51. असेंबली (x64, लिनक्स, एएस) , 1086 बाइट्स

#16  "(}23!@)(" 3//*v\D@;'[af2.qc]'#)"14";n4
#/*` PkPPZ (22)S"[!(>7 7*,;68*,@;'1,@␉␉␉␉ q
#>␉
# >36!@␉
#`<`
#<]+<[.>-]>[
#{
#z}
#
#=x<R+++++[D>+++++++EAL+++<-][pPLEASE,2<-#2DO,2SUB#1<-#52PLEASE,2SUB#2<-#32DOREADOUT,2DOGIVEUPDOiiipsddsdoh]>+.-- -. >][
#x%+>+=+~tt .
#D>xU/-<+++L
#R+.----\).>]|
#[#[(}2}20l0v01k1kx0l0ix0jor0h0h1d111x0eU0bx0b0o1d0b0e0e0@O6O4/0m1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10vx0v0l111111^_)  0046(8+9+9+9+9+=!)
###|
'\';echo 50;exit;';print((eval("1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or"'x"or'({({1})({1}[(0)])}{1}\{1})'#}#(prin 45)(bye)|/=1/24=x<$+@+-@@@@=>+<@@@=>+<?#d>+.--./
__DATA__=1#"'x"//
#.\."12"__*'
###;console.log 39
""""#//
=begin //
#sseemeePaeueewuuweeeeeeeeeeCisajjap*///;.int 2298589328,898451655,12,178790,1018168591,84934449,12597/*
#define p sizeof'p'-1?"38":"37"
#include<stdio.h>
main ( )/*/
#
#"`#"\'*/{puts (p);}/*'"`"
/*
<>{#65}//
#}
disp 49#//
#{
1}<>//
$'main'//
#-3o4o#$$$
#<R>"3"O.
=end #//
"""#"#//
#}
#s|o51~nJ;#:p'34'\=#print (17)#>27.say#]#print(47)#]#echo  21
#sss8␛dggi2␛ `|1|6$//''25  16*///89^_^_Z222999"26

␉एक शाब्दिक टैब है, ␛एक शाब्दिक ईएससी चरित्र; स्टाॅक एक्सचेंज अन्यथा कार्यक्रम को समाप्त कर देगा। यदि आप इस पर काम करना चाहते हैं, तो मैं नीचे TIO लिंक के "इनपुट" बॉक्स से प्रोग्राम को कॉपी करने की सलाह देता हूं।

और सीखना चाहते हैं? पॉलीगोट चैट की कोशिश करो !

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

वीआईपी स्कोर ( वर्सटाइल इंटेगर प्रिंटर ): .008186 (सुधार करने के लिए, अगली प्रविष्टि 1151 बाइट्स से अधिक नहीं होनी चाहिए)

इस कार्यक्रम के प्रिंट 51 विधानसभा, में 50 बैश में, 49 सप्टक में, 48 Deadfish ~, में 47 लिली में, 46 Cubix में, 45 PicoLisp में, 44 alphuck में, 43 जालीदार में, 42 बुराई में, 41 brainf में *** , 40 मिनिमल-2 डी, में 39 CoffeeScript, में 38 सी में, 37 सी ++, में 36 Labyrinth में, 35 INTERCAL में, 34 रेल में, 33 घटना में, 32 चक्कर में,31 मॉड्यूलर SNUSP, में 30 व्हाइटस्पेस में, 29 उत्प्रेरक में, 28 ब्रेन-आलोचना में, 27 पर्ल 6 में, 26 05AB1E में, 25 पिप में, 24 Thutu में, 23 Hexagony में, 22 लादना में, 21 निम में, 20 में प्रस्तावना, 19 में रेंग, कार्डिनल में 18 , जूलिया में 17 , पाइथ में 16 , हेस्टैक में 15 , टर्टलड में 14 , रूबी में 13 , विखंडन में 12 , बेफुज -98 में 1110 Befunge -93, में 9 पर्ल 5, में 8 रेटिना में, 7 Japt में, 6 SMBF में, 5 अजगर 2, में 4 > <> में, 3 Minkolang में, 2 वी / विम में, और 1 अजगर 3 में।

सत्यापन

अधिकांश भाषाओं का परीक्षण ऊपर दिखाए गए परीक्षण चालक द्वारा किया जाता है।

  • रेंग को यहां आउटपुट 19 पर परीक्षण किया जा सकता है ।

  • मॉड्यूलर एसएनयूएसपी को आउटपुट 31 पर परीक्षण किया जा सकता है यहांहै ।

  • क्यूबिक्स का घन आकार देखा यहाँ गया

  • पिछले उत्तरों में वर्णित टोकन को संतुलित रखकर हादसे की जाँच की जाती है।

  • डेडफिश ~ के लिए, आउटपुट 48 पर परीक्षण किया जा सकता है साथ । ध्यान दें कि डेडफ़िश ~ स्टड पर खिलाए जाने वाले पॉलीग्लॉट लेता है, लेकिन >>मानक आउटपुट के लिए कई संकेत देता है, जो किसी भी डेडफ़िश ~ प्रोग्राम को चलाने का एक अपरिहार्य परिणाम है।

  • विधानसभा का आउटपुट 51 पर परीक्षण किया जा सकता है यहां है

धन्यवाद और बधाई

जब @ ais523 का 50-इन-1-k उत्तर 2 सप्ताह पहले गिरा, तो एक आंसू ने मेरे गाल को हिला दिया। यह बहुत सुंदर था। और यह बाश में था। यह बहुत सही था।

मैं अपनी पत्नी की ओर मुखातिब हुआ और कहा "मुझे लगता है कि पॉलीग्लॉट किया गया है," बहुत गर्व महसूस हो रहा है।

उसने मुझे आँख मारने के लिए कहा, एक पल रुका, और कहा "अच्छा। अब कचरा बाहर निकालो। ”

हालांकि उसका मतलब यह था कि उसे मेरे और मेरे इंटरनेट मित्रों के लिए गहरी खुशी महसूस हुई। सभी को धन्यवाद और बधाई।

विधानसभा स्पष्टीकरण

इसके बाद के दिनों में, मेरा मन कुछ वापस करने के लिए भटकता रहा। उन्होंने कहा कि विधानसभा के कुछ जायके #आधारित लाइन टिप्पणियों का उपयोग करते हैं और/* ब्लॉक टिप्पणियों का उपयोग करते हैं। खैर यह मेरे लिए अगले 2 हफ्तों के लिए धीरे-धीरे अपना दिमाग खोने के लिए पर्याप्त था।

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

थोड़ी देर के लिए समस्या के खिलाफ मेरे सिर को पीटने के बाद, सह-अस्तित्व के लिए असेंबली और सी / सी ++ के लिए रास्ता खोज रहा है, मैंने पाया कि यह जीएनयू असेंबलर के लिए दस्तावेज है:

पिछले असेंबलरों के साथ संगत होने के लिए, '#' से शुरू होने वाली लाइनों की एक विशेष व्याख्या है। '#' के बाद एक पूर्ण अभिव्यक्ति होनी चाहिए (अभिव्यक्तियाँ देखें): अगली पंक्ति की तार्किक रेखा संख्या। फिर एक स्ट्रिंग (स्ट्रिंग्स देखें) की अनुमति दी जाती है: यदि वर्तमान में यह एक नया तार्किक फ़ाइल नाम है। शेष पंक्ति, यदि कोई हो, को व्हाट्सएप होना चाहिए।

मैंने देखा कि यह पॉलीग्लॉट 1 की पंक्ति 1 में C / C ++ के हमारे पूर्व-प्रोसेसर निर्देश के समान है। कुछ परीक्षण और त्रुटि के बाद मैंने पाया कि#1 “bla” 1//* केवल विधानसभा के लिए एक ब्लॉक टिप्पणी दर्ज की जाएगी।

और इसलिए एक बहुभुज बनाया गया था।

सबसे बड़ी अवरुद्ध समस्याओं को हल करने के साथ, मैंने इस हैलो वर्ल्ड उदाहरण को नीचे गोल्फ में सेट किया। 

.intel_syntax noprefix
.section .data
     msg: .asciz "51"
.section .text
.global _start
_start:
    # write syscall
    mov     rax, 1
    # file descriptor, standard output
    mov     rdi, 1
    # message address
    mov     rsi, OFFSET FLAT:msg
    # length of message
    mov     rdx, 14
    # call write syscall
    syscall
    #End the Program
    mov    rax, 60
    mov    rdi, 0
    syscall

प्राथमिक लेखक का श्रेय

वास्तव में मैंने एक मिनट पहले झूठ बोला था, मेरे द्वारा उपयोग किए गए असेंबली कोड का पहला संस्करण AT & T सिंटैक्स में था, जो असेंबली की दो वाक्यात्मक शाखाओं में से एक है। एटी एंड टी सिंटैक्स के मुख्य तत्वों में से एक यह है कि यह रजिस्टर संदर्भ एक %उपसर्ग का उपयोग करता है और यह पॉलीग्लॉट के लिए एक समस्या है। कार्डिनल %एक पॉइंटर मूल के रूप में उपयोग करता है , इसलिए यदि हम %इसके बारे में एक गुच्छा देते हैं, तो यह दूसरी विखंडन प्रतिक्रिया की तरह होगा।

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

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

विभिन्न प्रकार के रजिस्टर हैं जो विभिन्न उद्देश्यों के लिए उपयोग किए जाते हैं। विकिपीडिया से:

• AX गुणा / विभाजित, स्ट्रिंग लोड और स्टोर

• स्ट्रिंग संचालन और पारियों के लिए सीएक्स काउंट

• IN और OUT के लिए DX पोर्ट एड्रेस

• मोवे के लिए बीएक्स इंडेक्स रजिस्टर

• एसपी स्टैक के शीर्ष पर इंगित करता है

• बीपी स्टैक फ्रेम के आधार को इंगित करता है

• एसआई धारा संचालन में एक स्रोत को इंगित करता है

• DI धारा संचालन में एक गंतव्य की ओर इशारा करता है

AX का उपयोग _start फंक्शन की लाइन में किया जाता है mov rax, 1:। rमें raxइंगित करता है कि स्मृति 64-बिट है। यदि हमने इसके लिए स्वैप किया है e, तो यह 32-बिट मेमोरी को इंगित करेगा, जो 64-बिट प्रोसेसर के साथ करने के लिए पूरी तरह से वैध है। हम अभी उपलब्ध मेमोरी के शीर्ष आधे हिस्से का उपयोग नहीं करेंगे। 16-बिट मेमोरी को इंगित करने के लिए, आप बस उपयोग करते हैं ax, जो हमारे लिए ठीक है क्योंकि हम केवल पूर्णांक प्रिंट कर रहे हैं। इसलिए हम 16-बिट के लिए सभी रजिस्टर संदर्भों को बदलकर कुछ बाइट्स को गोल्फ कर सकते हैं।

ठीक है, काफी नहीं सभी रजिस्टर संदर्भ ड्रॉप कर सकते हैं r। mov rsi, OFFSET FLAT:msg। यदि आप असेंबली से परिचित हैं, लेकिन यह कथन नहीं है, तो ऐसा इसलिए है क्योंकि यह AS के लिए अद्वितीय था। कम से कम, कि क्या मैं से बटोरा इस है, जो मुझे बस करने के लिए बयान नीचे सोने में मदद की lea rsi,m।

इसके बाद, मैंने अनुभवात्मक रूप से पाया कि मैं _start:बस नीचे दस्तक दे सकता हूं _pऔर .global _startकेवल जारी की गई चेतावनी के साथ पूरी तरह से काट सकता हूं । दूसरा, msg:केवल एक वर्ण चर में घटाया गया था p:। मैंने अल्फाक के लाभ के लिए जोड़े गए pकुछ sविधानसभाओं को ऑफसेट करने के लिए स्ट्रिंग चर और शुरुआती फ़ंक्शन दोनों के लिए चुना ।

फिर, मैंने ;उन सभी को एक पंक्ति में रखने के लिए निर्देशों को परिसीमन करने के लिए रखा। यह मुख्य रूप से #//थुटू के लाभ के लिए प्रत्येक पंक्ति पर अत्यधिक अनुगामी एस से बचने के लिए है। इसके अलावा, मैंने देखा कि हमारे असेंबलर केस के प्रति संवेदनशील नहीं थे, इसलिए मैंने बस असंतुलित होने से बचने के लिए विभिन्न पात्रों को ऊपरी या निचले आवरण में ढंक दिया।

यह गोल्फ हमें नीचे ले जाएगा:

.intel_syntax noprefix;.text;mov ax,1;mov di,1;lea rsi,m;mov dx,2;syscall;mov ax,60;mov di,0;syscall;m:.asciz "51"

इस सब के बाद, इस उत्तर में जप और अंडरलोड बच्चों की एकमात्र समस्या थी। जाप *में पंक्ति 1 में कुछ गोमांस था , लेकिन यह puts(p);C ++ उत्तर से पंक्ति में बदलकर तय हो गया था। मैंने (इस लाइन में एक को फेंक दिया और फिर इसे ऑक्टिव की लाइन पर बंद कर दिया। यह इतना अंडरलोड था कि सीफॉल्ट करना बंद हो जाएगा। *वहाँ जोड़ने के लिए लाइन 1 पर एक समान उपचार किया गया था ।

इस चुनौती की बाइट आवश्यकताओं को पूरा करने के लिए यह पर्याप्त था। वास्तव में मैंने पॉलीग्लॉट के इस संस्करण का निर्माण करके इसे सत्यापित किया । लेकिन मैं अगर संभव हो तो वीआईपी स्कोर में सुधार करने का प्रयास करना चाहता था। और चूंकि मैंने चुनौती की सभी आवश्यकताओं को पूरा कर लिया था, इसलिए मुझे कोड को नीचे करने के लिए सहयोग करने के बारे में ठीक लगा। इसलिए मैं कुछ गोल्फ की मदद लेने के लिए पॉलीग्लॉट चैट पर रुक गया।

हमें गहराई तक जाना चाहिए

@ ais523 ने इस कथन के साथ मशीन कोड के रूप में कोडांतरक को निर्देश पारित करने की एक तकनीक का प्रदर्शन किया।

.text;.long 2298589328,898451655,12,178790,1018168591,84934449,12597 मशीन कोड सीपीयू द्वारा सीधे निष्पादित संख्यात्मक निर्देशों की एक श्रृंखला है जिसे दशमलव, हेक्साडेसिमल या ऑक्टल में दर्शाया जा सकता है। हमारे उद्देश्यों के लिए दशमलव सबसे कम है क्योंकि (हेक्स 0xप्रतिनिधित्व करने के लिए एक अग्रणी लेता है )। यहां .longबयान यह घोषणा कर रहा है कि दशमलव मशीन कोड निर्देशों की एक श्रृंखला क्या है।

वैसे मैंने इस कथन पर थोड़ा गौर किया और यह देखने के लिए कि कोडांतरक क्या अनुमति देगा, और कुछ बदलाव किए। सबसे पहले, मैंने पाया कि मैं .text;सभी को एक साथ निकाल सकता हूं , केवल चेतावनी के मुद्दों के साथ, जो कि एक बहुत बाइट की बचत थी। फिर थोड़ी देर बाद मैंने यह भी पाया, एएस के विवरण में यह कथन

.लोंग .int के समान है

ठंडा। तो, हम एक त्वरित बाइट के लिए उस स्वैप को बना सकते हैं। अब हमारा असेंबली, लेकिन वास्तव में मशीन कोड, इसे नीचे काट दिया गया था:

.int 2298589328,898451655,12,178790,1018168591,84934449,12597।

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

यहाँ कोड स्निपेट है।

और यहाँ सिर्फ विधानसभा है। 

nop
mov    $0x1,%al
mov    %eax,%edi
lea    0xc(%rip),%rsi
mov    $0x2,%dx
syscall 
mov    $0x3c,%al
xor    %edi,%edi
syscall 
.byte 0x35
xor    %eax,(%rax)

यह लिंक विधानसभा की प्रत्येक पंक्ति के साथ कुछ 2 वर्ण हेक्स संख्या भी दिखाता है। वे दशमलव निर्देशों के अनुरूप हैं। उदाहरण के लिए, यदि आप इस दशमलव को हेक्स कनवर्टर 2298589328में डालते हैं, तो आप वापस आ जाते हैं। और अगर आप बारीकी से देखते हैं, तो वे ऑब्जेक्ट डंप (रिवर्स ऑर्डर में) से पहले 4 हेक्स निर्देश हैं।8901B090

मैं जो बता सकता हूं, उसमें से 4 हेक्साडेसिमल संख्याओं के सेट हमेशा दशमलव में परिवर्तित करने के लिए उपयोग किए जाते हैं और मुख्य बाइट सेविंग ट्रिक का उपयोग यहां असेंबली को तैयार करने के लिए किया जाता है ताकि हमारे 4 सेटों में अंतिम कई हेक्स संख्या 00 हो जाएं। ये तब बदल देंगे अग्रणी शून्य के लिए जब हम उन्हें .intबयान में डालते हैं जो अभी छोड़ा जाता है।

12बयान में यही हो रहा है । ऑब्जेक्ट के हेक्स भाग में यह डंप है 0c 00 00 00।

जहाँ तक असेंबली के बारे में मेरी समझ 2 सप्ताह में मिल गई है। क्या क्रैश कोर्स है!

घटना

कम असेंबली कार्यान्वयन में हादसा एक अधिक कठिन हल था क्योंकि यह पॉलीग्लॉट टोकन को शीर्ष पर बहुत अधिक भारी बनाता था। ये है हादसा रिपोर्ट।

  • ! 2 लाइन में अलग हो जाता है !

  • EAINTERCAL लाइन पर सबसे पहले खुद को अलग करता है

  • दूसरी से अंतिम पंक्ति में अंतिम स्थान एक स्पेस-स्पेस टोकन को अलग करता है।

  • 85 अंतिम पंक्ति में अलग हो जाता है

  • Rमें #<R>"3"O.detokenizesR

  • 65में <>{#65 }//tokenizes65

  • 16 अंतिम पंक्ति में खुद को अलग करता है

  • 89 अंतिम पंक्ति में ही टोकन होता है

कार्डिनल

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

= पॉइंटर के सक्रिय मान को उसके निष्क्रिय मान में कॉपी करता है।

यह बहुवचन में इस्तेमाल की जाने वाली चाल नहीं थी। पुराने समाधान में ये इंस्ट्रक्टिटोन शामिल थे: `++ ~ * t

++ 2 तक incriments।

~ सक्रिय स्टैक को बदलता है

* ढेर जोड़ता है।

मुझे एहसास हुआ कि ~*बस =निर्देश के साथ हासिल किया जा सकता है , इसलिए मैंने कुछ बेकार स्टैक स्वैपिंग को बाहर निकालने और इस छोटे बाइट बचत में जोड़ने के समाधान को फिर से काम किया।

— मोका
स्रोत
3
मैं कैसे आप भी इस अद्भुत चरण के लिए polyglotting रख सकते हैं के रूप में intrigued रहा हूँ। किस तरह???
— Qwerp-Derp
3
यह वास्तव में शुद्ध सौंदर्य की चीज है।
— मुजेर
यूनरी अगला होना चाहिए
— क्रिस्टोफर
नहीं, यह वीआईपी स्कोर को मार देगा (जब तक कि कोड 3 बाइट्स या उससे कम नहीं था)
— कैलक्यूलेटरफिलीन
19

6. एसएमबीएफ , 45 बाइट्स

#v<++++<;n4
#>3N.
print('1'if 1/2else'5')
#i2

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

इस कार्यक्रम के प्रिंट 1 अजगर 3, में 2 वी में, 3 Minkolang v0.15, में 4 में> <>, 5 अजगर 2 में, और 6 SMBF में।

SMBF (उर्फ सेल्फ-मॉडिफाइंग ब्रेनफक) उपयोग करता है <++++<>.। पॉइंटर को लेफ्ट (स्रोत कोड के अंतिम वर्ण तक) ले जाया जाता है, और सेल को चार बार बढ़ाया जाता है फिर प्रिंट किया जाता है।

— mbomb007
स्रोत
17

13. रूबी (129 बाइट्स)

#v;2^0;7||"<+0+0+0+<*!2'!1'L;n4
#v0#_q@
#>3N.
#|\w*
#8  ^1b0<
#|
#M`
print ((0 and'13')or(None and 9 or 1/2 and 1 or 5))
#jd5ki2

कृपया ais523 के पर्ल जवाब के अनुसार और के Escबीच अंतिम पंक्ति पर शाब्दिक चरित्र पर ध्यान दें ।jd

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

यह 1 पायथन में 3, विम में 2 , मिंकोलंग में 3 , 4 में <> <, 5 में पायथन 2, 6 SMBF में, 7 Japt में, 8 रेटिना में, 9 पर्ल में, 10 Befunge में, 11 Befunge- में 98, विखंडन में 12 और रूबी में 13 हैं ।

रूबी में printसच्चाई है कि दुरुपयोग करने के लिए मौजूदा बयान के लिए सिर्फ एक मामूली संशोधन 0। मुझे इसे सही ढंग से पार्स करने के लिए अन्य कथनों में कुछ स्थान जोड़ना पड़ा।

— डोम हेस्टिंग्स
स्रोत
17

15. हेयस्टैक (141 बाइट्स)

#v;2^0;7||"<+0+0+0+<*!2'!1'L#'1r'4;n4
#v0#_q@
#>3N.15o|1
#|\w*
#8  ^1b0<
#|
#M`
print ((0 and'13')or(None and 9 or 1/2 and 1 or 5))
#jd5ki2

नोट: तीसरी पंक्ति में और अंतिम पंक्ति में एक के ESCबाद एक हैoj

यह प्रिंट 1 पायथन में 3 , 2 विम में, 3 Minkolang में, 4 में <> <, 5 अजगर में 2 , 6 SMBF में, 7 Japt में, 8 रेटिना में, 9 पर्ल में, 10 Befunge में, 11 Befunge- में 98 , 12 विखंडन में, 13 रूबी में, 14 turtlèd में, और 15 Haystack में।

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

व्याख्या

#v                           go down
 v
 >                           go right
  3N.                        does nothing important
     15o|                    outputs 15 and ends program
                             there is an <ESC> after 'o' since 'o' in Vim enters insert mode
         1                   I added this to satisfy Retina
— गायों का कुनबा
स्रोत
बहुत बढ़िया, हेडस्टैक की जाँच के लिए धन्यवाद! :)
— काडे
@ केड यह एक अच्छी 2 डी भाषा है, एक ऑनलाइन दुभाषिया अधिक मददगार होगा (हालाँकि मैंने पहले ही पायथन दुभाषिया डाउनलोड कर लिया है) :)
— गायों को
@ कैड अब हैस्टैक के लिए एक TIO लिंक है!
— गायों ने
@MistahFiggins लिंक मेरे लिए काम करता है और 15 से आउटपुट करता है
— गायों की
@MistahFiggins कैश? क्योंकि यह मेरे लिए बिना किसी समस्या या किसी त्रुटि संदेश के काम करता है
— गायों का क्षय
17

9. पर्ल, 84 बाइट्स

#v;7||"<+0+0+0+<;n4
#>3N.
#|\w*
#8
#|

#M`
print(None and 9or 1/2and 1or 5)
#j␛d5ki2

वहाँ के बीच वास्तविक कोड में एक शाब्दिक ESC चरित्र है jऔर d; इसे दृश्यता के लिए यहां a के साथ बदल दिया गया है।

यह प्रिंट 1 अजगर 3 में , 2 विम में (स्थानीय रूप से परीक्षण किया है, लेकिन यहाँ है बहुत इसी तरह की भाषा V के लिए एक लिंक), 3 Minkolang में , 4 <> <में , 5 अजगर 2 में , 6 SMBF में , 7 Japt में , 8 रेटिना में , और पर्ल में 9 ।

आइए, कुछ और विदेशी भाषाएं प्राप्त करें, जिसमें विभिन्न भाषाओं में अलग-अलग तरीके से काम करने वाले अंकगणित हैं। ( Noneपायथन में फाल्सी है लेकिन पर्ल में सत्य, और and/ orचेन दोनों भाषाओं में एक ही तरह से काम करते हैं।)

पायथन के अलावा, मुझे विम कोड भी बदलना पड़ा। इसे नो-ऑप्स की श्रृंखला में बनाने के बजाय, मैंने इसे केवल कबाड़ डालने दिया, फिर अंत में कबाड़ को फिर से हटा दिया।

— Riking
स्रोत
4
गंभीरता से? यदि आप शाब्दिक ईएससी में डालते हैं, तो आप किसी और के लिए उत्तर बनाना बहुत कठिन बना सकते हैं। हमें कोड का परीक्षण करने में सक्षम होना चाहिए।
— mbomb007
1
आपको अपने स्वयं के उत्तरों में शाब्दिक ESC को शामिल करने की आवश्यकता नहीं है; मुझे यह लिखने का सबसे आसान तरीका लगा। (इसके अतिरिक्त, यह फ़ायरफ़ॉक्स में ठीक काम करता है, और स्थानीय परीक्षण में; मुझे पोस्ट में डालने से रोकने वाली एकमात्र बात यह है कि क्रोमियम, जिसे मैं एसई के लिए उपयोग करता हूं, इसे इनपुट बॉक्स में नहीं डालना चाहता।)
1
इसके अलावा, आप विम के लिए स्थानीय स्तर पर परीक्षण नहीं कर सकते। भाषाएं उस दुभाषिया द्वारा परिभाषित की जाती हैं जिसका उपयोग किया जाता है। तो यह वास्तव में वी है कि हम यह सब समय है।
— mbomb007
1
एर, vimविम के लिए एक दुभाषिया नहीं है ? (यह vimयद्यपि और V दोनों में काम करता है ।)
4
@ ais523 शायद आप 0x1B बाइट का प्रतिनिधित्व करने के लिए maybe रख सकते हैं?
— betseg
17

36. भूलभुलैया , 647 बाइट्स

#v`16/"<"6/b.q@"(: ::Q):  ␉␉␉␉ :(22)S#;n4"14"
#>3N36!@@15o|>␉^?.*ttt*~++~~~%
#= >␉1#v#v0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#[␉
#`<`|
print((eval(" 1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or' (\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1111|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"␉*
""""#//
=begin␉//
$'main'//
#-3o4o#␉
=end   #//
"""#"#//
#0]#echo 21#/ (\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE) a
#   +/Jn~
#0␛dggi2␛`␉|1|6$//''25  >>>#>27.say# =#print(17)#$nd^_^_.]Q2229991#;abcd!fghij/+23!@"26

␉एक शाब्दिक टैब है, ␛एक शाब्दिक ईएससी चरित्र; स्टाॅक एक्सचेंज अन्यथा कार्यक्रम को समाप्त कर देगा। यदि आप इस पर काम करना चाहते हैं, तो मैं नीचे TIO लिंक के "इनपुट" बॉक्स से प्रोग्राम को कॉपी करने की सलाह देता हूं।

उन्हें ऑनलाइन कोशिश करो!

मंद होना

यह कार्यक्रम भूलभुलैया में 36, INTERCAL में 35, रेल में 34, हादसे में 33, भंवर में 32, मॉड्यूलर SNUSP में 31, व्हॉट्सएप में 30, ट्रिगर में 29, ब्रेन-फ्लैक में 28, पर्ल 6 में 27, 26 में 05AB1E , पिप में 25, थुटु में 24, हेक्सागोनी में 23, अंडरलोड में 22, निम में 21, प्रील्यूड में 20, रेंग में 19, कार्डिनल में 18, जूलिया में 17, पाइथ में 16, हेस्टैक में 15, टर्टलैड में 14, 13 रूबी में, १२ में विखंडन में, ११ में बेफ़ुंज-९ in में, १० में बेफ़ुंज-९ ३ में, ९ में पर्ल ५ में, रेटिना में in में, जाप में in में, एसएमबीएफ में ६ में, पायथन में ५ में, ४ में> <>, ३ में मिंकोलंग में , वी / विम में 2, और पायथन 3 में 1।

सत्यापन

अधिकांश भाषाओं का परीक्षण ऊपर दिखाए गए परीक्षण चालक द्वारा किया जाता है। आप यहां रेंग और मॉड्यूलर SNUSP का परीक्षण कर सकते हैं ; वे क्रमशः 19 और 31 का उत्पादन करते हैं। @ ais523 ने डिबग और इंसीडेंट कोड को ठीक करने में मदद की, जो अब काम करता है।

भूलभुलैया कैसे काम करती है

भूलभुलैया में कुछ स्तंभों को थोड़ा-थोड़ा इधर-उधर कर देना शुरू कर दिया जाता है, लेकिन कुछ ही कदमों के बाद पॉइंटर Nको दूसरी पंक्ति में है, जहां (शुरुआत में, तब तक पॉइंटर मिलता है)N तब वहाँ नहीं है) स्टैक के शीर्ष पर 0 के साथ। फिर, यह बस 36 को धक्का देता है और प्रिंट करता है36!@

चीजें मैंने पूरी कीं

मुझे पता था कि मैं भूलभुलैया जोड़ना चाहता हूं, क्योंकि यह उन कुछ एसोलैंगों में से एक है जिनके बारे में मैं थोड़ा जानता हूं। इसके डीबगर के साथ, मैंने पाया कि अंतिम पंक्ति में 8 को 0 में बदलकर, लेबिरिंथ एक अनंत लूप में फंस नहीं गया था और, अजीब तरह से, कुछ और नहीं लगता था। वहां से मुझे बस कच्चे 36 और आउटपुट कमांड की आवश्यकता थी, और उन @चीजों को आसानी से समाप्त करने के लिए नेतृत्व किया ।

फिर, मैं जो तोड़ता था, उसकी मरम्मत करने पर था: मिंकोलंग, कार्डिनल और हेक्सागोनी।

!Minko अगले वर्ण, जो इसे समाप्त करने के लिए आवश्यक को छोड़ कर रहा था, तो मैं बस एक अतिरिक्त जोड़ा @। अब तक सब ठीक है।

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

हेक्सागोनी सौभाग्य से एक अपेक्षाकृत सरल फिक्स था, मैंने सिर्फ अक्षरों की एक स्ट्रिंग में फेंक दिया ताकि सूचक कोड मिल जाए। मुझे लगा कि वर्णमाला पहले प्रकट नहीं होनी चाहिए और हादसे की समस्या पैदा नहीं करेगी। यह तब भी है जब मुझे एहसास हुआ कि मैंने हादसा नहीं किया है। @ Ai523 के लिए धन्यवाद, मुझे पता चला कि मुझे बस एक अतिरिक्त विस्मयादिबोधक बिंदु की आवश्यकता थी, इसलिए eवर्णमाला में स्ट्रिंग को एक में बदल दिया गया था! ।

से स्कोर किया बहुमुखी पूर्णांक प्रिंटर

बस किक के लिए और इस सवाल पर @Stewie ग्रिफिन की टिप्पणी से हटने के लिए, यहां एक स्निपेट है जो दिखाता है कि प्रत्येक उत्तर में "द वर्सटाइल इंटर्जर प्रिंटर" दर्ज होने पर कैसे स्कोर होता।

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

— SnoringFrog
स्रोत
1
ठीक है, ऐसा लगता है कि यह केवल हादसा के साथ समस्याओं का कारण बनता है; अब तीन विस्मयादिबोधक चिह्न होने के कारण प्रोग्राम का ऑफ-सेंटर है, लेकिन इसे आसानी से फिलर कैरेक्टर को चौथे विस्मयादिबोधक चिह्न में बदलकर ठीक किया जा सकता है। मैंने eआपके द्वारा विस्मयादिबोधक चिह्न में जोड़े गए वर्णमाला में बदल दिया ; यह काम करने लगता है।
1
अच्छा! मैं गुप्त रूप से भूलभुलैया का इंतजार कर रहा हूं, इसलिए आप पर अच्छा है। एक अलग नोट पर, कोड का अब तक का सबसे अच्छा हिस्सा (मेरे लिए) "PLEASEGIVEUPPLEASE" संदेश है, जो आपको सिर्फ कोशिश करना बंद करने के लिए कह रहा है। ;)
— माइल्डलीवेटकास्ट
17

41. ब्रेनफ *** , 916 बाइट्स

#  4"16" 3//v\(@#/;\D"14"<;n4
#/*`3 afaaZ">;[77*,68*,@;'1,'1,q)(22)S#   ␉␉␉␉ (
#yy␉;36!@
#`<` ␉
#=␉x
#<]+<[.>-]>[
#␉<
###xR+++++[D>+++++++L+++<-][<<<]>+.---.>][
#px%>~~~+␉+~*ttt*.x
#D>xU/-<+++L)
#R+.----.R␉>]|
#[#yy#yy0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#|␉
print((eval("1\x2f2")and(9)or(13   ) )-(0and 4)^1<<(65)>>(62))or'(\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1111|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"␉*
###; console.log  39
""""#//
=begin␉//
#*/
#define␉z  sizeof 'c'-1?"38":"37"
#include<stdio.h>
int main()  /*/
#()`#`\'*/{puts(z);}/*'``
$'main'␉//
#-3o4o#$$$
<>"3"O.<␉>//
#
=end   #//
"""#"#//
#0]#echo 21#/(\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE)  a>>>
#>27.say# /7Jn~15o|  
#8␛dggi2␛`␉|1|6$//''25  =#print(17) ###^_^_LEintnd"3"z!]/}23!@/*///Z222999"26

␉ एक शाब्दिक टैब है, ␛एक शाब्दिक ईएससी चरित्र; स्टाॅक एक्सचेंज अन्यथा कार्यक्रम को समाप्त कर देगा। यदि आप इस पर काम करना चाहते हैं, तो मैं नीचे TIO लिंक के "इनपुट" बॉक्स से प्रोग्राम को कॉपी करने की सलाह देता हूं।

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

वीआईपी स्कोर (वर्सटाइल इंटेगर प्रिंटर): 0.01329

मंद होना

यह कार्यक्रम ब्रेनफ *** में 41 , मिनिमल -2 डी में 40 , कॉफीस्क्रिप्ट में 39 , सी में 38 , सी में 37 , सी ++ में 36 , भूलभुलैया में 35 , INTERCAL में 35 , रेल में 34 , हादसे में 33 , व्हर्ल में 32 , 31 में 31 प्रिंट करता है । मॉड्यूलर SNUSP, 30 श्वेत रिक्ति, में 29 उत्प्रेरक में, 28 ब्रेन-आलोचना में, 27 पर्ल 6, में 26 05AB1E में, 25 पिप में, 24 Thutu में, 23 Hexagony में, निम में, 20 22 लादना में, 21 प्रील्यूड में , रेंग में 19 , कार्डिनल में 18 , जूलिया में 17 , पाइथ में 16 , हेस्टैक में 15 , टर्टलड में 14 , रूबी में 13 , विखंडन में 12 , बेफुज -98 में 11 , बेफुज में 10 93, 9 पर्ल 5, में 8 रेटिना में, 7 Japt में, 6 SMBF में, 5 अजगर 2, में 4 > <> में, 3 Minkolang में, 2 वी / विम में, और 1 अजगर 3 में।

सत्यापन

अधिकांश भाषाओं का परीक्षण ऊपर दिखाए गए परीक्षण चालक द्वारा किया जाता है। आप यहां रेंग और मॉड्यूलर SNUSP का परीक्षण कर सकते हैं ; आवश्यकतानुसार वे क्रमशः 19 और 31 का उत्पादन करते हैं।

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

मैंने रूंडाउन में टर्टेल्ड के यूएफटी 8 चार के लिए कॉलम रिक्ति को संभालने के लिए एक टेस्ट ड्राइवर समायोजन भी किया। वह मिसलिग्न्मेंट मुझे पागल कर रहा था! "फिक्स" बहुत हैक-ईश है क्योंकि यह सिर्फ एक के लिए दिखता है और उस मामले के लिए कॉलम की चौड़ाई को बदलता है, लेकिन यह काम पूरा कर लेता है।

व्याख्या

सबसे पहले, मैं यह कहना चाहता हूं कि पिछली पोस्ट से @ SnoringFrog का वर्सटाइल इंटीजर प्रिंटर स्कोर रंडाउन कोड स्निपेट कितना भयानक था। मैं कुछ समय के लिए पोस्ट करने से पहले उत्तरों की गणना कर रहा हूं, और इसने मुझे इसे छोटा रखने के लिए फिर से प्रेरित किया है। मुझे लगता है कि हम अंततः @ sp3000 के उत्तर को हरा सकते हैं।

इसलिए मैंने इस जवाब पर काम करना शुरू कर दिया कि मैं क्या कर सकता हूं और मैं बहुत सफल रहा। मैं भी एक अलग भाषा में # 40 की तुलना में कुल बाइट गिनती के साथ एक जवाब था। लेकिन जैसा कि मैंने मिनिमल -2 डी में नीचे गोल्फ करने की कोशिश की, मुझे बीएफ सीखना पड़ा ताकि मैं इसके डेरिवेटिव के साथ बेहतर काम कर सकूं और इस प्रक्रिया में मैंने @ प्राइमो का रिकॉर्ड तोड़ हैलो, वर्ल्ड!। मुझे शान से प्यार हो गया।

मिनिमल -2 डी, यह पता चला, @Primo द्वारा उपयोग की जाने वाली टेप इनिशियलाइजिंग तकनीक का उपयोग करने के लिए पर्याप्त कुशल नहीं था, लेकिन मैं अब यह सोचता हूं कि यह बहुत भारी बाइट होगा। हम केवल एक पूर्णांक प्रिंट करने की कोशिश कर रहे हैं। लेकिन @ प्रिमो ने मुझे बीएफ में गुणा करने का तरीका सीखने के लिए नीचे भेजा, जिसे मैंने मिनिमल -2 डी कोड में लाया।

फिर इस सब के बाद, मैंने BF को शामिल करने के तरीके के बारे में @ SnoringFrog की टिप्पणी को फिर से पढ़ा और महसूस किया कि न केवल मैं इसे कर सकता था, बल्कि मैं बीएफ जवाब में नीचे दिए गए मिनिमल -2 डी कोड का अधिक उपयोग कर सकता था। इसलिए मैंने बीएफ के साथ जवाब देने के लिए खोदा, और यहां हम हैं।

विवरण में आने से पहले एक और बात। गैर-गोल्फ कारणों से मैंने कुछ बदलाव किए। सबसे पहले, मैंने कोड @SnoringFrog के थोक को स्थानांतरित किया जो शीर्ष कई पंक्तियों में केवल 2 डी भाषाओं के नीचे है। मेरे लिए, यह भविष्य के कीड़े को रोकने के लिए बहुभुज के केंद्र को पीछे करने से 2 डी-लैंग्स को रोकने के लिए एक दीर्घकालिक रणनीतिक कदम है जहां संभव हो। इस कदम के लिए बाइट हिट कम थी, इसलिए मैं इसके लिए गया।

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

एस एम / बीएफ

आइए जल्दी से मूल बातें खत्म करें। ये SMBF और BF के लिए एकमात्र मान्य कमांड हैं:

>   Move the pointer to the right
<   Move the pointer to the left
+   Increment the memory cell under the pointer
-   Decrement the memory cell under the pointer
.   Output the character signified by the cell at the pointer
,   Input a character and store it in the cell at the pointer
[   Jump past the matching ] if the cell under the pointer is 0
]   Jump back to the matching [ if the cell under the pointer is nonzero

दोनों भाषाओं में एक मेमोरी टेप होती है जहां मान संग्रहीत और परिवर्तित किए जाते हैं। एसएमबीएफ का एकमात्र अंतर यह है कि जो भी कोड निष्पादित किया जा रहा है वह मेमोरी टेप पर शुरुआती बिंदु के बाईं ओर भी संग्रहीत है। जैसा कि @SnoringFrog ने बताया, SMBF और BF को अलग-अलग परिणाम प्राप्त करने के लिए मेमोरी पॉइंटर को मूल के बाईं ओर ले जाने पर टिका है। टियो के बीएफ दुभाषिया में, मेमोरी पॉइंटर मूल के बाईं ओर बढ़ने में सक्षम है और पॉलीग्लॉट के एससीआई कोड के बजाय 0 को खोजेगा जो एसएमबीएफ देखता है। यहाँ एक उदाहरण है जो SMBF और BF दोनों में अंतर को समझने के लिए चलाया जा सकता है।

पॉलीग्लॉट की शुरुआत में, बीफुंग्स >को पूरा होने के लिए दूसरी पंक्ति पर चलने की आवश्यकता होती है और पर्ल 6 को यह आवश्यक होता है कि हर >एक से पहले हो <। इसलिए एसएम / बीएफ की शुरुआत <>मेमोरी पॉइंटर को मूल स्थान पर छोड़ने से होती है, [जो ]6 वीं पंक्ति में दोनों भाषाओं के लिए कुछ आक्रामक पात्रों को हिट करता है ।

अगला, हम दोनों भाषाओं के लिए मूल मेमोरी सेल बढ़ाते हैं और मेमोरी पॉइंटर को बाईं ओर ले जाते हैं +<। (संवादी सम्मेलन के लिए, हम मूल मेमोरी सेल को सेल 0 के रूप में कहेंगे, कोशिकाओं को उत्पत्ति 1, 2 के दाईं ओर, ... और कोशिकाओं को बाईं ओर -1, -2, ...)। सेल -1 में SMBF और 0 में BF में अंतिम वर्ण का एससीआई कोड होता है, इसलिए जब अगला [सामने आता है, तो केवल ]बीएमबी अगले में कूदता है जबकि एसएमबीएफ कोड में गुजरता है।

SMBF ट्रैवर्स के अनुसार [.>-]यह पॉलीग्लॉट के अंत में पाए गए 6 प्रिंट करता है और फिर मेमोरी पॉइंटर को सेल 0 पर वापस ले जाता है, जिससे इसका मान वापस शून्य से बाहर निकल जाता है ]। समीक्षा करने के लिए, इस पिंट पर टेप हैं: एसएमबीएफ की नकारात्मक कोशिकाएं पॉलीग्लॉट रखती हैं, और यह 0 है और सकारात्मक कोशिकाएं शून्य रखती हैं। बीएफ की नकारात्मक और सकारात्मक कोशिकाएं शून्य रखती हैं जबकि यह मूल कोशिका 1 है।

इसके बाद >SMBF को सेल 1 और BF को सेल 0 में वापस ले जाता है, जिससे BF को यह निजी कोड ब्लॉक करने की अनुमति मिलती है: [<+++++[>++++++++++<-][<<<]>+.---.>](मैंने इसमें से गैर-बीएफ वर्ण हटा दिया है)। यहां, हम सेल -1 में वापस जाते हैं और अपने लूप कंट्रोल वैरिएबल (सेल -1) को 5. के मान से आरंभ करते हैं। फिर हम लूप में प्रवेश करते हैं, जहां हम सेल में 10 जोड़ते हैं और लूप से बाहर निकलने से पहले सेल को पांच बार घटाते हैं। हम सेल -1 पर 0 के मान से इंगित करेंगे।

अगला हम [<<<]शून्य पर इंगित करते हुए मुठभेड़ करते हैं, इसलिए बीएफ इस से नहीं गुजरता है। यहाँ उद्देश्य >पूर्ववर्ती के साथ कई की संख्या को संतुलित करना है, <इसलिए Perl6 त्रुटि नहीं करता है।

इस बिंदु पर सेल 0 का मान 51 है। 4 का एएससीआई मान 52 है, इसलिए हम पॉइंटर को सेल 0 ऐड 1 में ले जाते हैं, फिर वैल्यू प्रिंट करते हैं। और अंत में, हम सेल 0 को ascii वर्ण 1 पर वापस घटाते हैं और पिछले से बाहर निकलने के लिए सेल 1 (मान 0) के लिए मेमोरी पॉइंटर सेट करने से पहले फिर से प्रिंट करते हैं ]।

SMBF और BF दोनों ने [अगली बार लाइन 8 पर बाजी मारी जबकि दोनों 0 मूल्य पर आराम कर रहे हैं। इस प्रकार, दोनों शेष मिनीमल -2 डी कोड से आगे कूदते हैं जब तक कि ]लाइन 11 पर सामना नहीं किया जाता है। लेकिन यह बहुत कम समय तक रहता है क्योंकि लाइन 12 एक दूसरे के साथ शुरू होती है [जो दोनों भाषाओं को लगभग पॉलीग्लॉट के अंत तक ले जाती है जहां कोई और निर्देश नहीं आते हैं।

Refactors

मिनिमल-2 डी

मिनिमल -2 डी का री-राइट ज्यादातर BF के गुणन ट्रिक के समान कुछ बाइट्स को बचाने के लिए था। मिनिमल-2 डी हालांकि नहीं है [और ]लूप नियंत्रण के लिए वर्ण। इसके बजाय इसमें ये कमांड हैं:

/   Skips next instruction if the data pointer is set to 0.
U   Tells the program to switch to the up direction of processing instructions.
D   Tells the program to switch to the down direction of processing instructions.
L   Tells the program to switch to the left direction of processing instructions.
R   Tells the program to switch to the right direction of processing instructions.

इनका उपयोग उसी तर्क संरचना का निर्माण करने के लिए किया जा सकता है, जैसे कि एक 2D मनोर में, BF के रूप में। उदाहरण के लिए, बीएफ के ++++++[>++++++<-]>.के बराबर है इस मिनिमल-2 डी में।

यहां पॉलीग्लॉट में मिनिमल -2 डी के कोड का एक सरलीकृत संस्करण है, जिसमें सभी बाहरी कोड हटा दिए गए हैं और सभी जगह वाले वर्णों को बदल दिया गया है #।

###################D
###R+++++[D>+++++++L
###>
D>#U/-<+++L)
R+.----.R

Dपंक्ति 1 में करने के लिए नीचे भेजता अनुदेश सूचक Lबहुभाषी जो बाईं ओर सूचक भेजता की लाइन 8 में। यहां हम लूप नियंत्रण चर (सेल 0) को 7 पर सेट करते हैं, मेमोरी पॉइंटर को सेल 1 में ले जाते हैं और एक लूप दर्ज करते हैं। लूप में, हम 3 को सेल 1 में जोड़ते हैं, सेल में 0 घटाते हैं, फिर देखें कि सेल 0 की वैल्यू अभी तक शून्य है या नहीं। यदि नहीं, तो हम एक और 8 को सेल 1 में जोड़ते हैं फिर गिरावट और फिर से जांच करते हैं। इस लूप का परिणाम सेल 1 है मान लूप के अंत में 51 पर सेट है (6 * 8 + 3)।

हम लूप से बाहर निकलते हैं U, मेमोरी पॉइंटर को सेल 1 में ले जाते हैं और फिर पॉलीग्लॉट की लाइन 11 पर दाईं ओर नीचे जाते हैं। और अंत में, हम 4 के लिए एएससीआई मूल्य तक की वृद्धि करते हैं, फिर प्रोग्राम को समाप्त करने के लिए दाईं ओर चलने से पहले 0 के लिए एएससीआई मूल्य तक घटाते हैं।

रेटिना

रेटिना की बहुत सारी आवश्यकताएं थीं जो सभी बीएफ डेरिवेटिव के लिए काम करना मुश्किल था। यह लगातार +या बेमेल ()या पसंद नहीं करता है []। लेकिन ये वास्तव में हर दूसरी पंक्ति के लिए केवल आवश्यकताएं हैं, इसलिए बीएफ, एसएमबीएफ और मिनिमल -2 डी के लिए बहुत सारे काम कोड के थोक को समान संख्या में डालने के लिए घूमते हैं।

एक बाइट केवल रेटिना के लिए पूरी तरह से प्रतिबद्ध है, |जो कि लाइन 11 के अंत में है। @ ais523 को उद्धृत करने के लिए "सबसे अधिक regexes | कुछ भी मैच होगा ”। इसके बिना, रेटिना 0. लौटाता है। यह इसे क्यों ठीक करता है, मुझे नहीं पता। मुझे रेटिना में बहुत ज्यादा खुदाई नहीं करनी पड़ी, शायद इसलिए कि मैं लंबी लाइन से बचता रहा हूं। लेकिन प्रस्तावना की तरह, मैंने पाया है कि मुझे इसे समझने की ज़रूरत नहीं है जितना कि मुझे यह समझने की ज़रूरत है कि इसे कैसे डीबग करना है, इस मामले में ज्यादातर लाइनों को हटाने में शामिल था (2 के गुणकों में) जब तक मैंने लाइन नहीं ढूंढी। जिसके कारण यह टूट रहा है। मैंने @ ais523 की टिप्पणी के आधार पर इस फिक्स का अनुमान लगाया, और पुरस्कृत किया गया। मुझे लगता है मैं स्कूल के लिए बहुत अच्छा हूँ।

कार्डिनल

मैं कार्डिनल के कोड के सापेक्ष मिनिमम -2 डी के @ SnoringFrog के प्लेसमेंट की तरह हुआ। कार्डिनल रेटिना को परेशान नहीं करता है, यह एक अच्छा स्थान है, और यह मिनिमल -2 डी के साथ कुछ हस्तक्षेप करने की अनुमति देता है। इसलिए जब मैंने मिनिमल -2 डी को 2 डी भूमि पर ट्रांसप्लांट करने के लिए सेट किया, तो मैं कार्डिनल को सवारी के लिए लाया। हालांकि कार्डिनल में कुछ कॉस्मेटिक बदलाव हुए थे। सबसे पहले, मैंने अपने लूप / सेकंड के भीतर मेमोरी पॉइंटर्स को बदलने के लिए मिनिमल -2 डी के लिए >अपने बयान की शुरुआत के करीब फेंक दिया, मैंने #p x%>~~~+ +~*ttt*.xमिनिमल -2 डी रूम देने के लिए सब कुछ एक पात्र को दाईं ओर स्थानांतरित कर दिया, ताकि यह लूप इनायत से बाहर निकल सके। pइस स्टिंग में इस चरित्र गद्दी के लिए है।

Befunge / 98

Befunges वास्तव में हैं, जहां मैंने पॉलीगोट को नीचे गिराने की कोशिश शुरू कर दी थी, क्योंकि C ++ रिफ्लेक्टर ने इस को छोड़कर अन्य सभी 2D लैंग कोड को बदल दिया था। इस कोड में डब्ल्यूटीएफ सीखने की कोशिश कर रहा था, मुझे यह बेगुन प्रलेखन में मिला:

.आदेश ढेर और एक दशमलव पूर्णांक के रूप में यह उत्पादन बंद एक मूल्य, पॉप जाएगा फिर एक रिक्ति कुछ हद तक आगे की तरह,। ,कोई मान पॉप करेगा, इसे किसी वर्ण के ASCII मान के रूप में व्याख्या करेगा, और उस वर्ण को आउटपुट करेगा ( किसी स्थान के बाद नहीं ) ।

सबसे पवित्र स्थान! हम आउटपुट पर नल बाइट्स को साफ कर सकते हैं। इसके बाद, यह सब सिर्फ बड़े asci मानों को इनपुट करने और कोड को अलग करने के बारे में पता लगाने का एक मामला था। Befunge-98 में एक जंप कोड था , जिसमें ;कहा गया था कि वह अंदर छोड़ दें , जिससे हमें अलगाव हो गया।[77*,68*,@;[77*,68*,@;'1,'1,q

Befunge-98 'में अगले चरित्र के एससी कोड लेने के लिए एक कमांड ( ) भी था । तो, '1,चरित्र के लिए कोड asci कोड लेता है 1, इसे स्टैक पर रखता है और फिर स्टैक पर शीर्ष मान के लिए ascii वर्ण प्रिंट करता है ,। बस इसे 11 बार प्रिंट करने के लिए दो बार करें और qसुंदर तरीके से छोड़ने के लिए ड्रॉप करें ।

Befunge उचित थोड़ा कम सुविधाजनक है, लेकिन केवल। यहां हमें स्टैक पर वांछित कोड डालने के लिए गणना करनी होगी। सौभाग्य से, समान आउटपुट कमांड से पहले हमारे कोड आसानी से 7 * 7 और 6 * 8 से गुणा किए गए थे ,। तब हम @अपने बड़े भाई के कोड को आउटपुट से दूषित करने से पहले Befunge से बाहर निकल गए ।

Minkolang

Befunge की अनुगामी जगहों के लिए एक फिक्स को खोजने के बाद मैं Minkolang को ठीक करने के विचार पर बहुत अधिक सम्मोहित हो गया और Minkolang के प्रलेखन ने कहा कि इस बिंदु तक Befunge दुभाषिया के समान काम करने तक आउटपुट कमांड का उपयोग किया गया था। Oएक अन्य आउटपुट कमांड के रूप में प्रलेखित होने के लिए हुआ, जिसे इस बगेनगेस-नेस को साझा करने के रूप में वर्णित नहीं किया गया था, इसलिए मैंने बस अंधेरे में एक शॉट लिया और स्ट्रिंग को आउटपुट करने की कोशिश की "3"। निर्दोष विजय।

> <>

मिनिमल -2 डी कोड को स्थानांतरित करते समय मैंने जिन चीजों को देखा, उनमें से एक यह सत्यापित कर रहा था कि मैं इसके साथ> <> स्थानांतरित कर सकता हूं। अगर मैं 2 डी बहुपत्नी पारगमन के साथ सौदा करने जा रहा था, तो मैं सभी अपराधों से निपटने जा रहा था। मैंने मूल रूप से भाग्य को ;n4 1 पंक्ति के अंत में डालने और पंक्ति 1 में \Dआगे बढ़ने के समाधान में अपना रास्ता छोड़ दिया । BTW, मुझे नहीं पता था कि> <> उत्तर 40 से पहले नीचे निर्देशित किया जा सकता है क्योंकि यह बहुत अच्छी तरह से निहित है । मुझे लगता है कि यह बाद में इस्तेमाल किया जा सकता है> <> एक और इसी तरह की भाषा से।

Perl6

मैंने <>इस उत्तर में कहीं और Perl6 के कुछ संतुलन के मुद्दों के बारे में बात की है , इसलिए मैं इसे फिर से नहीं जा रहा हूं। लेकिन मैं यह बताना चाहता हूं कि मैं #>27.say#दूसरी से अंतिम पंक्ति में चला गया। इस उत्तर में इसका कार्यात्मक उद्देश्य नहीं है। मैंने वास्तव में एक अलग जवाब को संतुष्ट करने के लिए यह कदम उठाया था जो कि मैंने इस दौर का उपयोग नहीं किया था। जब से मैं अपने अगले अवसर पर उस उत्तर को पोस्ट करने की योजना बना रहा हूं, तब से मैंने इसे छोड़ने का फैसला किया और मैं इसे फिर से करना और फिर से परेशान नहीं करना चाहता था।

कंप्यूटर प्रोग्राम या प्रणाली में बग को दूर करना

05as1e

05as1e निश्चित रूप से नए Begunge कोड को पुराने संस्करण जितना पसंद नहीं करता था। मुझे लगता है कि यह ,केवल क्रांतिकारी चरित्र है। किसी भी घटना में, मुझे "आक्रामक आदेशों को छिपाने के लिए पंक्ति दो में आगे बढ़ना पड़ा , और मुझे पता था कि दोनों भाषाओं में हां-ओप "होने से पहले बेफुंज कोड पथ पर जाना पड़ा था "। (मैं बस हाँ-ऑप राइट की तरह शब्द बना सकता हूं?) लाइन 2 की 2- <डाइमेंशनलिटी बहुत कठोर है, लेकिन मैं इससे पहले बेगंज के कोड पाथ को विस्थापित करने में सक्षम था "। <तथापि Perl6 की एक आवश्यकता थी। (यह एक <पूर्ववर्ती सब है >।) मैं <सहज और foreknowledge द्वारा 05ab1e और Perl6 की असहमति को हल करने के लिए एक स्थान पर लाइन में एक ड्रॉप करने में सक्षम था ।

चक्कर

लाइन 2 पर बीफुंज परिवर्तन 1ने हादसा / भँवर लाइन से पहले पॉलीग्लॉट में एक अतिरिक्त जोड़ दिया । इस अतिरिक्त 1कारण ने व्हर्ल को पहिया पर गलत निर्देशों की ओर इशारा करना शुरू कर दिया। 1C / C ++ के प्रीप्रोसेसर निर्देश में बहुत पहले कोड में केवल एक पंक्ति संख्या संदर्भ था, और यह आसानी से किसी भी अन्य पंक्ति संख्या के रूप में हो सकता है, इसलिए मैंने 4व्हर्ल को संतुष्ट करने के लिए इसे मनमाने ढंग से बदल दिया ।

घटना

पॉलीग्लॉट के अंत में डिटोकेनाइजिंग स्ट्रिंग इस बिंदु पर अच्छी तरह से जाना जाता है, इसलिए मैं इसमें नहीं जाऊंगा। मैंने उस स्ट्रिंग से हटा दिया जो मैं कर सकता था और आवश्यक नए टोकन जोड़े। 2 अलग-अलग वर्ण हैं जो इस स्ट्रिंग में नहीं हैं, हालांकि मुझे इंगित करना चाहिए। सबसे पहले, दूसरे Rमें #R+.----.R >]|यहाँ की जरूरत है, क्योंकि यह एक फ्यूजन प्रारंभिक बिंदु है, और यह इस लाइन क्योंकि वहाँ पहले से ही एक ही दिशा में एक फ्यूजन प्रारंभिक बिंदु शीर्षक था पर सुरक्षित था। दूसरा, xमें #= xएक टोकन एक में शामिल दूर करने के लिए है ␉␊#पैटर्न है, जो आम हो गया है।

अन्य

हेक्सागोनी, व्हॉट्सएप और प्रस्तावना सभी में सामान्य मामूली समायोजन था, लेकिन बात करने लायक कुछ खास नहीं था।

अंतिम विचार

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

— मोका
स्रोत
इंसिडेंट में विफल रहता है (यह 3333तब इनपुट के लिए इंतजार करता है) प्रिंट करता है, लेकिन आसानी से ठीक होने की संभावना है। समस्या यह है कि आप एक टोकन (रखा है है -]) के बाद^- टोकन है कि पहले कार्यक्रम के अंत में जाने के लिए इस्तेमाल किया गया था। अन्य दो उपयोग -]लगातार होते हैं, जिससे कि एक… xx… x… पैटर्न बनता है, जो एक बैकवर्ड जंप है। -]थोड़ी देर पहले (या ^_सा बाद में, या दोनों), जो पिछले चल रहा है , हालांकि, काफी आसान होने की संभावना है।
@ ais523 धन्यवाद यह वही है जो मुझे लिखते समय गोल्फ के लिए मिलता है। हमेशा हादसे वाले बच्चों की जांच करना याद रखें। सौभाग्य से मैं इसे घटाव के साथ जोड़कर ठीक करने में सक्षम था, इसलिए कुल मिलाकर मुझे लगता है कि जीत।
— मौका
1
यदि आप वी के साथ -v(क्रिया के लिए) चलाते हैं, तो आप शाब्दिक एस्केप चार्जर को बदल सकते हैं <esc>, जो भविष्य में कोड के साथ काम करना थोड़ा आसान बना सकता है। (मुझे लगता है)
— पावेल
वाह! धन्यवाद @ ais523 इनाम के लिए सोमवार सुबह शुरू करने का एक शानदार तरीका क्या है!
— संभावना
Befunge-98, Befunge-93 से पुराना है?
— कैलक्यूलेटरफल
17

183. इंटेल 8080 बूट छवि (ZEMU), 9870 बाइट्स

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

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

व्याख्या

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

मैंने CP / M COM फ़ाइल नहीं की क्योंकि यह पॉलीग्लॉट के आकार को लगभग 60KB तक सीमित कर देता है जिससे मैं बचना चाहता हूँ। COM की तुलना में बूट इमेज और भी आसान हो गई क्योंकि ZEMU डिफ़ॉल्ट रूप से 6 सेक्टर से बूट सेक्टर को लोड करता है (1-आधारित, 128 बाइट लॉजिकल सेक्टर), इसलिए पॉलीग्लॉट की शुरुआत को निष्पादित करने की आवश्यकता नहीं है। पॉलीगोट में बूट कोड ऑफसेट 0x280 ((6-1) * 128) पर होना चाहिए।

मैं ZEMU एमुलेटर का उपयोग करता हूं जो इस पृष्ठ से जुड़ा हुआ है । ZEMU में बहुभुज चलाने के लिए:

  • डिस्क> ए: पॉलीग्लॉट फ़ाइल चुनें
  • विकल्प> निर्देश सेट I8080
  • बूट बटन दबाएं

फ़ंक्शन जो कंसोल को एक cns$otचार्ट प्रिंट करता है ( ) ZEMU वितरण से BIOS22Dv221.ASM से कॉपी किया गया था। मैंने दो बदलाव किए: चरित्र 7 बिट ASCII के लिए नकाबपोश नहीं है क्योंकि हम मापदंडों को नियंत्रित करते हैं और jrz cns$otइसके साथ प्रतिस्थापित किया जाता है jz cns$otक्योंकि jrz(शून्य के सापेक्ष सापेक्ष) Zilog Z80 निर्देश इंटेल 8080 में मौजूद नहीं है।

प्रारंभिक कार्यक्रम ( इंटेल सिंटैक्स , कोडांतरक यहां से जुड़ा हुआ है ):

    org 3120h    ; chosen so that cns$ot == 0x3131, easier to generate
                 ; this program will be generated at this offset
                 ; to run it directly specify org 0100h

    mvi c,31h    ; '1'
    call cns$ot
    mvi c,38h    ; '8'
    call cns$ot
    db 38h       ; for answer 188, NOP in I8080
    mvi c,33h    ; '3'
    call cns$ot
    hlt          ; halt processor

;;;;;;;;; copied from BIOS22Dv221.ASM
cno$sp equ 7dh
cno$sb equ 01h
cno$si equ 00h
cno$dp equ 7ch

; print char to console, receives char in c register
cns$ot:
    in cno$sp    ; in status
    xri cno$si   ; adjust polarity
    ani cno$sb   ; mask status bit
    jz cns$ot    ; repeat until ready
    mov a,c      ; get character in a
    out cno$dp   ; out character
    ret

इस कार्यक्रम में ऐसे वर्ण शामिल हैं जिनका उपयोग सीधे पॉलीग्लॉट में नहीं किया जा सकता है। सिमला में अधिकांश ASCII नियंत्रण वर्ण (कोड <0x20) निषिद्ध हैं, गैर- ASCII वर्ण (कोड> = 0x80) अकेले दिखाई नहीं दे सकते क्योंकि फ़ाइल को मान्य UTF-8 होना चाहिए। तो उपरोक्त प्रोग्राम एक अन्य प्रोग्राम द्वारा उत्पन्न होता है जो कि UTF-8 मान्य है।

निम्न प्रोग्राम आवश्यक कोड उत्पन्न करता है और इसके लिए कूदता है। ld (hl),aघास ( 'w'==0x77) के कारण उपयोग नहीं किया जा सकता है । sub h(0x94) और xor a(0xAF) UTF-8 की निरंतरता बाइट्स हैं, उन्हें UTF-8 लीड बाइट के साथ तैयार किया जाना चाहिए। निर्देश ret nc(= 0xD0, यदि नहीं ले तो वापसी) का उपयोग UTF-8 लीड बाइट के रूप में किया जाता है। इसे करने के लिए कुछ भी नहीं यह scfनिर्देश (सेट कैरी फ्लैग) के साथ है। ','DOBELA के लिए भी (0x2C) और '.'(0x2E) से परहेज किया। org 0100hनिर्देश का उपयोग नहीं किया जाता है क्योंकि उपयोग किए गए कोडांतरक इसे समझ नहीं पाते हैं (org जीयूआई में सेट किया गया है)। यह कार्यक्रम वैसे भी स्वतंत्र है। मुझे Zilog mnemonics अधिक पसंद है, इसलिए मैंने उन्हें लंबे समय तक प्रोग्राम के लिए उपयोग किया।

Zilog सिंटैक्स , असेंबलर यहाँ से जुड़ा :

  ; generate: 0E 31 CD 31 31 0E 38 CD 31 31 38 0E 33 CD 31 31 76 DB 7D EE 00 E6 01 CA 31 31 79 D3 7C C9

  ld hl,3120h

  ld a,3Fh
  scf       ; set carry flag so that ret nc does nothing
  ret nc    ; utf8 lead byte for next insn
  sub h     ; a -= h; a = 0Eh;  utf8 cont byte (opcode 0x94)
  ld c,a

  ld (hl),c ; 0Eh    ; not using ld (hl),a because it is 'w'
  inc hl

  ld (hl),h ; 31h
  inc hl

  ld a,32h
  cpl       ; a = ~a; a = 0xCD
  ld d,a
  ld (hl),d ; CDh
  inc hl

  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),c ; 0Eh
  inc hl
  ld (hl),38h ; 38h
  inc hl

  ld (hl),d ; CDh
  inc hl
  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),38h ; 38h
  inc hl

  ld (hl),c ; 0Eh
  inc hl
  ld (hl),33h ; 33h
  inc hl

  ld (hl),d ; CDh
  inc hl
  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),76h ; 76h
  inc hl

  ld a,23h  ; not using ld a,24h because it has '$' (breaks SNUSP)
  inc a
  cpl       ; a = ~a; a = 0xDB
  ld d,a
  ld (hl),d ; DBh
  inc hl

  ld (hl),7Dh ; 7Dh
  inc hl

  ld a,c    ; a = 0Eh
  cpl       ; a = F1h
  dec a
  dec a
  dec a     ; a = EEh
  ld d,a
  ld (hl),d ; EEh
  inc hl

  scf
  ret nc
  xor a     ; a ^= a; a = 0; utf8 cont byte
  ld c,a
  ld (hl),c ; 00h
  inc hl

  ld a,4Ah
  scf
  ret nc
  sub h     ; a -= h; a = 0x19;  utf8 cont byte
  cpl       ; a = ~a; a = 0xE6
  ld d,a
  ld (hl),d ; E6h
  inc hl

  ld a,c
  inc a
  ld d,a
  ld (hl),d ; 01h
  inc hl

  ld a,35h
  cpl       ; a = 0xCA
  ld d,a
  ld (hl),d ; CAh
  inc hl
  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),79h ; 79h
  inc hl

  ld a,2Dh  ; not using ld a,2Ch because it has ','
  dec a
  cpl       ; a = 0xD3
  ld d,a
  ld (hl),d ; D3h
  inc hl

  ld (hl),7Ch ; 7Ch
  inc hl

  ld a,36h
  cpl       ; a = 0xC9
  ld d,a
  ld (hl),d ; C9h

  ld sp,3232h  ; set up stack for generated program

  ld hl,3120h  ; not using ld l,20h because it has '.'
  jp (hl)      ; go to generated program 
               ; confusing mnemonic - actually it is jp hl, ie. PC = HL
               ; opcode 0xE9, utf8 lead byte (0xE9 = 0b11101001), must be followed by 2 cont bytes
  db 80h,80h

इस कार्यक्रम में इकट्ठा किया गया है:

! 1>?7ДOq#t#>2/Wr#t#t#q#68#r#t#t#68#q#63#r#t#t#6v#>#</Wr#6}#y/===Wr#7ЯOq#>J7Д/Wr#y<Wr#>5/Wr#t#t#6y#>-=/Wr#6|#>6/Wr122! 1退

यह पॉलीग्लॉट में 0x280 ऑफसेट होना चाहिए (पंक्ति 2 देखें)। परीक्षण चालक में अमूर्तता परीक्षण जाँच करता है कि।

refactorings

गोले

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

Grass  Moorhenses  Flaks  Shells  Rubies/Pythons/Perl5  PicoLisp  Prelude  Klein001

नए गोले कोड:

a=$(printf \\x00)
b=$(echo -n $a | wc -c)
case $b[1] in 1*)echo 54;; 4*)echo 78;; 8*)echo 166;; *1*)echo 50;; *)echo 58;; esac
exit

पुराने गोले कोड:

a=$(printf \\x00)
b=${#a}
case "{"$ar[1]"}"${b} in *1)echo 54;; *4)echo $((19629227668178112600/ 118248359446856100));; *1*)echo 50;; *)echo 58;; esac
exit

लंबाई की $aगणना $(echo -n $a | wc -c)अब ( यहां से ) की जाती है। प्रारंभ में मैंने इससे छुटकारा पाने के लिए इसका उपयोग किया था #, लेकिन अब इसका उपयोग छोटे कोड के कारण किया जाता है। गोले शामिल #हो सकते हैं क्योंकि Flaks गोले से पहले हैं।

यश (166) अंतर्निहित इको कमांड का उपयोग करता है जो डिफ़ॉल्ट रूप से विकल्पों का समर्थन नहीं करता है, इसलिए "-n" और लाइनफीड अंत में आउटपुट का हिस्सा है, जो अतिरिक्त 4 बाइट्स देता है। जब ECHO_STYLEडिफ़ॉल्ट को सेट नहीं किया जाता है SYSV( -nविकल्प स्वीकार नहीं किया जाता है)।

यह TIO लिंक सभी गोले में कोड का परीक्षण करता है।

अतिरिक्त (((((गोले अंडरलोड और रेटिना को ठीक करते हैं। 58प्रील्यू ( #)बाद के साथ बंद exit) से छिपाने के लिए एक और जोड़ी जोड़ी गई है । {पहले ((((((जाप के लिए है, इसके बिना जाप लटका हुआ है।

Flaks

फ्लैक्स शुरू होने के कारण कोड को सरल बनाया जा सकता है - केवल ([])बचा है:

     line 21      (Grass(([5]{})))    scripting langs                  clear stack     Flaks main code                                                                                      begin skip code      the rest of polyglot   end skip code   print(85)
old: []{}[][][]   ((([]{})))          ((()()<<()>>)((()([])))<<()>>)   {}{}{}{}{}{}{}  ({}<(((((()()())){}{})){}{})>)(({})){}{(<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)   (<><()>){({}[()])}{           ...           }{}<>              ()
new: []{}[][][]     ([]  )                                                             ({}<(((((()()())){}{})){}{})>)(({})){}{(<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)   (<><()>){({}[()])}{           ...           }{}<>              ()

यह TIO लिंक सभी फ्लैक्स में कोड का परीक्षण करता है।

विखंडन और कार्डिनल

विखंडन LNUSP में ले जाया गया था R"12"R _*:। दूसरे पॉइंटर का उपयोग विखंडन को जल्द से जल्द समाप्त करने के लिए किया जाता है - तीसरे चरण पर, अधिक जानकारी के लिए उत्तर 54 देखें ।

कार्डिनल को एलएनयूएसपी में स्थानांतरित किया गया था @ %"18":। जैसे कि विखंडन में, दूसरे पॉइंटर का उपयोग कार्डिनल को जितनी जल्दी हो सके समाप्त करने के लिए किया जाता है - तीसरे चरण पर।

MarioLANG

एक मंच ####...के ====...रूप में उपयोग करें :

यहां छवि विवरण दर्ज करें

मिनिमल-2 डी

मारियोलैंग के साथ बहुवचन:

यहां छवि विवरण दर्ज करें

Wierd और 1L_a

Wierd: IP दर्शाने के लिए लाइन 10 कॉलम 79 पर स्थान का उपयोग करें।
1L_a, Wierd: पंक्ति 9 कॉलम 79 पर स्थान महत्वपूर्ण है।

यहां छवि विवरण दर्ज करें

Cubically

नया कोड: :1*23!/5x%6E0

:1*23!/5x%6E0
! - skip over / in Klein 201
x - destroy Cardinal pointer before it hits /

pure:
:1*23/5%6E0

faceval:
0 0
1 9
2 18
3 27
4 36
5 45

program:
:1   mem = 9
*23  mem *= 18; mem *= 27
/5   mem /= 45
%6   print mem
E0   exit

9*18*27/45 == 97 (integer division)

6 in %6 is used to print mem because 0-5 are used to print faceval (eg. %3 prints 27)
0 in E0 is not an exit code, it is present just to trigger E instruction

क्लेन 201/100

नया कोड: !|*****[[[828+*+@+*99]]]*****|!

सभी गुणा के बाद स्टैक में एक शून्य होता है क्योंकि खाली स्टैक से पॉपिंग शून्य देता है। इस शून्य को +अगली संख्या के साथ मुख्य संख्या में जोड़ा जाता है @। पहले इसे साथ छोड़ दिया गया था ?, क्लेन 001 उत्तर देखें ।

क्लेन में दरवाजे कैसे काम करते हैं:

यहां छवि विवरण दर्ज करें

चक्कर

व्हर्ल कोड मूल रूप से एक ही है, एकमात्र बदलाव यह है कि मुख्य कोड मानता है कि वर्तमान ऑपरेशन ऑप्सोन (2) है, न कि ऑप्सोड (4)।

प्रभावी रूप से व्हर्ल के 3 ऑपरेशन होने के बारे में सोचा जा सकता है:

  • 1 एक कदम घुमाएं
  • 0 रोटेशन की दिशा स्विच
  • 00 वर्तमान अनुदेश और स्विच रिंग निष्पादित करें

कार्यक्रम के बारे में तर्क को आसान बनाने के लिए संयुक्त अभियान:

  • 0000 यदि निष्क्रिय रिंग का वर्तमान ऑप नॉप है, तो किसी भी साइड इफेक्ट के बिना सक्रिय रिंग के वर्तमान ऑप को निष्पादित करें
  • 11..11 एन चरणों को घुमाएं
  • 011..11 दिशा स्विच करें और एन चरणों को घुमाएं

0000सक्रिय रिंग के वर्तमान निर्देश को निष्पादित करता है, लेकिन साइड इफेक्ट के रूप में निष्क्रिय रिंग के वर्तमान निर्देश को भी निष्पादित करता है। यदि निष्क्रिय रिंग का वर्तमान निर्देश हानिरहित है तो हम निष्क्रिय रिंग के साथ क्या हो रहा है, यह सोचे बिना हम सक्रिय रिंग के संचालन पर ध्यान केंद्रित कर सकते हैं। यह इस कार्यक्रम के साथ विशेष रूप से उपयोगी है क्योंकि इसमें स्पष्ट पृथक्करण है: पहले 32 नंबर केवल गणित की अंगूठी का उपयोग करके बनाया गया है और फिर हम ऑप्स रिंग में स्विच करते हैं और वहां 2 निर्देशों (प्रिंट और एक्जिट) को निष्पादित करते हैं।

पहले मैं ऑप्स रिंग पर वर्तमान ऑपरेशन करना चाहता था, जब मुख्य कोड निष्पादित करना शुरू हो जाता है। इसके 2 फायदे हैं: 1) मुख्य व्हर्ल कोड को स्टैंडअलोन निष्पादित किया जा सकता है और 2) हम गणित की अंगूठी के साथ नंबर 32 बनाते समय ऑप्स रिंग के बारे में पूरी तरह से भूल सकते हैं। हालाँकि, यह कोड को उसके मुकाबले अधिक लंबा बनाता है, इसलिए मुख्य कोड मानता है कि वर्तमान ऑपरेशन ऑप्सोन (2) है। इसका मतलब यह है कि ऑप्सवैल्यू गणित के संचालन के साइड इफेक्ट के रूप में 1 पर सेट है, जो तब मुद्रण के लिए उपयोग किया जाता है। पुराने कोड ने ops.load निर्देश के साथ समान प्रभाव प्राप्त किया, लेकिन ops.one का उपयोग अधिक स्पष्ट रूप से इरादा व्यक्त करता है - ops.value को नॉनज़ेरो में सेट करने के लिए।

at this point current ring is ops, dir = clockwise, cur op = ops.one
00    switch to math ring
011   rotate to math.not
0000  math.not (math.val = 1)
01111 rotate to math.store
0000  math.store (mem[0] = 1)
1     rotate to math.add
0000  math.add (math.val = 2)
01    rotate to math.store
0000  math.store (mem[0] = 2)
011   rotate to math.mult
0000  math.mult (math.val = 4)
0000  math.mult (math.val = 8)
0000  math.mult (math.val = 16)
0000  math.mult (math.val = 32)
011   rotate to math.store
00    math.store (mem[0] = 32), switch to ops ring
up to this point the program is the same as before

01111 rotate to ops.intio
0000  ops.intio - print mem[0] as number
0111  rotate to ops.exit
00    ops.exit

नया कोड कम है क्योंकि पुराने कोड में प्रोग्राम के दूसरे भाग में अनावश्यक दिशा स्विच की एक जोड़ी है, नई धारणा के कारण नहीं।

old: (1111) 00011000001111000010000010000011000000000000000001100 01111110000011100
new: (11)   00011000001111000010000010000011000000000000000001100   011110000011100

हादसा / व्हर्ल लाइन से पहले कुछ बदलते समय व्हर्ल को सही कैसे रखें:

  • सुनिश्चित करें 0कि मुख्य व्हर्ल कोड से पहले भी संख्याएँ हैं
  • सुनिश्चित नहीं लगातार दो देखते हैं 0रों
  • 1व्हर्ल के फिर से काम करने तक पर्याप्त एस जोड़ें / निकालें ; n 1s जोड़ना 12-n 1s और इसके विपरीत को हटाने के बराबर है

मैंने अनजाने में पहला नियम तोड़ा जब रोपी गयी। जब विषम संख्या में 0मुख्य कोड ऑप्स रिंग की गलत दिशा के साथ निष्पादित होने लगते हैं जो निकास निर्देश को तोड़ता है। तो अब 0लाइन 3 पर है जो 0लाइन 1 पर क्षतिपूर्ति करता है।

अन्य

CoffeeScript : console.log a&&39||180( यहाँ से )

INTERCAL : लाइन 37
ब्रेनफक में ले जाया गया , Agony : लाइन 10 पर अन्य ब्रेनफैक डेरिवेटिव में ले जाया गया

xEec : 1L_a ( h#115# o#) में स्थानांतरित किया गया

CSL : लाइन में ले जाया गया 80
ट्रेफुंज : लाइन 120
गोट ++ तक ले जाया गया , पत्थर : अलग लाइनों पर रखा गया

— stasoid
स्रोत
4
अच्छा है, कि गोल्फ के लिए बहुत सारे बाइट्स हैं।
— आलू १४
16

16. अजगर (159 बाइट्स)

#v\;2^0\;7||"<+0+0+0+<*!2'!1'L#'1r'4;n4
#v0#_q@
#>3N.15o|1
#|\w*
#8  ^<1b0 <
#|
#M`
print ((0 and'13')or(None and 9 or 1/2 and 1 or 5))
#"07|5//00;16 "jd5ki2

नोट: तीसरी पंक्ति के बाद और अंतिम पंक्ति में एक ESCबाइट ( 0x1B) है ।oj

यह काफी मजेदार अनुभव था। जाप और पाइथ दोनों गोल्फ की भाषाएं हैं, लेकिन जैप इन्फिक्स है और पाइथ उपसर्ग है, और पाइथ ऑटो-रिक्वेस्ट इनपुट और विफल रहता है यदि तर्क गायब हैं।

हेस्टैक उत्तर से पहले मेरे पास लगभग काम करने वाला समाधान था #, जो कि जैप में एक कोड और पाइथ में लूप-अप-त्रुटि के लिए मिलता है। पॉलीगोट्स में पाइथ बहुत उपयोगी होता है, क्योंकि सामान्य टिप्पणी चार #अनिवार्य रूप से एक त्रुटि साइलेंसर के रूप में काम करती है।

जब मैं घर गया, तो मैंने इस कोड का एक टुकड़ा ढूंढने में कामयाबी हासिल की //, जो दोनों का उपयोग करने में काम आया , जो जाप में एक टिप्पणी और पाइथ में दो डिवीजनों के रूप में काम करता है। तब बीफंग्स को सही तरीके से प्राप्त करने के लिए यह सिर्फ एक मामला था।

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

प्रिंट 1 में पायथन 3 , वी में 2 , मिंकोलंग में 3 , में 4> <> , 5 में पायथन 2 , 6 में सेल्फ-मॉडिफाइंग ब्रेनफक , 7 में जाप , 8 में रेटिना , 9 में पर्ल , 10 में बेफुज (-93) ) , 11 में बेफ्यूज -98 , 12 में विखंडन , 13 में रूबी , 14 में टर्टल , 15 में हैस्टैक , और

पायथ में 16 ।

व्याख्या

पायथ यहाँ क्या देखता है:

#v\;2^0\;7||"string
multiline
string"07|5//00;16 "string

यह निम्नलिखित छद्मकोश का अनुवाद करता है:

while no errors occur:
    evaluate ";"
    print 2
    print 0 to the power ";"
    print 7
    print "string\nmultiline\nstring" or 0 or 7
    print 5 or 0 divided by 0 divided by (missing)
print 16
do nothing with "string"

पहला लूप मूल्यांकन करने की कोशिश करता है ;जो एक वैध अभिव्यक्ति नहीं है। तब पायथ सिर्फ प्रिंट करता है 16।

— PurkkaKoodari
स्रोत
किस तरीके से बढ़ा? मुझे अभी भी अपने जवाब के लिए एक और 5 या इतनी बाइट्स उपलब्ध हैं;)
— अल्फी गुडाक्रे
@AlfieGoodacre पोस्ट में बाकी विवरण जोड़कर। मैं बस समझदार रहना चाहता था और इस तरह किसी ने भी मेरी जगह चुरा लेने से पहले अपना कोड पोस्ट कर दिया। : D
— PrakkaKoodari
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.