30 भाषाएं, 248 बाइट्स, 248/30 ^ 3 = 0.009185
#|#?15g,@ kkmNmSaIeoe99+{\#/-;n@0ea
#[9!@>.>.eeaww#-1@*"12" L
#{
###
#`{
25
print(4^2 +7)/2
"""
Jo is here.
$'main'MoO OOM
7
>Jo, 30
>X Jo
f::=~27
::=]##}#(prin 29)
print (7/6*24)###;alert 2#-[>+<-----]>-.|#(write(if(= 1/5 .2)26 3))"""
संपादित करें: बीटनिक में मौलिकता परीक्षण के बाद से बीटनिक को हटाया नहीं जा सकता है।
कोड में टैब हैं (जो स्टैक एक्सचेंज द्वारा मंगवाए गए हैं) और एक अनुगामी न्यूलाइन है, इसलिए यहां निम्नलिखित है xxd:
00000000: 237c 233f 3135 672c 4020 2020 0920 2020 #|#?15g,@ .
00000010: 206b 6b6d 4e6d 5361 4965 6f65 3939 2b7b kkmNmSaIeoe99+{
00000020: 5c23 2f2d 3b6e 4030 6561 0a23 5b39 2140 \#/-;n@0ea.#[9!@
00000030: 3e2e 3e2e 6565 6177 7723 2d31 402a 2231 >.>.eeaww#-1@*"1
00000040: 3222 094c 0a23 7b20 090a 2323 230a 2360 2".L.#{ ..###.#`
00000050: 7b0a 3235 0a70 7269 6e74 2834 5e32 202b {.25.print(4^2 +
00000060: 3729 2f32 0a0a 0a22 2222 0a4a 6f20 6973 7)/2...""".Jo is
00000070: 2068 6572 652e 0a24 276d 6169 6e27 4d6f here..$'main'Mo
00000080: 4f20 4f4f 4d0a 2037 0a3e 4a6f 2c20 3330 O OOM. 7.>Jo, 30
00000090: 0a3e 5820 4a6f 0a66 3a3a 3d7e 3237 0a3a .>X Jo.f::=~27.:
000000a0: 3a3d 5d23 237d 2328 7072 696e 2032 3929 :=]##}#(prin 29)
000000b0: 0a70 7269 6e74 2028 372f 362a 3234 2923 .print (7/6*24)#
000000c0: 2323 3b61 6c65 7274 2032 232d 5b3e 2b3c ##;alert 2#-[>+<
000000d0: 2d2d 2d2d 2d5d 3e2d 2e7c 2328 7772 6974 -----]>-.|#(writ
000000e0: 6528 6966 283d 2031 2f35 202e 3229 3236 e(if(= 1/5 .2)26
000000f0: 2033 2929 2222 220a 3))""".
वैकल्पिक रूप से, आप इस कोड को "इसे ऑनलाइन आज़माएं" से कॉपी और पेस्ट कर सकते हैं ! लिंक ।
यह बहुत बुरी तरह से गोल्फ है, लेकिन मैं इस विचार से खेलना चाहता था, एक बार जब आपके पास पर्याप्त भाषाएं होती हैं, तो बाइट काउंट कोई ज्यादा मायने नहीं रखता है। यह कहते हुए कि कुछ भाषाएँ हैं जिन्हें मैं अब भी आसानी से जोड़ सकता हूँ (उदाहरण के लिए ओब्जेक) लेकिन वर्तमान में उपयोगी होने के लिए बहुत लंबा है। मैं हालांकि अच्छी भाषाओं से बाहर चल रहा हूं, इसलिए मैं अब यहां रुक सकता हूं।
</dev/null 2>/dev/null(यानी खाली इनपुट, अधिशेष STDERR) के साथ सभी कार्यक्रम चलाएं ।
स्पष्टीकरण काफी लंबा है, इसलिए यहां एक कार्यकारी सारांश है:
No. Lang. Non-esolang? 2D esolang? BF/BF-deriv?
--------------------------------------------------------------------------
1 COW ✓
2 CoffeeScript ✓
3 Common Lisp ✓
4 Retina
5 Befunge-93 ✓
6 Python 2 ✓
7 Rail ✓
8 ETA
9 Prelude
10 Gol><> ✓
11 evil
12 Foo ✓
13 Ruby ✓
14 ><> ✓
15 Brian & Chuck ✓
16 Whitespace
17 3var
18 Axo ✓
19 Labyrinth ✓
20 Starry
21 Fission ✓
22 Brainfuck ✓
23 Julia ✓
24 Lily ✓
25 GolfScript
26 Chicken Scheme ✓
27 Thue
28 Perl 6 ✓
29 Picolisp ✓
30 TRANSCRIPT
गाय अतिरिक्त आदेशों के साथ एक ब्रेनफॉक व्युत्पन्न है, जिसमें से एक संख्यात्मक आउटपुट है। अमान्य कुछ भी अनदेखा किया जाता है, इसलिए निष्पादित कार्यक्रम केवल है
MoO OOM
जो सेल को 1 तक बढ़ाता है, फिर उसे नंबर के रूप में प्रिंट करता है।
CoffeeScript देखता है:
# comments
###
multiline comment
###;alert 2# comment
जो बस 2 अलर्ट करता है।
(हां, यह बेहतर होगा कि अगर कोई अन्य भाषा इस स्लॉट को लेती है, लेकिन मैं इस बिंदु पर फेरबदल करने के लिए बहुत आलसी हूं: पी)
आम लिस्प (क्लिस्प) देखता है:
#|
multiline comment
|#(write(if(= 1/5 .2)26 3))"""
1/5तर्कसंगत है और नहीं के बराबर है 0.2, इसलिए 3 मुद्रित है। कार्यवाही """एक सिंटैक्स त्रुटि है।
ध्यान दें कि printकॉमन लिस्प में एक पूर्ववर्ती न्यूलाइन और ट्रेलिंग स्पेस का आउटपुट लगता है। हालांकि, सौभाग्य से, writeकॉमन लिस्प और चिकन योजना दोनों में काम करता है।
प्रतिबंध लागू : पहली दूसरी से शुरू होने वाली हर दूसरी पंक्ति को एक वैध रेगेक्स होना चाहिए।
लाइनों की प्रत्येक जोड़ी एक प्रतिस्थापन चरण बनाती है, जो दूसरी पंक्ति के साथ पहली पंक्ति के regex के मैचों के उदाहरणों को प्रतिस्थापित करती है। बीच में, हमारी जोड़ी है
"" "
जो प्रारंभिक खाली स्ट्रिंग को बदलता है """। अंतिम खाली लाइन, किसी भी जोड़ी का हिस्सा नहीं है, इसे मैच चरण के रूप में माना जाता है, रेगेक्स के मैचों की संख्या की गिनती करता है। खाली स्ट्रिंग के चार उदाहरण हैं """, अर्थात् 1"2"3"4।
Befunge एक 2D भाषा है, और प्रासंगिक निर्देश हैं
# # 15g,@
पहली पंक्ति, और में 5में 25लाइन। #अगले निर्देश को छोड़ देता है, 15gकी स्थिति में चार हो जाता है (1, 5)कोड (में 5में 25लाइन), ,चार आउटपुट और @रुक जाता है।
अजगर देखता है:
# comments
25
print(4^2 +7)/2
"""
multiline string
"""
(4^2+7)/2 = (xor(4,2)+7)/2 = (6+7)/2 = 13/2 = 6, जो printएड हो जाता है ।
रेल एक 2 डी भाषा है, और निष्पादन $मुख्य कार्य से शुरू होता है , दक्षिण-पूर्व की ओर बढ़ रहा है। इस प्रकार, कोड का प्रासंगिक हिस्सा है
$'main'
7
o
J
साथ oऔर Jप्रतिलेख द्वारा इस्तेमाल किया लाइनों से आ रही। 7 आउटपुट करने के बाद, ट्रेन एक गैर-मान्यता प्राप्त Jनिर्देश को हिट करती है , जो प्रोग्राम को क्रैश कर देती है।
प्रतिबंध लागू: ईटीए कार्यक्रम से पहले के चार्ट में नहीं होना चाहिए etaoinsh।
ईटीए केवल अक्षरों etaoinshऔर उनके अपरकेस संस्करणों को पहचानता है , जिसका अर्थ कोड के साथ शुरू होता है
NSaIeoe
n...eएक आधार 7 क्या, सीमांकक के भीतर है, जिसके लिए के आधार पर संख्या धक्का SaIहै 624, या दशमलव में 312। oफिर चारु के रूप में आउटपुट, जाहिरा तौर पर मोडुलो 256 के बाद, चार 8(कोड बिंदु 56) देते हुए। eफिर एक खाली ढेर के साथ विभाजित करने की कोशिश करता है, जो विफल हो जाता है।
प्रतिबंध लागू:() किसी भी कॉलम में एक से अधिक नहीं , ()एक समय में एक कॉलम पढ़ने से मेल खाता है, इसके कारण कोई अनंत लूप नहीं है ()।
इसके लिए अजगर इंटरप्रेटर को NUMERIC_OUTPUT = Trueसेट करना पड़ता है।
प्रस्तावना एक ऐसी भाषा है जहाँ प्रत्येक पंक्ति को अलग-अलग निष्पादित किया जाता है। बहुत सारे चार्ट निष्पादित हो जाते हैं, लेकिन महत्वपूर्ण हिस्सा है
9!
दूसरी पंक्ति पर, जो आउटपुट 9 ()में है। प्रस्तावना में लूप निरूपित करता है, लेकिन #एस (जो स्टैक से पॉप) की प्रमुखता के लिए धन्यवाद , स्टैक के सबसे ऊपर हमेशा 0 होते हैं जब तक एक लूप हिट होता है, इसलिए उनमें से कोई नहीं दौड़ में हैं। प्रेलोडे के स्रोत कोड प्रतिबंधों के बारे ()में कुछ बाहरी स्थानों को पेश किया गया है।
यह भाग (और> <>) मार्टिन के उत्तर की तरह काम करता है । प्रासंगिक कोड है
# ;n@0ea
गोल> <> एक 2 डी भाषा है और #आईपी को दर्शाता है, जिससे यह बाईं ओर यात्रा करता है। यह चारों ओर लपेटता है, स्टैक पर 10, 14 और 0 धक्का देता है। @फिर स्टैक को घुमाता है, शीर्ष पर 10 लाता है, nइसे आउटपुट करता है और ;कार्यक्रम को रोक देता है।
यह हिस्सा भी मार्टिन के जवाब के समान है।
बुराई निचले अक्षरों को छोड़कर सब कुछ अनदेखा करती है। कुछ और पात्रों को अनदेखा करना, प्रासंगिक हिस्सा है
aeeeaeeaww
जहां aचर वृद्धि होती है A, eबुराई की बुनाई का कार्य है जो बिट्स को फेरबदल करता है A, और wआउटपुट A। इसलिए हम 1दो बार आउटपुट देते हैं 11।
लेकिन बाकी निर्देशों के बारे में क्या है, और विशेष रूप wसे अंतिम पंक्ति पर? मान लीजिए कि कभी-कभी कोड के साथ खिलवाड़ करना सबसे आसान होता है और प्रार्थना करना अभी भी हर चीज में काम आता है जो, यहाँ, यह किसी तरह किया ...
फू दोहरे उद्धरण चिह्नों के बीच कुछ भी उत्पन्न करता है, इसलिए प्रासंगिक हिस्सा है
"12"
दूसरी पंक्ति पर। हालाँकि, बाद में हमें दोहरे उद्धरण चिह्नों की आवश्यकता होती है, क्योंकि हम फू को त्रुटि मुक्त बनाने के लिए मार्टिन के उत्तर के समान विधि का उपयोग करते हैं, अर्थात् पूर्ववर्ती #-1@। यह स्पष्ट नहीं है कि यह उस भाषा में क्यों काम करता है जो शून्य स्टैक द्वारा खाली स्टैक और विभाजन के चेहरे पर सैनिकों, लेकिन मुझे खुशी है कि यह करता है।
अजगर की तरह, रूबी देखता है:
# comments
25
print(4^2 +7)/2
"""
multiline string
"""
हालांकि, यह देखते हुए कि बहु स्ट्रिंग वास्तव में तीन अलग तार है लायक है ( "", "...", "") एक साथ concatenated। 2 (4^2+7) = xor(4,2)+7 = 6+7 = 13से विभाजित करने का प्रयास करने से पहले, प्रिंट लाइन आउटपुट करता है nil।
यह भाग गोल> <> भाग के समान है, सिवाय @इसके 14 को ऊपर की तरफ लाता है, जो आउटपुट प्राप्त करता है।
ब्रायन और चक एक दो टेपों के साथ बीएफ व्युत्पन्न है, जहां एक टेप का निर्देश सूचक दूसरे टेप का मेमोरी पॉइंटर है। अनुपस्थिति में ```, स्रोत कोड की पहली दो पंक्तियों का उपयोग टेपों को आरंभ करने के लिए किया जाता है।
पहले दो पंक्तियों में प्रासंगिक वर्ण हैं:
?15
# >.>.
?ब्रायन की टेप में सेल करने के लिए (बताया जा रहा में चक पर नियंत्रण गुजरता है #) अशून्य है। चक तब निष्पादित होता है >.>., प्रश्न चिह्न के बाद दो वर्णों को आउटपुट करता है ।
STLक्रमशः स्थान, टैब और लाइन फ़ीड के लिए उपयोग करना , कार्यक्रम की शुरुआत है:
SSSTSSSSL
TL
STL
L
L
पहली पंक्ति 16 ( +10000आधार 2) को धक्का देती है , पूर्ववर्ती TLSTइसे संख्या के रूप में प्रिंट करती है। अगले तीन न्यूलाइन्स ने कार्यक्रम को रोक दिया।
हालाँकि, ध्यान दें कि यह कार्यक्रम दुभाषिया विशिष्ट है। अधिकांश दुभाषियों में बाकी कोड वाक्यविन्यास त्रुटियां हैं, इसलिए ऊपर दिए गए लिंक की तरह अधिक उदार व्याख्याकार की आवश्यकता होती है।
पहली पंक्ति में, निर्देशों का एक समूह निष्पादित होता है, लेकिन प्रासंगिक हैं
kkmmao#/
ईटीए के प्रतिबंध के कारण, हम इसे बढ़ाने के kबजाय चर बी को कम aकरने के लिए उपयोग करते हैं। kkबी -2 को घटाता है और mmबी को दो बार 16 से बढ़ाता है, जिसे 17 के साथ बढ़ाया जाता है a। इसके बाद इसका आउटपुट दिया जाता है o।
#तब B को 0 पर रीसेट करने के लिए उपयोग किया जाता है, और /प्रोग्राम को 0 से विभाजन के माध्यम से त्रुटि का कारण बनता है।
प्रतिबंध लागू: एक्सो कार्यक्रम से पहले कोई निर्देश जो आईपी की दिशा बदलते हैं
एक बार फिर, निर्देशों का एक समूह पहली पंक्ति में निष्पादित हो जाता है, लेकिन प्रासंगिक हैं
# # 15 ,@ 9 9 + { \
Axo, Befunge की तरह एक 2D भाषा है, और #इसी तरह एक पुल है जो अगले निर्देश को छोड़ देता है, लेकिन केवल तभी जब स्टैक के शीर्ष शून्य हो। 15,स्टैक के लिए धक्का, लेकिन स्टैक के साथ खाली है @। 99+फिर 18 को धक्का देता है, {आउटपुट और \हाल्ट।
भूलभुलैया एक और 2 डी भाषा है, और निष्पादित निर्देश हैं
#|#
[9!@
#स्टैक की लंबाई को धक्का देता है, जो पहली बार 0 है। |बिटवेट है या, स्टैक के बाद से कुछ भी नहीं बदल रहा है इस बिंदु पर केवल 0s है, और दूसरा #अब अकेला शून्य के कारण 1 धक्का देता है। हम 1 के कारण दाएं मुड़ते हैं, 9इस 1 को धर्मान्तरित करते हैं 1*10+9 = 19, !इसे प्रिंट करते हैं और @रोकते हैं।
यह कार्यक्रम इस तथ्य पर निर्भर करता है कि [वर्तमान में एक मान्यता प्राप्त निर्देश नहीं है, और इसलिए इसे दीवार के रूप में माना जाता है।
प्रतिबंध लागू: सभी के +पास कम से कम एक पूर्ववर्ती स्थान होना चाहिए
यदि हम गैर-मान्यता प्राप्त वर्णों को दूर करते हैं, तो कोड का प्रासंगिक हिस्सा है
, +.. +
,इनपुट है, लेकिन चूंकि हम /dev/nullवहाँ से पाइप करते हैं, इसलिए 0 को स्टैक पर धकेलना कोई नहीं है। पूर्ववर्ती रिक्त स्थान के +साथ एक n >= 5धक्का होता है n-5, इसलिए अगला निर्देश 2 धक्का देता है। ..फिर इन दो अंकों को रिवर्स ऑर्डर में आउटपुट करता है।
अगला हमारे पास एक +एकल पूर्ववर्ती स्थान है, जो डुप्लिकेट करता है। हालाँकि, स्टैक खाली है, इसलिए हम त्रुटि करते हैं।
विखंडन के लिए एकमात्र प्रासंगिक हिस्सा है
*"12"L
Lबायीं ओर एक परमाणु घूमता है, "21"21 को प्रिंट करता है *।
शुरू प्रतिबंध: कोई .पहले से पहले[
इसके लिए एक दुभाषिया की आवश्यकता होती है जो EOF पर 0 देता है और इसमें 8-बिट कोशिकाएँ होती हैं। प्रासंगिक कोड है
,+-[>.>.-+.>,>]-[>+<-----]>-..
इनबिल्ट -को ऑफ़सेट करना है +, और [...]सेल को 0. के बाद से पहले निष्पादित नहीं किया गया है। निम्न -[>+<-----]>-सेल सेल को चार कोड में सेट करता है 2, और ..इसे दो बार आउटपुट करता है।
जूलिया देखती है:
# comments
25
print(4^2 +7)/2
जो छपा है वह है 4^2+7 = pow(4,2)+7 = 16+7 = 23, और कार्यक्रम की त्रुटियां nothing2 से विभाजित करने की कोशिश कर रही हैं । ध्यान दें कि जूलिया को इस तथ्य का ध्यान नहीं है कि बाकी कोड वैसे भी एक सिंटैक्स त्रुटि का कारण होगा।
लिली देखती है:
# comment
#[
multiline comment
]## comment
print (7/6*24)# comment
7/6*24 = 1*24 = 24 छपा है।
GolfScript देखता है:
# comments
25
print(
GolfScript स्टैक-आधारित है, इसलिए 25 को स्टैक पर धकेल दिया जाता है, फिर पॉप किया जाता है और इसके साथ मुद्रित किया जाता है print। (फिर स्टैक पर निहित खाली स्ट्रिंग को कम करने की कोशिश करता है, जो विफल हो जाता है और कार्यक्रम से बाहर निकलता है।
चिकन स्कीम #| ... |#में कॉमन लिस्प के समान मल्टीलाइन टिप्पणी वाक्य रचना है। हालाँकि, में
(write(if(= 1/5 .2)26 3))
1/5एक फ्लोट है जो इसके बराबर है 0.2, इसलिए इसके बजाय 26 आउटपुट है।
थ्यू एक भाषा है जो स्ट्रिंग पुनर्लेखन पर आधारित है। पहला प्रासंगिक हिस्सा है
f::=~27
::=
जो एक प्रतिस्थापन को परिभाषित करता है, f -> 27उसके साथ प्रतिस्थापन के अंत को दर्शाता है ::=। अकेला fमें ifतो साथ बदल दिया है 27, जो outputted है।
पर्ल 6 में एक नई टिप्पणी वाक्यविन्यास है, #`(some bracket)जिसका अर्थ है बहुस्तरीय टिप्पणी जो मिलान ब्रैकेट के लिए सभी तरह से है। इस प्रकार, पर्ल 6 देखता है:
# comments
#`{
multiline comment
}# comment
print (7/6*24)# comment
जो प्रिंट करता है 7/6*24 = 28।
Picolisp देखता है:
# comment
#{
multiline comment
}#(prin 29)
जो 29 प्रिंट करता है। बाद में लाइन एक सिंटैक्स त्रुटि का कारण बनता है।
ट्रांसक्रिप्ट एक रोमांचित विषय है, जिसे टेक्स्ट एडवेंचर के बाद बनाया गया है। गैर-मान्यता प्राप्त लाइनों को अनदेखा किया जाता है (जो आपको वास्तविक कोड निर्देशों के बीच अतिरिक्त कहानी / स्वाद पाठ जोड़ने की अनुमति देता है), इसलिए संबंधित लाइनें निम्नलिखित हैं:
Jo is here.
>Jo, 30
>X Jo
पहली पंक्ति एक स्ट्रिंग चर की घोषणा करती है Jo, दो-अक्षर के नाम का उपयोग करने के बाद से एक-अक्षर के नाम विफल होने लगते हैं। दूसरी पंक्ति इस स्ट्रिंग को सेट करती है "30", जिसे Xतीसरी पंक्ति में ("जांच") द्वारा आउटपुट किया जाता है ।
2.7.1लिए मुफ्त समाधान देगा2.7.n। (वास्तव में, स्वीपरपटाटो प्रमुख संस्करणों के साथ ऐसा ही करता है।)