चुनौती:

आपका काम है कि आप जितने भी प्रोग्राम / फंक्शन / स्निपेट्स लिखें, उनमें से हर एक आउटपुट / प्रिंट / एक पूर्णांक लौटाए। पहले कार्यक्रम को पूर्णांक 1, दूसरे को 2और इतने पर आउटपुट देना चाहिए ।

आप कार्यक्रमों के बीच किसी भी वर्ण का पुन: उपयोग नहीं कर सकते। इसलिए, यदि पहला प्रोग्राम है: x==xतो आप वर्णों का उपयोग नहीं कर सकते हैं xऔर =फिर से किसी अन्य कार्यक्रम में। नोट: एक ही प्रोग्राम में कई बार एक ही चरित्र का उपयोग करने की अनुमति है।

स्कोरिंग:

विजेता वह सबमिशन होगा जो सबसे अधिक मायने रखता है। यदि कोई टाई है, तो विजेता वह सबमिशन करेगा जो कुल संख्या में सबसे कम बाइट्स का उपयोग करता है।

नियम:

आप सभी पूर्णांकों के लिए केवल एक ही भाषा का उपयोग कर सकते हैं
स्निपेट की अनुमति है!
इसे निष्पक्ष रखने के लिए, सभी पात्रों को आपके द्वारा चुनी गई भाषा में एक बाइट का उपयोग करके एन्कोड किया जाना चाहिए।
आउटपुट दशमलव में होना चाहिए। आप इसे वैज्ञानिक संकेतन या कुछ अन्य वैकल्पिक प्रारूप के साथ आउटपुट नहीं कर सकते। आउटपुट फ़्लोटिंग ठीक है, जब तक कि सभी बिंदु जो दशमलव बिंदु के पीछे दिखाए गए हैं 0। तो, 4.000स्वीकार कर लिया है। FPA के कारण गलतियाँ स्वीकार की जाती हैं, जब तक कि इसे आउटपुट में नहीं दिखाया गया है।
ans =, प्रमुख और अनुगामी रिक्त स्थान और newlines आदि की अनुमति है।
आप STDERR की अवहेलना कर सकते हैं, जब तक कि STDOUT में सही आउटपुट वापस नहीं आ जाता
आप पूर्णांक को STDERR में आउटपुट करना चुन सकते हैं, लेकिन केवल अगर STDOUT खाली है।
प्रतीक स्वतंत्र भाषाएं (जैसे कि पेंग्वेज ) को अस्वीकृत कर दिया जाता है
पत्र मामला संवेदनशील हैं a != A।
कार्यक्रम स्वतंत्र होने चाहिए
व्हाट्सएप का पुन: उपयोग नहीं किया जा सकता है
आपको आउटपुट में ASCII- अंकों का उपयोग करना होगा

स्पष्टीकरण को प्रोत्साहित किया जाता है!

number code-challenge restricted-source

— स्टीवी ग्रिफिन
स्रोत

4

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

— डेनिस

1

स्निपेट नियम के बारे में, क्या हमें अभी भी उपयोग / आयात को शामिल करने की आवश्यकता है? और स्थिर आयात की अनुमति है (उन्हें स्निपेट का हिस्सा बनाए बिना)?

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

1

@ केविनक्रूजसेन आप बॉयलरप्लेट सामान को छोड़ सकते हैं जो हर कार्यक्रम / कार्यों के लिए आवश्यक है। उदाहरण के लिए, आपको #include <iostream>C ++ में अन्य बॉयलरप्लेट सामग्री की आवश्यकता नहीं है । आप करते हैं की जरूरत है from numpy import *। नोट: मैं एक प्रोग्रामर नहीं हूं, इसलिए मुझे सभी बारीकियों की जानकारी नहीं है। अगर कुछ अस्पष्ट है तो हम चैट पर चर्चा कर सकते हैं :)

— स्टीवी ग्रिफिन

1

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

— स्टीवी ग्रिफिन

1

@StewieGriffin मैं कम से कम रिक्त स्थान की अनुमति देता हूं, लेकिन हे, मैं नहीं हूं।

— tuskiomi

146

जावास्क्रिप्ट (ईएस 7), स्कोर 17, 176 बाइट्स

उन्होंने कहा कि ऐसा नहीं किया जा सकता है, इसलिए मैंने ऐसा किया: D (@FullDecent से बहुत मदद के लिए)

""**""
~(~/~//~/~/)/~/~/
3
4
!NaN- -!NaN- -!NaN- -!NaN- -!NaN
6
7
8
9
++[[]][+[]]+[+[]]
11
'lengthlength'.length
222>>2>>2
`${``^``}xE`^``
0XF
C=CSS==CSS;C<<C<<C<<C<<C
555555555555555555555%55

अप्रयुक्त वर्ण:

#&,:?@ABDGHIJKLMOPQRTUVWYZ\_bcdfijkmopqrsuvwyz|

मुझे नहीं लगता कि 18 संभव है, लेकिन मैंने 17 के बारे में एक ही बात कही ...

व्याख्या

जावास्क्रिप्ट एक बहुत ही कमजोर टाइप की भाषा है; यदि आप एक गैर-संख्या मान पर एक गणितीय ऑपरेशन करने की कोशिश करते हैं, तो जेएस इसे पहले नंबर पर बदलने के लिए सबसे कठिन प्रयास करेगा। यह बहुत सारे दिलचस्प समाधानों की अनुमति देता है। मैंने यथासंभव अंकों का उपयोग करने से बचने की कोशिश की है ताकि बाद में उनका उपयोग किया जा सके।

**ES7 में प्रतिपादक ऑपरेटर है। खाली स्ट्रिंग जब एक संख्या के लिए coerced हो जाता है 0, तो यह गणना करता है 0 ** 0, जो 1जावास्क्रिप्ट के अनुसार है।
थोड़ा हास्यास्पद है, लेकिन यह काम करता है। /~/रेगेक्स शाब्दिक है, और ~/~/लौटता है -1, इसलिए यह ~(-1 / -1) / -1= ~(1) / -1= -2 / -1= है 2। ( विचार के लिए @ GOTO0 को श्रेय )
बस 3।
अब बस 4।
NaNमिथ्या है, इसलिए !NaNहै true, जो के बराबर है 1। इस प्रकार अभिव्यक्ति 1 - -1 - -1 - -1 - -1= 1 + 1 + 1 + 1 + 1= बन जाती है 5।
बस 6।
बस 7।
बस 8।
बस 9।
यह थोड़ा JSF *** जादू का उपयोग करता है । +[]है 0, इसलिए [[]][+[]]इसका पहला तत्व [[]](जो है []), और इसे ++बढ़ाता है 1। फिर +[+[]]एरे को जोड़ता है [0], जो एक स्ट्रिंग के लिए मजबूर होता है और बनाता है "10"।
बस 11। मैं मूल रूप 11&1111से 3 के लिए और 33/311 के लिए इस्तेमाल किया था जब तक मुझे एहसास हुआ कि अभी तक फिर से मैं कितना बेवकूफ हूं ...
यह रणनीति किसी भी संख्या पर काम करेगी: लंबाई 12और उपयोग की एक स्ट्रिंग बनाएं .length।
मैं बस थोड़ी देर के लिए 2एस और >एस के साथ गड़बड़ कर दिया । मैं फिर से भाग्यशाली हो गया: 222 >> 2है 55, और 55 >> 2है 13।
यह एक बल्कि मुश्किल है। मूल विचार 14हेक्स ( 0xE) में बनाना है , लेकिन हमें 0कहीं और अंक की आवश्यकता है। इसलिए इसके बजाय हम ``^``स्ट्रिंग के परिणाम को रोकते हैं xE; खाली स्ट्रिंग एक संख्या के लिए coerced है 0, तो यह रिटर्न 0 ^ 0= 0। फिर परिणाम खाली स्ट्रिंग के साथ XORed है, जो दोनों मानों को संख्याओं में परिवर्तित करता है; "0xE" ^ ""है 14।
यह अब बहुत आसान है: के 0XFमूल्य के साथ एक हेक्साडेसिमल शाब्दिक है 15।
सबसे मुश्किल? सबसे पहले हम चर Cको CSS == CSS(यानी true) सेट करते हैं । फिर हम परिणाम लेते हैं और << Cचार बार प्रदर्शन करते हैं , जो मूल रूप से गुणा करता 1है 2 ** 4।
जावास्क्रिप्ट 2 से ⁵³ पर पूर्णांक सटीकता खोना शुरू कर देता है, जो 555...555%55एक संख्या को वापस करने की अनुमति देता है जो नहीं है 0या नहीं 5। मैं इधर-उधर खेलते हुए बहुत भाग्यशाली निकला।

कई संख्याओं पर काम करने वाली रणनीतियाँ:

-!NaNकिसी भी संख्या पर काम करेगा (वर्तमान में 5), हालांकि यह बहुत तेजी से बड़ा हो जाता है।
~/~/किसी भी संख्या पर काम करेगा (वर्तमान में 2), हालांकि यह बहुत तेजी से बहुत बड़ा हो जाता है ।
+[]किसी भी संख्या पर काम करेगा (वर्तमान में 10), हालांकि यह अभी तक सबसे आसान है 10या 11।
.length किसी भी नंबर पर काम करेगा।
`${-``}xE`-`` यदि आप इसे सही करते हैं तो किसी भी संख्या पर बहुत अधिक काम करेंगे।
C<<C16यदि आप शामिल हैं, तो दो (वर्तमान में ), या किसी भी इंट की किसी भी शक्ति पर काम करेंगे |।

— ETHproductions
स्रोत

3

यह बहुत बढ़िया है :)

— स्टीव बेनेट

1

window.गुणों में से किसी एक का उपयोग करने के लिए कुछ डरपोक तरीके हो सकते हैं, जैसे defaultPixelWidth, लेकिन वे सभी lया तो शामिल हैं या लगते हैं e। आप एक और 0 प्राप्त कर सकते हैं URL | URLलेकिन यह ज्यादा मदद नहीं करता है।

— स्टीव बेनेट

1

मैंने "फोकस" भी पाया, लेकिन मैं अभी भी नहीं देख रहा हूं कि 18: "फोकस" फ़ंक्शन () कैसे प्राप्त करें। "फ़ोकस एंड फ़ोकस" 0. "फ़ोकस (URL)" अपरिभाषित है।

— जेंटिक्स

1

वर्तमान में पाए गए ऑपरेटर जो वृद्धि करते हैं:+ - * ~ < x X length

— l4m2

1

संख्याओं की कमी मुख्य रूप से इन प्रतीकों पर सीमित है। किसी भी संख्या में एक होता है 1 2 3 4 5 6 7 8 9 + - * ~ < x X length। इसलिए इसे हल करने से पहले हम

— l4m2

90

जेली , 47 पूर्णांक, 519 बाइट्स

e
BI$⁼#
⁾⁾⁾Ụ^/
ı***ıḞḞ
5
6
7
.::::
9
EȮ<
⁻GṘ
=`p`VV×`DQV
~A~A~A~A~A~A~A~A~A~A~A~A~A
⁷ṾṾṾw
⁴ḟ€⁴Ṁ
mmmmċ
ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ
+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ
CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC
ĖḌĖḌ
ṫṣȦJṫȦ⁸ȦJ
22
“@ṃ»
!ḤḤ!
³HH
ØaM
;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬
irið8c
⁶ḲĠṂ°İṂĊ
œṡ¹ẆẆTUṖṖṖṖP
ȷ½RṪ
LµdddddµFL
33
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ
ẇɓæ«æ«æ«æ«æ«|æ«|
⁹ṚḢ²
‘‘‘0‘‘‘‘‘‘‘
’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ
-____---__________
”(O
⁵ḶxḶ⁵ị⁵ḶxḶḣṢ
⁽{ʂ%⁽{}
ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®
44
111111l11&K1111111Kl11&
,SS¶ỊỊ,ÇS¶ÇÑÇÇÇÑ
ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn

हर पंक्ति एक अलग, पूर्ण कार्यक्रम है।

इसे ऑनलाइन आज़माएं! (परीक्षण सूट और चौराहे चेकर शामिल हैं)

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

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

जेली कई मामलों में अपने उत्पादन का प्रबंधन करती है। विशेष रूप से, एक एकल सरणी अपने आसपास के कोष्ठक के बिना मुद्रित होती है, इसलिए 42 और [42] और मुद्रण के बाद अप्रभेद्य। हम कई मौकों पर इसका इस्तेमाल करेंगे।

1 - 10

मौजूद परमाणु परीक्षण करता है, तो वापसी मान 0 तर्क के अंतर्गत आता है 0 । यह करता है, इसलिए 1e लौटाता है ।

BI$⁼#

BI$एक क्विकलिंक है, विशेष रूप $से द्विआधारी परमाणु Bऔर इंक्रीमेंट परमाणु के त्वरित समूह द्वारा बनाई गई एक मौद्रिक श्रृंखला है I। संयुक्त, वे एक पूर्णांक को आधार 2 में अपने अंकों की सरणी में परिवर्तित करते हैं, फिर परिणामी अंकों के आगे के अंतरों की गणना करते हैं। यदि सरणी में केवल एक तत्व है, तो कोई फ़र्क नहीं है और Iखाली सरणी (मिथ्या) लौटाता है; यदि कम से कम दो अंक हैं, तो Iएक गैर-खाली सरणी (सत्य) देता है।

त्वरित #पिछले क्विकलिंक का उपभोग करता है और इसे 0 , 1, 2,… तक लागू करता है जब तक कि पर्याप्त मैचों को रिटर्न नहीं मिलता है, मैचों की सरणी देता है। आवश्यक राशि की गणना की जाती है ⁼, जो कि रिटर्न वैल्यू / तर्क 0 से खुद की तुलना करता है, उपज 1 । इस प्रकार, पूरा कार्यक्रम वापस आ जाता है [2] , आधार 2 में दो अंकों के साथ पहला गैर-नकारात्मक पूर्णांक।

⁾⁾⁾Ụ^/

⁾⁾⁾एक स्ट्रिंग शाब्दिक, विशेष रूप से स्ट्रिंग है ⁾⁾ । ग्रेड ऊपर परमाणु Ụउनके संबंधित मान द्वारा अपने सूचकांक क्रमबद्ध करता; चूँकि दोनों वर्ण समान हैं, इसलिए इसकी पैदावार [1, 2] है । परिणामी सरणी बिटवाइज़ एक्सओआर के साथ कम हो जाती है ^/, इसलिए पूरा कार्यक्रम 3 रिटर्न करता है ।

ı***ıḞḞ

ıआरंभिक तर्क और वापसी मूल्य को काल्पनिक इकाई i । *है घातांक युग्म, जिसका सही तर्क मुख्य कड़ी के तर्क को चूक। इस प्रकार, ***ıcomputes ((मैं ^मैं ) ^मैं ) ^मैं ≈ 4.81 + 0i , Ḟपरमाणु ( मंजिल असली तर्क, के लिए वास्तविक हिस्सा जटिल लोगों के लिए) असली हिस्सा (गणना करता है 4.81 ), तो Ḟफर्श, उपज 4 ।

5
6
7

इन तीन कार्यक्रमों में एक एकल शाब्दिक शामिल है और आप जो अपेक्षा करते हैं, वही करते हैं।

.::::

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

एक और शाब्दिक।

EȮ<

सभी को समान परमाणु Eरिटर्न 1 अगर इसके तर्क में सभी तत्वों के बराबर हैं, और 0 नहीं तो। एक पूर्णांक तर्क z को [z] प्रचारित किया जाता है , इसलिए निहित तर्क 0 के लिए 1E वापस आ जाएगा ।

अब, आउटपुट परमाणु 1 से STDOUT को Ȯप्रिंट करता है । हम फिर 1 की तुलना में निहित तर्क 0 के साथ परमाणु की तुलना में कम का उपयोग करते हैं । परिणाम (1 <0) = 0 है , और जब कार्यक्रम समाप्त होता है, तो इसे स्पष्ट रूप से मुद्रित किया जाता है।<

11 - 20

⁻GṘ

ग्रिड परमाणु Gअपने तर्क से एक नेत्रहीन मनभावन तालिका बनाने के लिए कोशिश करता है। एक सादे पूर्णांक तर्क के लिए (यहाँ: 0 ), यह बस इसे एक सरणी में लपेटता है। फ्लैट नहीं-बराबर परमाणु ⁻अंतर्निहित तर्क तुलना 0 सही (करने के लिए परिणाम के साथ [0] ), उपज 1 के बाद से अपने तर्कों बराबर नहीं हैं। प्रतिनिधित्व परमाणु Ṙप्रिंट 1 STDOUT करने के लिए और इसके परिणाम देता है। कार्यक्रम के अंत में, अंतिम रिटर्न मान को स्पष्ट रूप से मुद्रित किया जाता है, इसलिए हम 11 के आउटपुट के साथ समाप्त होते हैं ।

=`p`VV×`DQV

स्वयं त्वरित `समान छोड़ दिया और सही तर्क के साथ यह फोन करके एक इकाई में एक युग्म बदल जाता है। सबसे पहले, =`निहित तर्क 0 की तुलना अपने आप से, उपज 1 ।

कार्तीय उत्पाद परमाणु pअपने तर्कों के रूप में सूचियों की उम्मीद है, तो यह पूर्णांक को बढ़ावा देता है 1 करने के लिए रेंज [1, ..., 1] = [1] । p`कार्टेजियन उत्पाद [1] और स्वयं, उपज [[1, 1]] लेता है ।

Eval परमाणु V, सभी फ्लैट सरणियों तार में (केवल नंबर और वर्ण से युक्त) बदल जाता है तो niladic जेली कार्यक्रमों के रूप में जिसके परिणामस्वरूप तार मूल्यांकन करता है। [[१, १]] को पहले [११] में बदल दिया जाता है , फिर Vस्ट्रिंग को निकालते हुए, [११] पैदावार दी जाती है । एक बार और, Vइस सरणी को "11" में बदल देता है , और फिर इसे 11 उपज देता है ।

अब, अपने आप से 11×` गुणा , 121 की उपज । दशमलव परमाणु बदल जाता है 121 में [1, 2, 1] , अद्वितीय परमाणु को छोड़ देता है दूसरा 1 , और एक बार फिर पूर्णांक है कि, उन्हें श्रृंखलाबद्ध लौटने से परिणाम में अंक की एक सूची बदल जाता है 12 ।QV

~A~A~A~A~A~A~A~A~A~A~A~A~A

~है बिटवाइज़ नहीं परमाणु। दो पूरक अंकगणित के साथ, यह एक तर्क z को ~ z = - (z + 1) में मैप करता है । Aहै निरपेक्ष मूल्य परमाणु, तो यह नक्शे - (z + 1) = z + 1 । प्रारंभिक वापसी मान 0 के साथ , ~Aवापसी 13 की तेरह प्रतियां ।

⁷ṾṾṾw

स्थिरांक ⁷newline वर्ण '\ n' रखता है और तर्क और रिटर्न वैल्यू को इनिशियलाइज़ करता है।

Uneval परमाणु Ṿअपने तर्क के एक स्ट्रिंग प्रतिनिधित्व बनाने का प्रयास करता z ऐसी है कि एक जेली इस कोड से मिलकर कार्यक्रम वापसी होगी जेड ।

पहला कॉल कर्तव्यपरायणता से स्ट्रिंग "" \ n "" लौटाता है , जो एक अक्षर शाब्दिक है। अगला कॉल "" "," \ n "देता है - चरित्र शाब्दिकों की एक जोड़ी। तीसरा और अंतिम कॉल "" "," ",", ",", "\ n" - वर्ण शाब्दिक का एक क्विंटअपलेट है।

अंत में, खिड़की सूचकांक परमाणु wइसकी सही तर्क को बढ़ावा देता है '\ n' स्ट्रिंग के लिए "\ n" और सबस्ट्रिंग के साथ शुरू के पहले सूचकांक लगता है "\ n" । यह 14 देता है ।

⁴ḟ€⁴Ṁ

⁴लगातार 16 है । क्विकलिंक फ़िल्टरफ़्लैस प्रत्येक ( ḟ€) अपने बाएं तर्क 16 को रेंज [1,… 16 , ] तक बढ़ावा देता है , फिर अपने तत्वों पर निर्भर करता है।

प्रत्येक तत्व z के लिए , ḟ⁴निष्पादित किया जाता है, पहले z [z] को बढ़ावा देता है , फिर सभी (यदि कोई है) 16 को हटाता है । यह सरणी [[1], [2],…, [14], [15], []] को जन्म देता है , जहां अंतिम सरणी खाली है क्योंकि इसमें 16 शामिल हैं ।

अंत में, अधिकतम परमाणु [15]Ṁ का चयन करता है ।

mmmmċ

मॉड्यूलर परमाणु m- साथ बहस बुलाया एक्स (सरणी) और y (पूर्णांक) आम तौर पर हर लेता है y | | ^वें के तत्व एक्स पहले अगर साथ शुरू, y> 0 , पिछले अगर साथ y <0 । हालांकि, जब y = 0 होता है , तो यह एक्स को अपने रिवर्स के साथ वापस लौटता है ।

बाएं पूर्णांक तर्क 0 को पहले [0] में पदोन्नत किया गया है । mकॉकटेलेट्स की पहली प्रति [0] अपने आप से, उपज [0, 0] । शेष प्रतियाँ इस परिणाम को [0, 0, 0, 0] में बदल देती हैं , फिर [0, 0, 0, 0, 0, 0, 0] , और अंत में [0, 0, 0, 0, 0] , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] ।

अंत में, गिनती परमाणु 16 बार लौटते हुए परिणामित सारणी में ċअनुमानित तर्क 0 की संख्या को गिनता है ।

ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ

ṭयह सौदा परमाणु है और इसके बाएं तर्क को इसके दाईं ओर जोड़ता है। के बाद से ṭऔर निम्नलिखित ḍdyadic कर रहे हैं, सभी के लिए कॉल ṭअंतर्निहित तर्क पारित 0 सही तर्क के रूप में ṭ। पहला कॉल रिटर्न देता है [0, 0] , दूसरा [0, [0, 0] , और आठवां और अंतिम [0, [0, [0, [0, [0, [0, [0,] 0, [0] ०]]]]]]]] ।

ḍहै विभाज्यता परमाणु; तर्क x और y के लिए , यह रिटर्न 1 है x x से विभाज्य है y , 0 नहीं तो। Ḅपूर्णांक के लिए कोई ऑप नहीं है, इसलिए निर्मित सरणी में प्रत्येक पूर्णांक द्वारा विभाज्यता के लिए 0 काḍḄ परीक्षण करता है । 0 अपने आप से विभाज्य है, इसलिए हमें [1, [1, [1, [1, [1, [1, [1, [1, 1]]]]]]]]]] हैं ।

अब, असंबद्ध परमाणु Ḅफ्लैट सरणियों पर संचालित होता है । एक जोड़ी [ए, बी] के लिए , यह केवल 2 ए + बी देता है । जैसा कि पहले उल्लेख किया गया है, Ḅपूर्णांक के लिए एक नो-ऑप है: एक पूर्णांक तर्क c [c] में पदोन्नत किया गया है , और किसी भी आधार में [c] बस c है ।

पहली कॉल को Ḅकम करने के लिए [1, 1] से 3 , इस प्रकार उपज [1, [1, [1, [1, [1, [1, [1, [1, 3]]]]]]] । अगली कॉल [१, ३] को घटाकर ५ , अगले एक [१, ५] से 1 , और नौवें Ḅरिटर्न १ 1 तक आने वाली है ।

+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ

Ṇहै फ्लैट तार्किक नहीं परमाणु और नक्शे अंतर्निहित तर्क 0 करने के लिए 1 । +इसके अलावा परमाणु है, इसलिए +Ṇपिछले वापसी मूल्य (शुरू में 0 ) वेतन वृद्धि की अठारह प्रतियों में से प्रत्येक । इस प्रकार पूरा कार्यक्रम 18 को लौटता है ।

CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC

Cहै पूरक परमाणु और उसके तर्क नक्शे z करने के लिए 1-z । Nहै निगेट परमाणु और नक्शे अपने तर्क जेड को -z । साथ में, CNनक्शे z से - (1-z) = z-1 हैं , इसलिए अठारह प्रतियां निहित तर्क 0 -18 में बदल जाती हैं । Cपैदावार का एक अंतिम आवेदन 1 - (-18) = 19।

ĖḌĖḌ

गणना परमाणु Ėएक सरणी में आइटम विश्लेषण करता है, सूचकांक और मान के जोड़े का निर्माण। निहित तर्क 0 को [0] में पदोन्नत किया जाता है , फिर Ėपैदावार [[1, 0]] की जाती है । Undecimal परमाणु आधार 10 से एक फ्लैट सरणी पूर्णांक में बदलता है, उपज [10] इस विशेष मामले में।

करने के लिए दूसरी कॉल Ėरूपांतरण [10] में [[1, 10]] , दूसरा जो Ḍअंत में में परिवर्तित हो [20] ।

21 - 30

ṫṣȦJṫȦ⁸ȦJ

पूंछ परमाणु ṫ(एक दो का समूह) ने अपनी बाईं तर्क के पोस्टफ़िक्स कि सूचकांक पर शुरू होता है का चयन (1-आधारित और मॉड्यूलर) अपने अधिकार का तर्क में निर्दिष्ट, एक बाएं पूर्णांक तर्क को बढ़ावा देने एक्स के लिए [x] । जब दोनों तर्कों के साथ 0 पर सेट किया जाता है , तो ṫरिटर्न [0] ।

किसी भी और सभी परमाणु Ȧरिटर्न 1 अगर इसके तर्क truthy है और किसी भी गहराई, में कोई शून्य होता है 0 अन्यथा। यहाँ, हम इसका उपयोग एक पहचान फ़ंक्शन के रूप में निहित तर्क 0 को वापस करने के लिए करते हैं । पर विभाजन परमाणु ṣअपनी बाईं तर्क विभाजित कर [0] अपने अधिकार तर्क की घटनाओं पर 0 , तो यह रिटर्न [[] [],] यहाँ।

सूचकांक परमाणु Jवापसी मान के तत्वों को छोड़ देता है और उन्हें अपने सूचकांक के साथ बदलता है, उपज रेंज [, 2 1] इस विशिष्ट मामले में। Ȧऔर ṫदोनों पहले की तरह काम करते हैं, इसलिए वे [1, 2] को कम करते हुए पोस्टफिक्स को अंतिम सूचकांक में शुरू करते हैं, [2] ।

निलादिक लिंक में, स्थिरांक []⁸ रखता है । यह एक अप्राप्य निलाद है, अर्थात, यह किसी भी तरह से श्रृंखला में फिट नहीं होता है। परिणामस्वरूप, पिछला रिटर्न मान ( [2] ) STDOUT में मुद्रित होता है, फिर निलाड के मूल्य ( [] ) के साथ बदल दिया जाता है ।

चूंकि [] मिथ्या है, Ȧइसे 0 में रूपांतरित किया । Jपरमाणु को बढ़ावा देता है 0 करने के लिए [0] , तो इसकी सूचकांक (की सूची देता है [1] ) है, जो परोक्ष छपा है जब कार्यक्रम खत्म।

एक और शाब्दिक। इनका उपयोग करने के लिए रेपिडिजिट सबसे अच्छी जगह लगती है।

“@ṃ»

यह जेली के इनबिल्ट स्ट्रिंग कंप्रेशन का उपयोग करता है। जेली के कोड पृष्ठ में @ और ṃ के सूचकांक 64 और 220 हैं और स्ट्रिंग शाब्दिकों में 250 भिन्न वर्ण हो सकते हैं, इसलिए यह पूर्णांक 250 × 65 + 220 = 16470 की गणना करता है ।

16470 3 से विभाज्य है, इसलिए भागफल 16470/3 = 5490 एक मुद्रण योग्य ASCII चरित्र या एक लाइनफीड को एन्कोड करता है। इनमें से 96 और 5490 = 96 × 57 + 18 हैं , जिसका अर्थ है कि हमने 0-आधारित इंडेक्स 18 में मुद्रण योग्य ASCII चरित्र को डिकोड किया है , जो '2' है ।

हम 57 के साथ बचे हैं , जो 3 से भी विभाज्य है , इसलिए भागफल 57/3 = 19 = 96 × 0 + 19 0-आधारित इंडेक्स 18 में मुद्रण योग्य ASCII वर्ण है , जो '3' है ।

यह 0 छोड़ देता है ; डिकोडिंग प्रक्रिया बंद हो जाती है। उत्पन्न चरित्रों को "23" बनाने के लिए संक्षिप्त किया गया है

!ḤḤ!

भाज्य परमाणु !अंतर्निहित तर्क बदल जाता है 0 में 1 । अस्वस्थ परमाणु के दो आह्वान 1 को 2 में Ḥबदल देते हैं , फिर 2 को 4 में । अंत में, गणना 4! = 24 ।!

³HH

कमांड लाइन तर्क के अभाव में, लगातार ³रखती है 100 । दो आमंत्रण Hबदल जाता है 100 में 50 , तो 50 में 25 ।

ØaM

निरंतरता Øaलोअरकेस वर्णमाला रखती है। अधिक से अधिक परमाणु Mअधिक से अधिक आइटम के सभी सूचकांकों पैदावार, और के बाद से z सबसे बड़ा छोटा अक्षर है, परिणाम है [26] ।

;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬

की छब्बीस प्रतियां CONCATENATE परमाणु ;प्रारंभिक वापसी मान जोड़ 0 और डिफ़ॉल्ट तर्क के छब्बीस उदाहरणों 0 , 27 शून्यों की एक सरणी का निर्माण।

¬है तार्किक नहीं परमाणु, तो ;¬एक संलग्न कर देता है 1 शून्य की सरणी के लिए। अगले ¬सरणी में सभी तत्वों को नकारता है, जो हमें 27 लोगों और 1 शून्य के सरणी के साथ छोड़ देता है।

ḅहै unbase परमाणु और आधार का अधिकार तर्क पूर्णांक में निर्दिष्ट से अपने बाएँ तर्क से एक अंकों सरणी बदल देता है। ḅ¬यूनरी से पूर्णांक में परिवर्तित होता है, इसलिए यह केवल एक योग करता है। 27 लोगों की एक सरणी के लिए, यह 27 देता है ।

irið8c

परमाणु का सूचकांकi इसके बाएं तर्क को 0 से [0] तक बढ़ावा देता है , फिर इसके सही तर्क 0 के सूचकांक को उस सरणी में 1 , yiel 1 में खोजता है ।

रेंज परमाणु rनिर्माण करती है इसे से एक बढ़ते या घटते रेंज का अधिकार एक के लिए तर्क बचा है। सही तर्क निहित तर्क 0 है , इसलिए यह पैदावार करता है [1, 0] । [१, ०] में ०i के सूचकांक को खोजता है , २ का अंकन करता है ।

ðएक नई, रंगाई श्रृंखला शुरू करता है। चूंकि पूर्ववर्ती श्रृंखला निलादिक थी, इसलिए इस श्रृंखला के बाएं और दाएं दोनों तर्क पहले श्रृंखला के रिटर्न मान ( 2 ) के बराबर होंगे । cमें संयोजन परमाणु। बाएं तर्क 8 और दाएं तर्क 2 के साथ , यह 8C2 = 8! (6! 2!) = 28 को वापस करते हुए, 8 तत्वों के एक सेट के सभी अनूठे, अनियंत्रित 2-संयोजनों को गिनता है ।

⁶ḲĠṂ°İṂĊ

स्थिरांक ⁶एक अंतरिक्ष वर्ण रखता है और तर्क और वापसी मान को '' सेट करता है । शब्द परमाणु Ḳचरित्र को बढ़ावा देता है '' सिंगलटन स्ट्रिंग के लिए "" और रिक्त स्थान पर यह विभाजन, उपज [[] [],] ।

समूह परमाणु Ġसभी समूहों को समान तत्वों का समूह बनाता है । चूँकि अंतिम रिटर्न मान के दोनों तत्व समान हैं, इसलिए यह [[१, २]] यहाँ लौटाता है। न्यूनतम परमाणु एक न्यूनतम (केवल) इस सरणी के तत्व, उपज निकालता है [1, 2] ।

डिग्री परमाणु °, रेडियंस में सेक्साजेसिमल डिग्री से दोनों पूर्णांकों धर्मान्तरित उपज 1 ° × 2π / 360 ° = π / 180 और 2 ° × 2π / 360 ° = π / 90 । उलटा परमाणु गुणक प्रतिलोम लेता है, उपज 180 / π ≈ 57.3 और 90 / π ≈ 28.6 ।

फिर, Ṃएक बार अधिक से अधिक न्यूनतम 28.6 की उपज लेता है । अंत में, छत परमाणु 28.6 को 29 में Ċबदल देता है ।

œṡ¹ẆẆTUṖṖṖṖP

पहचान परमाणु ¹रिटर्न 0 अंतर्निहित तर्क के लिए 0 । चारों ओर विभाजन परमाणु œṡअपने तर्कों (दोनों के दोनों को बढ़ावा देता है 0 ) के लिए [0] , तो विभाजन [0] के बराबर सन्निहित subarrays के आसपास [0] । इससे पैदावार [[], []] होती है ।

रपट खिड़की परमाणु Ẇअपने तर्क के सभी सन्निहित subarrays बनाता है। पहला उदाहरण [[], []] को [[[]], [[]], [[], []] में बदल देता है, दूसरा उदाहरण रूपांतरित [[[]], [[]], [[] , []]] में
[[[[]]], [[[]]], [[[], []]], [[[]], [[]]], [[[]], [ [], []]], [[]], [[]], [[], []]] ।

सच्चाई परमाणु Ttruthy तत्वों के सभी सूचकांकों सूचीबद्ध करता है। पहले स्तर पर कोई भी ऐरे खाली नहीं है, इसलिए यह पैदावार [1, 2, 3, 4, 5, 6] करता है । समाप्त कर देना परमाणु Uइस सरणी उलट जाता है, उपज [6, 5, 4, 3, 2, 1] ।

पॉप परमाणु की चार प्रतियां Ṗपिछले चार तत्वों को हटा देती हैं, जो हमें [6, 5] के साथ छोड़ देती हैं । अंत में, उत्पाद परमाणु Pइस सरणी को 30 में बदल देता है ।

३१ - ४०

ȷ½RṪ

ȷ1 × 10 ³ = 1000 के लिए एक आशुलिपि है । वर्गमूल परमाणु ½पैदावार 31.6 है, जो सीमा परमाणु Rमें परिवर्तित हो [1, ..., 31] । अंत में, पूंछ परमाणु Ṫआखिरी तत्व को निकालता है, 31 को वापस करता है ।

LµdddddµFL

लंबाई परमाणु Lनिहित तर्क को बढ़ावा देता है 0 करने के लिए [0] उपज के लिए, तो लंबाई लेता है 1 । µएक नई, मौद्रिक श्रृंखला शुरू करता है, और परिणाम 1 इसका तर्क बन जाता है।

तर्कों x और y के लिए , डिवमोड परमाणु dउपज देता है [x / y, x% y] । प्रत्येक कॉल में y = 1 होगा , इसलिए परिणाम हमेशा [x, 0] होगा ।

पहली कॉल x = 1 से शुरू होती है , उपज [1, 0] । dकेवल पूर्णांकों पर काम करता है, इसलिए यह बाद की कॉलों में सदिश करता है। दूसरी कॉल की उपज [[1, 0], [0, 0]] , तीसरी [[[1, 0], [0, 0]], [[0, 0], [0, 0]]] है । और गहराई 5 की पांचवीं और अंतिम एक सरणी जिसमें एक एकल और 31 शून्य होते हैं।

µएक बार फिर से एक नई, मौद्रिक श्रृंखला शुरू होती है, और पहले से सरणी इसका तर्क बन जाती है। फ्लैट परमाणु Fइस सरणी unnests, एक भी एक और 31 शून्यों का एक फ्लैट सरणी उपज। अंत में, Lपरिणामी की लंबाई लेता है, 32 लौट रहा है ।

एक और रेपिडिजिट, दूसरा शाब्दिक।

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ

रैप परमाणु का प्रत्येक उदाहरण अपने तर्क z को [z] में बदल देता है । 0 के प्रारंभिक वापसी मूल्य के साथ, सभी 34 उदाहरण एक साथ उपज देते हैं [[[[[[[[[[[[[[[[[[[[[[[[[[[] [[[]] ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] । अंत में, गहराई परमाणु ŒḊपरिणामी सरणी की अधिकतम गहराई की गणना करता है, 34 लौटता है ।

ẇɓæ«æ«æ«æ«æ«|æ«|

खिड़की मौजूद परमाणु ẇअपने तर्कों (दोनों के लिए डिफ़ॉल्ट के दोनों को बढ़ावा देता है 0 ) के लिए [0] , तो परीक्षण करता है, तो ** [0] ** का एक सन्निहित subarray रूप में होता है [0] । यह करता है, इसलिए 1ẇ लौटाता है ।

ɓएक नई, रंगाई श्रृंखला शुरू करता है। चूंकि पूर्ववर्ती श्रृंखला निलादिक थी, इसलिए इस श्रृंखला के बाएं और दाएं दोनों तर्क पहले श्रृंखला के रिटर्न मान ( 1 ) के बराबर होंगे । श्रृंखला दो अलग-अलग, डाईएडिक परमाणुओं का उपयोग करती है: बिटशिफ्ट लेफ्ट ( æ«) और बिटवाइज़ ओआर ( |)।

एक डायैडिक श्रृंखला जो तीन या अधिक रंगों से शुरू होती है, शुरू में श्रृंखला के तर्कों के साथ पहले डेड को बुलाती है। यहाँ, यह 1 << 1 = 2 देता है । इसके बाद के छह रंगों को जोड़े (तथाकथित कांटे ) में बांटा जाता है , जहां सबसे दाहिने रंगाद को श्रृंखला के तर्कों के साथ पहले कहा जाता है, फिर सबसे बाईं ओर दोनों पक्षों के पिछले रिटर्न मूल्यों के साथ बुलाया जाता है।

के लिए æ«æ«, हमें 2 << (1 << 1) = 2 << 2 = 8 मिलते हैं । फिर, 8 << (1 << 1) = 8 << 2 = 32 कीæ«æ« गणना करता है । अब, हमें 32 मिलता है | (1 << 1) = 32 | 2 = 34 ।|æ«

अंत में, अनुगामी |एक हुक की तरह कार्य करता है और इसे पिछले रिटर्न मान के साथ इसके बाएं तर्क के रूप में कहा जाता है और श्रृंखला का सही तर्क इसके दाहिने हिस्से के रूप में। यह रिटर्न 34 | 1 = 35 ।

⁹ṚḢ²

एक दूसरा तर्क के अभाव में, लगातार ⁹रखती है 256 । रिवर्स परमाणु को बढ़ावा देता है 256 सरणी [2, 5, 6] और यह उपज के लिए पराजयों [6, 5, 2] । फिर, सिर परमाणु Ḣपहला तत्व निकालता है, और वर्ग परमाणु ²रिटर्न ** 6² = 36 *।

‘‘‘0‘‘‘‘‘‘‘

वेतन वृद्धि परमाणु ‘द्वारा अपने तर्क वृद्धि कर देता है 1 , इसलिए ‘‘‘प्रारंभिक वापसी मान बारी 0 में 3 । निम्नलिखित 0 एक अप्राप्य निलाद है, अर्थात, यह किसी भी तरह से श्रृंखला में फिट नहीं होता है। परिणामस्वरूप, पिछला रिटर्न मान ( 3 ) STDOUT में मुद्रित होता है, फिर निलाड के मान ( 0 ) के साथ बदल दिया जाता है ।

निम्नलिखित 7 की प्रतियां ‘इस मोड़ 0 में 7 , जो परोक्ष छपा है जब कार्यक्रम खत्म।

’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ

घटती परमाणु ’द्वारा अपने तर्क decrements 1 , तो अड़तीस प्रतियां प्रारंभिक वापसी मान बारी 0 में -38 । पूर्ण अंतर परमाणु ạके बीच अहस्ताक्षरित अंतर की गणना करता है -38 और अंतर्निहित तर्क 0 , लौटने 38 ।

-____---__________

--1 के लिए एक आशुलिपि है और लिंक के तर्क और रिटर्न मान को -1 पर सेट करता है । प्रत्येक _डाईडिक घटाव परमाणु का एक उदाहरण है , जिसका सही तर्क अनुपलब्ध होने पर -1 में डिफ़ॉल्ट होगा ।

पहले, -____-गणना (-1) - (-1) - (-1) - (-1) - (-1) = 3 । निम्नलिखित -1 एक अप्राप्य निलाद है, इसलिए पिछला रिटर्न मान ( 3 ) STDOUT में मुद्रित किया जाता है, फिर निलाड के मूल्य ( -1 ) के साथ बदल दिया जाता है ।

अगला, -_गणना करता है (-1) - (-1) = 0 , जहां शाब्दिक बाएं तर्क को -सेट करता है और सही मान के रूप में वापसी मूल्य का उपयोग करता है। डिफ़ॉल्ट मान -1 को घटाने के बाद वापसी की मूल्य से निम्नलिखित नौ प्रतियां , उपज 9 , जो कि कार्यक्रम समाप्त होने पर स्पष्ट रूप से मुद्रित होती है।__

”(O

”(एक चरित्र शाब्दिक है और क्रमिक परमाणु Oअपने यूनिकोड कोड बिंदु को देखता है, जो 40 का है ।

४१ - ४ 41

⁵ḶxḶ⁵ị⁵ḶxḶḣṢ

एक तिहाई कमांड लाइन तर्क के अभाव में, लगातार ⁵रखती है 10 । Unlength परमाणु Ḷ0-आधारित रेंज, विशेष रूप से पैदा करता है [0, ..., 9] तर्क के लिए 10 , के दोनों पक्षों के लिए जगह में दोहराने परमाणु x। उत्तरार्द्ध अपने बाएं तर्क के तत्वों को अपने दाएं की पुनरावृत्ति के साथ मेल खाता है, और प्रत्येक तत्व को इसी संख्या को दोहराता है। साथ [0, ..., 9] दोनों छोड़ दिया और सही तर्क के रूप में, हम इस प्रकार शून्य शून्य, एक के बाद एक, दो दुक्की आदि मिलता है

में सूचकांक परमाणु ịसूचकांक अपने बाएँ एक में निर्दिष्ट में अपनी सही तर्क के तत्व को हासिल करेगा। बाएं तर्क 10 ( ⁵इसके बाएं) और दाएं तर्क [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] (पिछले परिणाम) के साथ, यह 4 देता है ।

इस बिंदु तक की श्रृंखला एक अप्राप्य निलाद द्वारा पीछा की जाती है ⁵, इसलिए STDOUT में मुद्रित पिछला रिटर्न मान ( 4 ), वापसी मान 10 पर सेट होता है , और शेष श्रृंखला हमेशा की तरह पार्स होती है।

पहले की तरह, ⁵ḶxḶसरणी [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] का उत्पादन करेगा । इस बार, हम तर्क 10 पर सॉर्ट किए गए परमाणु Ṣको कहते हैं , जो 10 को [1, 0] को बढ़ावा देता है , फिर इसे उपज के लिए सॉर्ट करता है [0, 1] । Dyadic सिर परमाणु अब लंबाई की उपसर्गों को हासिल करेगा 0 और 1 बाईं ओर परिणाम से, के साथ हमें छोड़ रहा है [[], [1]] । जब मुद्रित, कुछ भी नहीं लेकिन 1 दृश्यमान रहेगी।

⁽{ʂ%⁽{}

⁽और इसके दो निम्नलिखित वर्ण एक संख्यात्मक शाब्दिक हैं। यदि जेली के कोड पृष्ठ में j और k उनके कोड पॉइंट हैं और (j, k) <(124, 250) , तो हमें पूर्णांक 1001 + 250j + k मिलता है । के कोड अंक '{' , '}' , और 'ʂ' कर रहे हैं 123 , 125 , और 167 है, इसलिए करने के लिए शाब्दिक मूल्यांकन करता छोड़ दिया 1001 + 250 × 123 + 167 (= 31918) है, जबकि सही एक का मूल्यांकन 1001 + 250 × 123 + 125 (= 31876) ।

चूँकि बायाँ पूर्णांक दो बार जितना छोटा है, उतना ही सही है, परिणाम (… + 167)% (… + 125) = (… + 167) - (… + 125) = 167- 125 = 42 है ।

ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®

फेरबदल परमाणु Ẋअपने तर्क के तत्वों का क्रम randomizes; एक संख्यात्मक तर्क z को पहले से [1,…, z] श्रेणी में पदोन्नत किया जाता है । निहित तर्क 0 के लिए , यह सीमा खाली है और Ẋपैदावार [] । सभी परमाणु Ạरिटर्न 1 अगर इसके तर्क के तत्वों के सभी truthy, कर रहे हैं 0 नहीं तो। चूँकि एक खाली सरणी में मिथ्या तत्व नहीं होते हैं, इसलिए 1 यहाँ Ạलौटाता है।

साथ जिप परमाणु ż(एक दो का समूह) तर्क लेता है x और y और जोड़ी transposes [एक्स, वाई] । पूर्णांक x और y के लिए , यह बस [[x, y]] देता है , इसलिए यह विशेष रूप से ż, तर्क 1 और 0 (अंतर्निहित तर्क) के साथ, रिटर्न [[1, 0]] । Dyadic eval परमाणु v, सभी फ्लैट सरणियों (युक्त केवल अंक और अक्षर) मैं तार में बाईं तर्क बदल जाता है तो कार्यक्रमों के तर्क के रूप में अपनी सही तर्क के साथ monadic जेली कार्यक्रमों के रूप में जिसके परिणामस्वरूप तार मूल्यांकन करता है। चूंकि ["10"]पूरी तरह से शाब्दिक हैं, यह सही तर्क की उपेक्षा करता है vऔर बस [10] परिणाम देता है ।

प्रति त्वरित ©करने के लिए देता vहै और प्रतियां रजिस्टर में इसके परिणाम। बाद में रिकॉल एटम ®(एक निलाद) की घटनाएँ रजिस्टर से [10] प्राप्त करेंगी ।

[१०] से [[१०] , [१००] से [१००] तक [१००००] तक [१०]żv मैपिंग से पहले की तरह की अगली तीन प्रतियां । आदेश परमाणु परीक्षण कितनी बार अपने बाएँ तर्क इसलिए यहाँ अपने अधिकार एक से विभाज्य है, इसके बारे में आदेश की गणना 10 (साथ लाए जाने में) 10000 = 10 ⁴ , उपज [4] ।ọ®

निम्नलिखित ®एक अप्राप्य निलाद है, इसलिए पिछले रिटर्न मान ( [4] ) को STDOUT में मुद्रित किया जाता है, फिर निलाड के मूल्य ( 10 ) के साथ बदल दिया जाता है । हम Ạअगले आवेदन करते हैं , 1 उपज । (यह एक बिंदु के रूप में निषाद के बाद इस बिंदु पर पार्स करने योग्य होगा के रूप में आवश्यक है।)

पहले की तरह, żvżvżvतीन रिटर्न को मौजूदा रिटर्न वैल्यू में जोड़कर 1 को [1000] में बदल दिया । अंत में, 1000 = 10 ³ में 10ọ® के क्रम की गणना करता है , और जब प्रोग्राम समाप्त हो जाता है तो 3 को STDOUT में प्रिंट किया जाता है।

फिर भी एक और प्रतिगामी, फिर भी एक और शाब्दिक।

111111l11&K1111111Kl11&

सबसे पहले और सबसे महत्वपूर्ण, शाब्दिक 111111तर्क और प्रारंभिक वापसी मूल्य 111111 है । अन्य रन 1भी शाब्दिक हैं।

lहै लघुगणक परमाणु, जो आधार सही एक में निर्दिष्ट करने के लिए अपनी बाईं तर्क के लघुगणक गणना करता है। जब सही तर्क 11 के साथ 111111 पर कॉल किया जाता है , तो हमें लॉग ₁₁ 111111। 4.85 मिलता है ।

शब्द परमाणु Kरिक्त स्थान एक सूची तर्क मिलती है, एक अंकीय / चरित्र को बढ़ावा देने के बाद जेड को [z] । यहाँ, हम इसका उपयोग लिंक के तर्क को 111111 को [111111] में बदलने के लिए करते हैं । (हमें यहां एक सरणी की आवश्यकता नहीं है, लेकिन हम पहचान परमाणुओं से बाहर निकल चुके हैं।) बिटवाइंड और परमाणु &दोनों पक्षों में वापसी मान लेता है, यदि आवश्यक हो, तो उन्हें पूर्णांक में डाल देता है और उनकी बिटवाइज़ की गणना करता है। इस विशेष मामले में, यह [4.85 और 111111] = [4 और 111111] = [4] रिटर्न करता है ।

निम्नलिखित 1111111एक अप्राप्य निलाद है, इसलिए पिछले रिटर्न मान ( [4] ) को STDOUT में मुद्रित किया जाता है, फिर निलाड के मूल्य ( 1111111 ) के साथ बदल दिया जाता है । Kफिर इस पूर्णांक को [1111111] में बदल देता है । (यह एक बार फिर वास्तव में आवश्यक नहीं है, लेकिन एक डाईलाड के बाद एक निलाद इस बिंदु पर पार्स करने योग्य होगा।)

पहले की तरह, l11गणना ₁₁ 1111111 , 5.81 लॉग इन करती है , फिर &रिटर्न [5.81 और 111111] = [5 और 111111] = [5] ।

,SS
ỊỊ,ÇS
ÇÑÇÇÇÑ

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

शीर्ष लिंक में जोड़ी परमाणु शामिल है ,- एक डाईड जो तर्कों को x और y को [x, y] में बदल देता है - और योग परमाणु S- एक मोनाद जो एक पूर्णांक तर्क z [z] को बढ़ावा देता है और इसके अलावा एक सरणी तर्क को कम करता है। जब लिंक ,SSको पूर्णांक तर्क n के साथ बुलाया जाता है , तो यह n [n, ]n] = Σ [n, n] = 2n की गणना करता है ।

मध्य लिंक में उपरोक्त परमाणु, पूर्वोक्त त्वरित Ç, और तुच्छ परमाणु शामिल हैं Ị- एक ऐसा मौद्रिक जो 1 से argu z , 1 के साथ संख्यात्मक तर्कों के लिए 1 उपज देता है , लेकिन अन्य सभी के लिए 0 । Ịदो बार एक पूर्णांक तर्क पर लागू होता है n अनिवार्य रूप से 1 के साथ बदल देता है , क्योंकि पहला Ị( दूसरा इनपुट ) का आउटपुट हमेशा महत्वहीन होता है। इस परिणाम को उसके रिटर्न वैल्यू के साथ जोड़ा Çजाता है (जिसे तर्क n के साथ कहा जाता है ), और परिणामस्वरूप जोड़ी को घटा दिया जाता है S। कुल मिलाकर, हम गणना करते हैं| [(| N | ≤ 1), 1, 2n] = 1 [1, 2n] = 2n + 1 ।

जगह में इन दो सहायक लिंक के साथ, मुख्य लिंक अब अपने द्विआधारी अंकों को देखकर किसी भी गैर-नकारात्मक पूर्णांक का निर्माण कर सकता है। 0 के प्रारंभिक रिटर्न मूल्य के साथ , श्रृंखला ÇÑÇÇÇÑअंतिम परिणाम की गणना करती है (((((0 × 2 + 1) × 2) × 2 + 1) × 2 + 1) × 2 + 1) × 2 = ((5 ×) 2 + 1) × 2 + 1) × 2 = 46 ।

ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn

अगले प्रधानमंत्री परमाणु छोटी से छोटी सकारात्मक अभाज्य संख्या है कि इसके तर्क से सख्ती से अधिक है पाता है। प्रारंभिक वापसी मूल्य 0 के साथ , पंद्रह Ænअभाज्य संख्याओं की गणना करता है, जो कि 47 है ।

— डेनिस
स्रोत

7

मैं सारा दिन नीम के 38 तक पकड़ने की कोशिश में बिता रहा हूं और फिर मैं इसे नीचे देखता हूं और देखता हूं। चुनौती स्वीकार की गई!

— झबरा

1

TL, डॉ। आप इसे 47 तक गिन सकते हैं, और आप जेली में एक जादूगर हैं।

— कैस्केडिंग-शैली

चुनौती में अनुरोध के अनुसार "परमाणु" सिंगल बाइट्स के सभी हैं? यदि हां, तो यह कौन सा एन्कोडिंग है?

— M.Herzkamp

4

@ M.Herzkamp जेली अपने स्वयं के कोड पृष्ठ का उपयोग करती है ।

— डेनिस

1

मैंने अब पहली बार विवरण को विस्तार से पढ़ा। यह वास्तव में प्रभावशाली है। इनमें से कुछ सिर्फ हास्यास्पद हैं :-)

— स्टीवी ग्रिफिन

62

ब्रेनफक , स्कोर 2, 255 144 10 बाइट्स

... हाँ, सबसे अच्छा विचार नहीं है क्योंकि मेरे पास केवल 8 अक्षर हैं (टारपिट्स को tarpit) के साथ काम करने के लिए लेकिन चलो देखते हैं कि कितना संभव है। ~~मुझे लगता है कि यह सब संभव है। : P~~ यह उत्तर उन आठ वर्णों में से छह को प्रदर्शित करता है ,जो ब्रेनफक उपयोग करता है, अन्य दो जा रहा है , जो इनपुट है और ., जो आउटपुट है।

+
>--[<->-]

यह कल्पना ऑनलाइन!

व्याख्या

प्रत्येक संख्या को टेप पर शुरुआती सेल पर बनाया और संग्रहीत किया जाता है। भारी रूप से रैपिंग कोशिकाओं पर निर्भर करता है, जो कुछ दुभाषियों में लागू नहीं होते हैं।

1 :

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

+  increment the current cell

[ 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

2 :

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-- decrement the current cell twice

[ 0 |254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[  while the current cell is not 0
<  move to the previous cell
-  decrement the current cell

[255|254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-  decrement the current cell

[255|253| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

]  repeat while the current cell is not 0

...

[ 3 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[ 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

[ 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

— totallyhuman
स्रोत

5

अब इसे ब्रेन-फ्लैक में करें। : पी

— DJMcMayhem

38

नीम , स्कोर 38, 327 बाइट

1: 𝔼
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: β
11: γ
12: δ
13: ε
14: ζ
15: η
16: θ
17: ι
18: κ
19: λ
20: μ
21: ν
22: ξ
23: π
24: ρ
25: σ
26: ς
27: τ
28: υ
29: φ
30: χ
31: ψ
32: ω
33: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
34: <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<𝐀
35: 𝐓0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻
36: ℂ𝐋𝐠𝐋𝐠𝐋𝐠𝐋𝐝𝐬𝕏𝐬
37: α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊
38: 𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝐥

स्पष्टीकरण:

1 के लिए, हम 'चेक फॉर इक्वैलिटी' टोकन का उपयोग करते हैं, यहां शोषण करते हैं कि जब नीम खाली इनपुट पर पॉप करने का प्रयास करता है, तो इसे 0. मिलता है। 0 के रूप में 0 और 0 बराबर होते हैं, यह 1 धक्का होता है, जो स्पष्ट रूप से मुद्रित होता है
2 से 9 तक, हम केवल संख्यात्मक शाब्दिक का उपयोग करते हैं।
10 से 32 के बीच, नीम वास्तव में उन सभी के लिए एक बाइट स्थिरांक है (हाँ, यह पागल है)।
33 के लिए, हम केवल वेतन वृद्धि कमांड का उपयोग करते हैं। पहली बाइट पर, नीम कुछ पॉप करने की कोशिश करता है ताकि वह इसे बढ़ा सके, लेकिन चूंकि इनपुट खाली है, यह पॉपिंग के लिए चूक करता है 0।
34 के लिए, हम एक ही दृष्टिकोण का उपयोग करते हैं, लेकिन निस्तारण, और निरपेक्ष मूल्य लेते हैं।
35 के लिए, हम इस तथ्य का फायदा उठा रहे हैं कि शून्य फैक्टरियल एक है, और हम इसका उपयोग एक को दोहराकर और बार-बार जोड़कर करते हैं
३६ के लिए, हम ℂ० और ० को को-प्राइमलिटी के लिए जाँचते हैं, जो कि वे हैं। यह पुश करता है 1. तब हमें पहला प्राइम प्राप्त होता है 𝐋, जिसके परिणामस्वरूप एक सिंगलटन सूची मिलती है, जिसमें सिर्फ 2. होता है। हमें सबसे बड़ा तत्व ( 𝐠) मिलता है, जो 2 को एक संख्या के रूप में धकेलता है। तब तक हम इस प्रक्रिया को दोहराते हैं जब तक हमें सूची नहीं मिलती [2 3 5 7 11]। उसके बाद, हम 𝐝डेल्टास की गणना करने के लिए उपयोग करते हैं, जिसके परिणामस्वरूप सूची [1 2 2 4]। अगला, हम 𝐬राशि प्राप्त करने के लिए उपयोग करते हैं - जो 9 है - फिर हम 0 से 9 तक अनन्य रेंज की गणना करते हैं, जिसके परिणामस्वरूप [0 1 2 3 4 5 6 7 8]। अंत में, 𝐬37 प्राप्त करने के लिए फिर से उपयोग किया जाता है।
37 के लिए, αएक स्थिरांक है जो नकारात्मक का प्रतिनिधित्व करता है, और हम बार-बार इसे धक्का देते हैं और घटाते हैं (फिर से इस तथ्य का फायदा उठाते हैं कि जब हम खाली इनपुट पर पॉपिंग का प्रयास करते हैं, तो 0 को धक्का दिया जाता है)
38 के लिए, खाली इनपुट के लिए एक बार फिर डिफ़ॉल्ट 0 का उपयोग करते हुए, हम 0 को अपने आप से जोड़ते रहते हैं, एक लंबी सूची बनाते हैं, फिर लंबाई की गणना करते हैं।

यहां कोशिश की जा सकती है

— Okx
स्रोत

3

आपने 36-37 के आसपास कुछ मिलाया है।

— आउटगोल्फ

2

हालांकि उन विशेष पात्रों को 1 से अधिक बाइट के साथ एन्कोड नहीं किया गया है? यदि ऐसा है, तो यह मॉथेरेप के बाइट काउंटर के अनुसार इसे 860 बाइट्स बना देगा और चुनौती नियम कहता है कि all characters must be encoded using a single byte in the language you choose। क्या नीम केवल 1 बाइट में उन विशेष पात्रों को एनकोड करता है? कैसे?

— हांक्रेकॉर्ड्स

8

@Hankrecords नीम

— ओएक्सएक्स

2

आपने 1अभी तक चरित्र का उपयोग नहीं किया है। निश्चित रूप से आप कुछ उपयोग कर सकते हैं?

— बरगी

34

अजगर 2, 15

यहाँ एक शुरुआत है, और अधिक की तलाश में

लेओ की बदौलत जिसकी टिप ने मुझे 15 में लाने में मदद की

[[[]]>[]][[]>[]]>>[[]>[]][[]>[]]

import math
print'%i'%math.pi

((()<())<())<<((()<())<())<<((()<())<())

11^1

33/3

4--4--4

__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__

q=""=="";qq=q=="";qqq=~q*~q*~q;~qqq*~q*~qq

0xF

— श्रीओटचिलिज्म ओ'जैसिक
स्रोत

2

आप कुल बाइट की संख्या के -~-~-~-~-~-~-~-~-~[[]==[]][[]<[]]लिए 10 और 0xD13 के लिए उपयोग कर सकते हैं

— 14

क्या आप कुछ इस तथ्य का उपयोग कर सकते हैं ''is''जो एक और संख्या बनाने के लिए सही मूल्यांकन करता है?

— नॉट्स90

@ Nots90 दुर्भाग्य से मैं ऑपरेशन से बाहर हूं। यदि आपको नए नंबर बनाने का कोई तरीका मिल जाता है या अगर बूलियन्स मुझे बताएं

— श्रीकोटिलिज्म ओ'जैसिक

1

14 को एक समापन परेड याद आ रही है:((()<((),))|(()<((),))<<(()<((),))|(()<((),))<<(()<((),))<<(()<((),)))<<(()<((),))

— TemporalWolf

1

रिकॉर्ड के लिए, आपके नवीनतम संशोधन ने निम्नलिखित का उपयोग नहीं किया है string.printable:

c, j, k, l, s, v, w, y, z, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, !, #, $, &, ., :, ?, @, \\, `, {, }, \t, \r, \x0b, \x0c

— wnnmaw

23

जाप , 448 बाइट, स्कोर 42

झबरा , ETHproductions और ओलिवर के बीच एक बड़ा सहयोग ।

v
y
Íà
Qiiii)iiii)âQ
ÂHq
LÁL
´Vn´VnVnVn
8
9
A
B
C
D
E
F
G
J-----J---J---J---J
[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x
;Iìw
~~½e½e½e½e~½e½
++T+++T+++T+++T+++T+++T
22
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
4á
5²
°UU°°°U°°U°°U°°U°°U
»³³
7/¼
$'_____________________________b'$bb
ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa
Sc
33
Mg011
##
6p
Rí í í í í è.
`¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥`l
¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o
º¤¤*º¤*º¤
(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å
Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

ये (उपयोगी) वर्ण बचे हैं:

!%&,:=>?@OPWX\dfhjkrstuz{}¡¢£¦§©ª«¬®¯¸ÀÃÆÇÈÐßãäåæçéêëîïñóôõö×øÿ

स्पष्टीकरण

जाप के बारे में कुछ बातें जानने से पहले हम शुरू करते हैं, कि मैंने लगातार उपयोग किया है। सबसे पहले, Japt में इनपुट के लिए 6 वैरिएबल हैं, जो अपरकेस अक्षर हैं U-Z। यदि उन चरों के माध्यम से कोई इनपुट पारित नहीं किया जाता है, तो वे सभी डिफ़ॉल्ट होते हैं 0। दूसरी बात इस टिप में शामिल है ।

ऑनलाइन इंटरप्रेटर में इसे आजमाने के लिए किसी भी स्निपेट पर क्लिक करें ।

जब किसी संख्या पर लागू किया जाता है, तो vविधि एक पूर्णांक n को एक तर्क के रूप में लेती है, और यदि संख्या n , 0 से विभाज्य है तो 1 देता है यदि नहीं। यदि n की आपूर्ति नहीं की गई है तो यह 2 को डिफॉल्ट करता है । 0 (डिफ़ॉल्ट मान ) 2 से विभाज्य है , इसलिए यह हमें हमारा 1 देता है ।U

पहले वाले के समान। किसी संख्या पर लागू होने पर, yविधि एक पूर्णांक n को तर्क के रूप में लेती है, और दो संख्याओं के GCD को लौटा देती है। यदि n की आपूर्ति नहीं की गई है तो यह 2 में चूक जाता है । चूँकि 0 2 से विभाज्य है , GCD (0, 2) हमें हमारा 2 देता है ।

Íà

Ín(2)या 2- के लिए शॉर्टकट है this। क्योंकि हमारे पास कोई इनपुट नहीं है, इसलिए हम डिफ़ॉल्ट thisहोते हैं 0, जिसके परिणामस्वरूप 2-0 = 2।

àके संयोजन की संख्या देता है [1...this], जो 3 देता है

Qiiii)iiii)âQ

Qएक एकल उद्धरण चिह्न के लिए चूक। iएक स्ट्रिंग पर शुरुआत में एक और स्ट्रिंग सम्मिलित करता है; जैसा कि # 3 में बताया गया है , प्रत्येक JS में iiii)समतुल्य है .i("i".i("i")), इस प्रकार iस्ट्रिंग की शुरुआत में दो प्रतियां सम्मिलित हैं । इसे दो बार करें और आपके पास स्ट्रिंग है iiii"। âQफिर अनुकरण करता है .search(Q), "स्ट्रिंग में पहले का सूचकांक देता है, जो 4 है ।

ÂHq

H32 के लिए स्थिर है । किसी संख्या पर लागू होने पर qविधि, जो पूर्णांक n को तर्क के रूप में लेती है, उस संख्या के n ^वें मूल को लौटाती है । यदि n की आपूर्ति नहीं की गई है तो डिफ़ॉल्ट मान 2 है इसलिए Hqहमें 32 का वर्गमूल देता है जो लगभग 5.6568 है । Âशॉर्टकट है ~~, जो परिणाम देता है, हमें 5 देता है ।

LÁL

L100 के लिए पूर्व निर्धारित है , और (शून्य-बिट बिटवाइज़ राइट शिफ्ट) के Áलिए शॉर्टकट है >>>। 100>>>100के रूप में ही है 100>>>4(सही ऑपरेंड wraps मॉड 32), जो 6 है ।

´Vn´VnVnVn

जैसा कि पहले उल्लेख किया गया है, Vचूक 0 से । ऑपरेटर के ´लिए शॉर्टकट है --, इसलिए कोड निम्नलिखित JS के बराबर है:

(--V).n((--V).n(V.n(V.n())))

X.n(Y)Y - X , या -X + Y के बराबर है ; पहला --Vरिटर्न -1 , और दूसरा -2 , इसलिए यह - (- 1) + (- (- 2) + (- (- 2) + - (- 2)) के बराबर है । सरल करते हुए, हमें 1 + 2 + 2 + 2 = 7 मिलता है ।

8
9

शाब्दिक रूप से, 9 और ९ ।

A
B
C
D
E
F
G

ये 10 - 16 के लिए स्थिरांक हैं , समावेशी।

J-----J---J---J---J

J-1 के लिए पूर्व निर्धारित है । जाप दुभाषिया किसी भी तरह से इस सही ढंग से पार्स करने का प्रबंधन करता है (J--) - (--J) - (--J) - (--J) - (--J)। कुछ और गणित करते हुए, हम पाते हैं कि यह (-1) - (-3) - (-4) - (-5) - (-6) , या -1 + 3 + 4 + 5 + 6 = 17 के बराबर है। ।

[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x

¾जैसा कि आप अनुमान लगा सकते हैं, के लिए एक शॉर्टकट .75। हम 24 प्रतियां डाल 0.75 एक सरणी में है, तो साथ योग x, दे रही है 0.75 * 24 = 18 ।

;Iìw

मुझे लगता है कि यह मेरा पसंदीदा है। ;कार्यक्रम की शुरुआत में कुछ जाप स्थिरांक के मूल्यों में परिवर्तन होता है; बिना यह Iहै 64 है, लेकिन इसके साथ, Iहै 91 । ìwइसे अंकों की सूची में परिवर्तित करता है और wसूची पर चलता है , सरणी को उलटता है, फिर हमें 19 प्राप्त करने के लिए एक संख्या में वापस परिवर्तित करता है ।

~~½e½e½e½e~½e½

½के लिए एक शॉर्टकट है .5। eसंख्या x में एक तर्क y लेता है और x * 10 ^{y देता है} । तो होने वाली गणना की श्रृंखला है:

           ½e½     1.5811  (.5 * sqrt(10))
          ~       -2
        ½e         0.005  (.5 * (10 ** -2))
      ½e           0.5058
    ½e             1.6024
  ½e              20.0138

और फ़ाइनल ~~इसे एक पूर्णांक तक फ़्लोर करने का कार्य करता है, जो हमारे 20 परिणाम का परिणाम देता है ।

++T+++T+++T+++T+++T+++T

T0 पर पूर्व निर्धारित है । ++जेएस में वेतन वृद्धि संचालक है और जाप में भी; T+++Tके रूप में पार्स किया जाता है (T++) + T, लेकिन ++T+++Tइसे पार्स किया जाता है (++T) + (++T), इसलिए यह JS कोड के बराबर है

(++T) + (++T) + (++T) + (++T) + (++T) + (++T)

परिणाम 1 + 2 + 3 + 4 + 5 + 6 है , जो 21 तक बैठता है ।

एक शाब्दिक २२ ।

ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ

Äके लिए एक शॉर्टकट है +1, इसलिए यह केवल 23 1 s पर हस्ताक्षर करता है ।

4á

यह 4 के क्रमपरिवर्तन की संख्या [1, 2, 3, 4]ज्ञात करता है , जो कि 4 है! = 24 ।

5²

²एक शॉर्टकट है p2, जो दो की शक्ति के लिए एक संख्या को बढ़ाता है। 5 ** 2 है 25 ।

°UU°°°U°°U°°U°°U°°U

°++ऑपरेटर के लिए एक शॉर्टकट है , या यदि इसे इस तरह से पार्स नहीं किया जा सकता है, तो + +। जैसा कि पहले उल्लेख किया गया है, जब कोई इनपुट नहीं है, तो 0 सेU चूक । तो कोड के बराबर है , जो बहुत ही के समान है # 17 : पहले करने के लिए वृद्धि की जाती है तो बार-बार वृद्धि की जाती है और इस तरह यह भी कहा कि अंतिम परिणाम है, 1 + 3 + 4 + 5 + 6 + 7 = 26 ।(++U), (U++) + + (++U) + + (++U) + + (++U) + + (++U) + + (++U)U1

»³³

³3 केp तर्क के साथ विधि के लिए शॉर्टकट है । हालांकि, अगर एक निचला अक्षर बाएं-कोष्ठक के बाद सीधे प्रकट होता है ( यह शॉर्टकट है ), तो यह एक स्ट्रिंग बन जाता है। यह इसे एक विधि से पास होने देता है और एक फ़ंक्शन के रूप में बुलाया जाता है (यानी मैपिंग द्वारा )। इस मामले में, हालांकि, हमारा रिटर्न , फिर हम इसे ( एक संख्या पर लागू होने पर शक्ति विधि है) की शक्ति तक बढ़ाते हैं , जो हमें हमारा 27 देता है ।»((m³.p(3)("p",3)33p

7/¼

¼, जैसा कि आप शायद अब तक जानते हैं, एक शॉर्टकट है .25, इसलिए यह 7 / 0.25 = 28 की गणना करता है ।

$'_____________________________b'$bb

$प्रतीकों में लिपटे किसी भी चीज़ को शुद्ध जावास्क्रिप्ट के रूप में माना जाता है, इसलिए हमें 29 अंडरस्कोर का तार मिला है, उसके बाद ए b। (बिना $, 'एक एकल-वर्ण स्ट्रिंग होगी।) bजब किसी स्ट्रिंग पर लागू किया जाता है, तो उस स्ट्रिंग के भीतर इसके तर्क का पहला सूचकांक वापस आ जाता है। जैसा कि # 3 में बताया गया है , अंतिम bको एक स्ट्रिंग में बदल दिया जाता है, इसलिए हम bअपने स्ट्रिंग के पहले इंडेक्स को पकड़ रहे हैं , जो कि 29 है ।

ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ

µ-=और के Éलिए एक शॉर्टकट है -1। प्रभाव 0 से 0 की 30 प्रतियों को घटा रहा है , जो 30 देता है ।

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa

बहुत पसंद है # 29। aविधि, जब एक स्ट्रिंग के लिए आवेदन किया, कि स्ट्रिंग में अपने तर्क के अंतिम सूचकांक देता है। 0-इंडेक्सिंग का उपयोग करते हुए, a32 aएस के एक स्ट्रिंग में अंतिम इंडेक्स 31 है ।

Sc

Sएक एकल स्थान पर पूर्वनिर्धारित है, और cएक एकल-चर स्ट्रिंग पर अपना चार-कोड लौटाता है, 32 ।

शाब्दिक 33 ।

Mg011

MgNNth फाइबोनैचि संख्या देता है। 011है 9 अष्टाधारी में; 9 वीं फाइबोनैचि संख्या 34 है ।

##

#अगले चरित्र का चार-कोड लौटाता है। #स्वयं का चार-कोड 35 होता है , यहाँ हमारा काम विशेष रूप से आसान है।

6p

pप्रतिपादक है, और एक दूसरे तर्क के बिना यह 2 को चूकता है ; इस प्रकार, यह प्रिंट 6 ** 2 = 36 है ।

Rí í í í í è.

यह एक बल्कि मुश्किल है। Rएक ही न्यूलाइन वर्ण में चूक (कि यह एक नई पंक्ति बाद में महत्वपूर्ण हो जाती है)। íबिना किसी तर्क के, प्रत्येक वर्ण को लेता है और इसके सूचकांक को जोड़ देता है: एक बेकार परिवर्तन, लेकिन 5 पुनरावृत्तियों के माध्यम से परिणाम यह है: ( Rशाब्दिक नई रेखा के बजाय)

R
R0
R001
R0010213
R001021304251637
R0010213042516370849210511112613314715

दिलचस्प है कि कैसे प्रत्येक प्रविष्टि अगले का केवल एक उपसर्ग है ... लेकिन वैसे भी, अंतिम भाग è., मायने रखता है कि /./gपरिणाम में कितने मैच पाए गए हैं। स्ट्रिंग में 38 वर्ण हैं; हालाँकि, चूंकि /./gकेवल गैर-नईलाइन चार्ट से मेल खाता है, परिणाम 37 है ।

¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥l

बैकटिक्स एक संकुचित स्ट्रिंग, और डिकम्प्रेसेस को चिह्नित ¥करते हैं ll। lएक स्ट्रिंग पर lउत्कीर्णन देता है , इसलिए अपघटन के बाद, यह 38 देता है ।

¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o

ऊह लड़का, यह एक डोज है। सबसे पहले, हम के trueसाथ उत्पन्न ¨N( ¨के लिए खड़ा है >=, और Nकोई जानकारी के साथ खाली सरणी है), तो उस के 1साथ परिवर्तित करें |N। वहाँ से यह बहुत पागल हो जाता है:

ò    Inclusive range [0..1],            [0, 1]
 ò   making each an inclusive range.    [[0], [0, 1]]
m·   Join each on newlines.             ["0", "0\n1"]
·    Join on newlines.                  "0\n0\n1"
·    Split on newlines.                 ["0", "0", "1"]
m    Map each item X and index Y to     
 |     X | Y.                           ["0" | 0, "0" | 1, "1" | 2] -> [0, 1, 3]
m    Map each by 
 ò     inclusive range.                 [[0], [0, 1], [0, 1, 2, 3]]
m··· Same as before.                    ["0", "0", "1", "0", "1", "2", "3"]
m|   Bitwise OR thing again.            [0, 1, 3, 3, 5, 7, 7]
mò   Map each by inclusive range.       [[0], [0, 1], ..., [0, 1, 2, 3, 4, 5, 6, 7]]
m··· Same as before.                    ["0", "0", ..., "5", "6", "7"]
m|   Bitwise OR again.                  ["0"|0, "0"|1, ..., "5"|30, "6"|31, "7"|32]
                                        -> [0, 1, ..., 31, 31, 39]

( ¹एस पास-पार्न्स के लिए केवल विकल्प हैं और छोड़ दिया गया है।) अंतिम oतब पॉप होता है और सरणी में अंतिम आइटम 39 देता है ।

º¤¤*º¤

ज्यादातर # 3 के साथ एक ही चाल है । 2 के तर्क के साथ विधि के ¤लिए शॉर्टकट है । हालाँकि, इस मामले में, ट्रांसप्लड कोड है , या सरलीकृत, है । आधार -2 स्ट्रिंग के रूप में संख्या देता है, जो देता है ; अंतर्निहित रूप से यह एक संख्या में परिवर्तित हो जाता है और 4 से गुणा करता है , 40 देता है ।s(("s", 2).s(2) * (("s", 2) * (("s", 2))))(2).s(2) * (2 * 2).s(2)"10"* (2 * 2)

(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å

पिछले वाले के समान। 1 के तर्क के साथ विधि के Åलिए शॉर्टकट है । इस मामले में, हालांकि, प्रत्येक ट्रांसपाइल्स , जो सिर्फ 1 रिटर्न देता है । है 32 , और है 8 ; ये 41 प्राप्त करने के लिए एक साथ XORed हैं ।s(Å("s", 1)1<<1<<1<<1<<1<<11<<1<<1<<11

Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

±+=और के ¶लिए एक शॉर्टकट है ===। इसका मतलब है कि कोड वास्तव में है

Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y

Y===Y हमेशा सच होता है, इसलिए हम इसे सरल बना सकते हैं:

Y+=1,Y+=Y,Y+=Y+=1,Y+=Y,Y+=Y+=1,Y+=Y

0 + 1 = 1 ; 1 + 1 = 2 ; 2 + (2 + 1) = 5 ; 5 + 5 = 10 ; 10 + (10 + 1) = 21 ; 21 + 21 = 42 ।

— ETHproductions
स्रोत

वाह, यह अब बहुत अच्छा हो रहा है :-) आप वापस Iqपाने के लिए 8 का उपयोग कर सकते हैं 8, आपको 19 के लिए कुछ और खोजना होगा।

— ETHproductions

@ETHproductions: सिर्फ इस्तेमाल किया qके लिए 5मुझे इस्तेमाल करने की इजाजत दी lएक अतिरिक्त नंबर जोड़ने के लिए। इसके लिए एक विकल्प पर काम करना 2मुझे =वापस मिल सकता है ।

— झबरा

@Shaggy आप उपयोग कर सकते हैं (¤2 के लिए L>>Lखाली कर सकते हैं 6. #w s Åखाली कर सकते हैं ;औरI

— ओलिवर

2, @obarakon के लिए अच्छी चाल; मैं भी 3 मुक्त करने के लिए कुछ इसी तरह का इस्तेमाल किया। दुर्भाग्य से यह 19 के लिए काम नहीं करेगा क्योंकि मैंने पहले ही #21 के लिए उपयोग किया है।

— झबरा

मुझे लगता है कि आप कुछ बाइट्स को बचाने और वापस पाने के लिए 18 के साथ 22 को स्वैप कर सकते हैं *और^

— ETHproductions

18

पीएचपी, स्कोर 17, 130 बाइट्स

पात्रों का इस्तेमाल किया ADEFGIKLMOPRSTVXYZ=_![]()<>'"#$,;/-+*|^&0123456789afhnprstwx

Z==Z
FTP_MOREDATA
';'&w
![]<<![]<<![]
5
6
"#"|"$"|"1"
8
SIGKILL
333333>>3>>3>>3>>3>>3
99/9
22-2-2-2-2-2
strspn(XXXXXXXXXXXXXX,X)
7+7
0xf
4*4
ha^YV

1 बूलियन निरंतर Z (सेट नहीं) बराबर स्थिर Z

2 FTP_MOREDATA PHP में एक मान 2 के साथ एक स्थिर है

3 बिटवाइज़ और चार्ज़; और

4 बिटवाइज़ शिफ्ट छोड़ दिया और तार्किक खाली बूलियन को सही नहीं डाला, शिफ्ट बचे ऑपरेटर के माध्यम से पूर्णांक 1 में डाला जाता है

7 बिटवाइस या चर # और $ और 1

9 SIGKILL PHP में एक मान 9 के साथ एक स्थिर है

10 बिटवाइज़ शिफ्ट राइट हर चरण 8 के साथ पूर्णांक विभाजन है, इसलिए हमारे पास 333333, 41666, 5208, 651, 81, 10 चरण हैं

शुरू से ही स्ट्रिंग X में 13 काउंट चार X ...

15 हेक्साडेसिमल मान f = 15

स्ट्रिंग्स हा और YV के साथ 17 बिटवाइज़ Xor

सभी स्निपेट्स एक सरणी में आइटम हैं

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

PHP, स्कोर 16, 94 बाइट्स

पात्रों का इस्तेमाल किया AEIMPRTUZeflnrstvwx^_&|()[]=!.*+/-<>$":0123456789

Z==Z
":"&"w"    
M_PI|[]
TRUE<<TRUE<<TRUE
5
6
A^v    
8
9
!$s.strlen($s)    
77/7
3+3+3+3
111>>1>>1>>1    
22-2-2-2-2
0xf
4*4

1 बूलियन निरंतर Z (सेट नहीं) बराबर स्थिर Z

2 बिटवाइज़ और चार्ज़: और डब्ल्यू

3 Pi शून्य से डाली गई खाली सरणी के माध्यम से पूर्णांक मान पर डाली गई

7 बिट वाइज xor वर्ण A और v

10 चर $ s सेट नहीं है! $ S = चर $ s की स्ट्रिंग लंबाई के साथ एक समतल

13 111/2 = 55/2 = 27/2 = 13 पूर्णांक विभाजन बिटवाइज़

15 हेक्साडेसिमल मान f = 15

सभी स्निपेट्स एक सरणी में आइटम हैं

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

PHP, स्कोर 14, 84 बाइट्स

पात्रों का इस्तेमाल किया $!_^[]()%/+~-=AEILMNPRUZ0123456789delnrstx

Z==Z
2
M_PI^[]
4
5
6
ERA%11
8
9
!$s.strlen($s)
77/7
3+3+3+3
0xd    
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-NULL

1 बूलियन निरंतर Z (सेट नहीं) बराबर स्थिर Z

3 Pi शून्य से डाली गई खाली सरणी के माध्यम से पूर्णांक मान पर डाली गई

7 ईआरए 131116 मॉड 11 = 7 के मान के साथ एक स्थिर है

10 चर $ s सेट नहीं है! $ S = चर $ s की स्ट्रिंग लंबाई वाला एक कंबेट शून्य है

13 हेक्साडेसिमल मान d = 13 14 बिटवाइज़ नहीं और माइनस साइन NULL से 14 बढ़ा

सभी स्निपेट्स एक सरणी में आइटम हैं

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

— जार्ग हुल्सरमैन
स्रोत

17

आर, स्कोर १३ १४

F^F                       # F==0 in R
q=""=="";q--q             # ""=="" is TRUE, TRUE == 1 (Thanks WheatWizard)
3
4
5
6
7
8
9
1e1                       # scientific notation for 10
22/2
T+T+T+T+T+T+T+T+T+T+T+T   # T == 1
0xD                       
sum(mtcars$vs)            # mtcars is a built-in dataset, summing the $vs column gives 14

User2390246 के लिए एक अतिरिक्त धन्यवाद मिला।

उपयोग किए गए वर्ण:

0123456789acemqrstuvxDFT^=";-/+()$

— बीएलटी
स्रोत

1

यदि आप अंतर्निहित डेटासेट का उपयोग करने की अनुमति देते हैं, तो आप 14 तक पहुंच सकते हैं। 1: F^F2 "n"%in%"n"+"n"%in%"n":; 3-9: अंक, 10:, 1e111:, 22/212:, T--T--T--T...13:, 0xD14:sum(mtcars$vs)

— user2390246

%अंतर्निहित डेटासेट का उपयोग करने की सोच और उपयोग। मैं नहीं देख सकता कि यह ठीक क्यों नहीं होगा।

— बीएलटी

मुझे आश्चर्य है कि क्या फिर से डेटा में निर्मित एक का उपयोग करना संभव होगा: यदि नामित पंक्तियों और स्तंभों के साथ एक डेटासेट था, तो आपके पास लाइनों के साथ एक कमांड हो सकती है dataset['A','B'], बशर्ते पहले से उपयोग किए गए पत्रों को ओवरलैप करने से बचा जाए (और होता है) एक उपयोगी मूल्य शामिल करने के लिए!)। दुर्भाग्य से, जहां तक मैं एक त्वरित नज़र से बता सकता हूं, नामित पंक्तियों वाले सभी डेटासेट में i अक्षर होता है, इसलिए यह उपयोग करने के साथ संगत नहीं है %in%।

— user2390246

हममम। 2 के लिए, आप WheatWizard के पायथन जवाब से एक चाल का उपयोग कर सकते हैं q=""=="";q+q:। यह पत्र के उपयोग को मुक्त करेगा iऔर n। अब इसे देखने के लिए समय नहीं है, लेकिन मुझे यकीन है कि वहाँ एक अतिरिक्त एक कहीं है ...

— user2390246

मुझे लगता है कि आप सही हैं। मुख्य समस्या एक डेटासेट मिल रही है जो i, n, s, u, m, t, c, a, r, e, x, या v का उपयोग नहीं करता है। कुछ अक्षरों को वापस पाने में मदद करनी चाहिए।

— बीएलटी

16

MATL , स्कोर 21 22 23 संख्या (273 बाइट्स)

22 से 23 की संख्या तक विस्तार के लिए जे डो का धन्यवाद !

0~
'bd'd
{P}gk
HH^
5
6
7
8
9
3 3.333333333333333*
11
IEE
[B]Yq
llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx
KUKUa-
4W
FFFFFFFFFFFFFFFFFn
TTTTTTTTTTTTTTTTTTs
rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz
OOOOOOOOOOOOOOOOOOOOvZyX>
JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/
22
`@QQQQQQQQQQQQQQQQQQQQQQ@@<

इसे ऑनलाइन आज़माएं! स्टैक को खाली करने केलिए लिंक में प्रत्येक स्निपेट या तोD(डिस्प्ले) या]D(क्लोज लूप स्पष्ट रूप से और डिस्प्ले)समाप्त होता हैऔर इस तरह अगले स्निपेट से अलग हो जाता है।

व्याख्या

0~

धक्का देना 0। नकारना। देता है true, जो के रूप में प्रदर्शित किया जाता है 1।

'bd'd

धक्का मारना 'bd'। पात्रों के कोड बिंदुओं के बीच लगातार अंतर।

{P}gk

पुश सेल सरणी जिसमें संख्या होती है pi। संख्यात्मक सरणी (एक एकल संख्या के लिए) में कनवर्ट करें। नीचे घूमो।

HH^

2दो बार धक्का । शक्ति।

न्यूमेरिक शाब्दिक।

3 3.333333333333333*

धक्का देना 3। धक्का देना 3.333333333333333। गुणा करें। फ्लोटिंग पॉइंट सटीकता के कारण यह देता है 10।

न्यूमेरिक शाब्दिक।

IEE

धक्का देना 3। 2दो बार से गुणा करें ।

[B]Yq

धक्का [6](जो जैसा है 6)। गणना n -th Prime

llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx

114 बार पुश करें । ढेर में तत्वों की संख्या। बाकी का ढेर साफ करें।

KUKUa-

धक्का देना 4। स्क्वायर। ऐसा ही करने। कोई भी: देता है 1। घटाएं।

4W

धक्का देना 4। 2उस पर उठाया।

FFFFFFFFFFFFFFFFFn

पुश सरणी [false false ... false](17 बार)। सरणी में तत्वों की संख्या।

TTTTTTTTTTTTTTTTTTs

पुश सरणी [true true ... true](18 बार)। सरणी का योग।

rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz

अंतराल (0,1) से लिया गया 19 यादृच्छिक संख्याओं को पुश करें। क्षैतिज रूप से 18 बार सम्‍मिलित करें। सरणी में नॉनज़रो तत्वों की संख्या।

OOOOOOOOOOOOOOOOOOOOvZyX>

020 बार पुश करें । समवर्ती स्टैक सामग्री खड़ी (एक स्तंभ वेक्टर देता है)। आकार: सरणी देता है [20 1]। सरणी की अधिकतम।

JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/

1j21 बार पुश (काल्पनिक इकाई)। 20 बार जोड़ें। द्वारा विभाजित करें 1j।

सांख्यिक शाब्दिक

`@QQQQQQQQQQQQQQQQQQQQQQ@@<

करो ... जबकि लूप ( `) अंतर्निहित अंत के साथ। पहले पुनरावृत्ति में यह पुनरावृत्ति सूचकांक ( @) को बढ़ाता है और इसे बढ़ाता है ( Q) 22 बार, जो पैदावार देता है 23। लूप की स्थिति ( @@<) झूठी है, इसलिए लूप बाहर निकल गया है।

आगे सुधार के लिए कुछ विचार

(स्पेस) स्निपेट 10 में प्रतिस्थापित किया जा सकता है |
X>स्निपेट में 20 को प्रतिस्थापित किया जा सकता है p, इस प्रकार उपसर्ग को मुक्त किया जा सकता है X।
वर्तमान में अप्रयुक्त और संभावित रूप से उपयोगी: :,A

— लुइस मेंडो
स्रोत

क्या आप बाइट काउंट सहित बुरा मानेंगे?

— ओकेक्स

@ ऑक्स अब शामिल

— लुइस

15

विंडोज पर विम 8, स्कोर 13, 104 बाइट्स

1
2
3
4
5
6
7
^R=&ts^@
9
8^O^A^O^A
0^[^X^X^X^X^X^X^X^X^X^X^X0x
:h<CR>wwwwwwwwwwwy$:q<CR>p
grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llD

^{keystroke}का प्रतिनिधित्व करता है <C-{keystroke}>तो, ^Xयह है <C-x>, सिवाय इसके लिए ^@जो है <C-j>। मैं अब भी इस सूची में और संख्याएँ जोड़ने का प्रयास कर रहा हूँ और <CR>एक लाइनफीड का प्रतिनिधित्व करता हूँ।

नोट: इन कमांड को चलाने के लिए, vim का उपयोग करना शुरू करें -u NONE -U NONE। यह सुनिश्चित करना है कि आपके कॉन्फ़िगरेशन कोड के साथ हस्तक्षेप नहीं करेंगे।

स्निपेट 1 आवेषण मोड में 10 से शुरू होता है। जबकि स्निपेट्स 12 और 13 सामान्य मोड में शुरू होते हैं।

स्पष्टीकरण

स्निपेट 8 है :^R=&ts^@। इसके लिए आने के लिए मुझे @ L3viathan को धन्यवाद देना है और लाइनफीड के लिए ^@रिप्लेसमेंट के रूप में सुझाव देने के लिए @ nmjcman101 और @ eningrjanJohansen को छोटा करने के &tabstopलिए &ts। &tsफिर टैब के आकार का मूल्यांकन करता है, जो डिफ़ॉल्ट रूप से 8 पर है, और यह मान संपादक में डाला जाता है।

स्निपेट 10 है 8^O^A^O^A। हम एक 8 डालते हैं, और फिर 10 प्राप्त करने के लिए इसे दो बार बढ़ाते हैं।

स्निपेट 11 है 0^[^X^X^X^X^X^X^X^X^X^X^X0x। हम एक 0 लिखते हैं और इसे 11 बार घटाकर -11 प्राप्त करते हैं। फिर हम 11 प्राप्त करने के लिए ऋण को हटा देते हैं।

स्निपेट 12 है :h<CR>wwwwwwwwwwwy$:q<CR>p। यह Vim 8 के सहायता मेनू को खोलता है, जिसमें निम्न जानकारी है:

*help.txt*  For Vim version 8.0.  Last change: 2016 Sep 12

और s का क्रम w12 पर जाता है, जिस बिंदु y$पर संख्या की प्रतिलिपि बनती है। फिर इसे संपादक का उपयोग करके चिपकाया जाता है p।

स्निपेट 13 grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llDइसके साथ आने के लिए @DJMcMayhem का धन्यवाद है। यह केवल विंडोज पर काम करता है। स्निपेट के साथ शुरू होने वाले कमांड के लिए सहायता मेनू खोजता हैg । तब यह jइस रेखा पर पहुंचने के लिए नीचे की ओर बढ़ता है :

|g?|        g?      2  Rot13 encoding operator

जिसके बाद यह इसे कॉपी करता है और इसे बफर में पेस्ट करता है। उसके बाद, सब कुछ लेकिन 13 बफर से हटा दिया जाता है।

— गायों का कुनबा
स्रोत

स्निपेट की अनुमति है।

— लीक नून

क्या ^R=&tabstop+&tabstop+&tabstop<CR>Pआप 12 देंगे, या <CR>पहले से ही उपयोग किया जाता है ^M?

— L3viathan

1

हाँ, मेरा मतलब था <CR>जब मैंने कहा था ^M, लेकिन धन्यवाद, मैं ^Mअब स्निपेट 8 से हटाने पर गौर करूंगा :)

— गायों को

1

@WheatWizard नियंत्रण कुंजी कीस्ट्रोके के रूप में और न ही बाइट के रूप में गिना नहीं जाता है, लेकिन इसका उपयोग अन्य कुंजी के साथ संयोजन में किया जाता है और इन्हें बाइट्स के रूप में गिना जाएगा। उदाहरण के लिए, Ctrl + A बाइट देता है 0x01जबकि Ctrl + X देता है 0x18। और स्पष्ट रूप से, ये दोनों अलग-अलग बाइट्स हैं। क्या इसका कोई मतलब है?

— गाय

1

@ L3viathan जब विम के साथ शुरू होता है -u NONE -U NONE, &tabstopतो 8. का मूल्यांकन करता है। इसलिए मैंने इसे कुछ बदलावों के साथ 8 स्निपेट के साथ स्वैप किया, धन्यवाद :)

— गायों ने

13

गणितज्ञ, स्कोर १३

x~D~x
⌊E⌋
3
⌈Pi⌉
5
6
LucasL@4
8
9
0!+0!+0!+0!+0!+0!+0!+0!+0!+0!
77/7
Tr[{11,1}]
-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I

— J42161217
स्रोत

आपको शायद निरर्थक अंतरिक्ष वर्णों को हटा देना चाहिए, ऐसा लगता है कि आपने उस चरित्र का पुन: उपयोग किया है अन्यथा नहीं।

— अर्जन जोहान्सन

1

वह कोई समस्या नहीं है। मैं उन्हें हटा दूंगा।

— J42161217

2

"सभी पात्रों को आपके द्वारा ⌊⌋⌈⌉

— चुनी

हम में , में , में , और में ⌊⌋⌈⌉बदल कर बच सकते हैं । संभवत: एक समारोह के साथ कम से कम एक कदम आगे बढ़ना संभव है⌊E⌋Floor@GoldenRatio⌈Pi⌉4LucasL@4777/722/2//

— मिशा लावरोव

12

05AB1E , स्कोर 18, 67 बाइट्स

X     Variable is initialized to 1
Y     Variable is initialized to 2
2>     2 + 1
4
5
6
7
8
9
T     Constant 10
3b     3 in binary
•C     Ascii code of 'C'
11Ì     11 in hex
A'ok     Index of 'o' in the alphabet
žz¨¤x+     Middle character of '256' times 2, plus itself
¾<<<<n     Variable initialized to 0, 4 times -1, squared
‘c‘‘c‘QDJH     'c' equals itself (true = 1), duplicated, converted from hex to dec
тD÷·±D*·     Constant 100, divided by itself, * 2, bitwise not, times itself, * 2
"d"aÐÐÐÐÐÐÐÐÐ)O     "d" is_alpha (true = 1), triplicated 9 times, total sum

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

— kalsowerus
स्रोत

13

आपका उत्तर है A'ok:)

— Okx

यहाँ तीन और हैं: „((Ç;¬= 20.0(दो-बाइट चार "("; क्रमिक मूल्यों के लिए; दोनों को हल करें; पूंछ लें); ₁.²₁P₃/ï= 21(लॉग -2 ऑफ़ 256; गुणा 256 से; 95 से विभाजित; दशमलव के साथ हटाया गया); ₂Ågttγć= 22(26 वाँ लुकास शब्द; दो बार वर्ग-मूल; समान तत्वों के चक में विभाजित; सिर निकाले गए; अंतिम दो परीक्षण और त्रुटि थे;)

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

9

पिंगपोंग , स्कोर 127

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

1: 1
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: A
11: B
12: C
13: D
14: E
15: F
16: G
17: H
18: I
19: J
20: K
21: L
22: M
23: N
24: O
25: P
26: Q
27: R
28: S
29: T
30: U
31: V
32: W
33: X
34: Y
35: Z
36: a
37: b
38: c
39: d
40: e
41: f
42: g
43: h
44: i
45: j
46: k
47: l
48: m
49: n
50: o
51: p
52: q
53: r
54: s
55: t
56: u
57: v
58: w
59: x
60: y
61: z
62: ©
63: ®
64: À
65: Á
66: Â
67: Ã
68: Ä
69: Å
70: Æ
71: Ç
72: È
73: É
74: Ê
75: Ë
76: Ì
77: Í
78: Î
79: Ï
80: Ð
81: Ñ
82: Ò
83: Ó
84: Ô
85: Õ
86: Ö
87: ×
88: Ø
89: Ù
90: Ú
91: Û
92: Ü
93: Ý
94: Þ
95: ß
96: à
97: á
98: â
99: ã
100: ä
101: å
102: æ
103: ç
104: è
105: é
106: ê
107: ë
108: ì
109: í
110: î
111: ï
112: ð
113: ñ
114: ò
115: ó
116: ô
117: õ
118: ö
119: ÷
120: ø
121: ù
122: ú
123: û
124: ü
125: ý
126: þ
127: ÿ

— WaffleCohn
स्रोत

5

ठीक है, यह भी उचित नहीं है ...: पी

— एमडी एक्सएफ 2

वाह, यह इस तरह की भाषा है इस चुनौती के लिए किया गया है: डी

— वी। कोर्टोइस

एक और अजीब भाषा के बारे में टीआईएल :)

— लूट

8

ऑक्टेव, स्कोर 14, 74 बाइट्स

मुझे यकीन है कि अब मैं सीमा के करीब हूं।

1:  ~0                        % Not 0 == 1
2:  "H"/"$"                   % "H" = 72, "$" = 36. H/$ = 2
3:  3                         % Literal
4:  4                         % Literal
5:  5                         % Literal
6:  6                         % Literal
7:  7                         % Literal
8:  8                         % Literal
9:  9                         % Literal
10: ceil(pi*pi)               % pi*pi = 9.87. ceil(9.87) = 10
11: 11                        % Literal
12: 2+2+2+2+2+2               % Well, not much to say
13: ['','RT'-'!']             % 'RT' = [82,84]. Subtract '!' (33) to get ['',49,51]=13
14: nnz...                    % Number of non-zero elements in the string...
    nnnnnnnnnnnnnn            % on this line. (This is an awesome trick by the way!)

दूर करने के लिए किया था strchrके बाद से मैं पहले से ही है cनंबर 10 मैं अब भी है में j, ^, =, !, अंतरिक्ष और क्षैतिज टैब (ASCII-9) में एक और निचोड़ करने के लिए छोड़ दिया, तो यह संभव हो सकता है।

क्षैतिज टैब का उपयोग एक स्थान के रूप में किया जा सकता है, इसलिए इसके साथ प्रयोग की जाने वाली चाल strchrऔर nnzएक बार उपयोग की जा सकती है। केवल निचले मामले के अक्षर बचे हैं abdfgjkmoquvwxy। ऐसे कई कार्य नहीं हैं जो इनसे किए जा सकते हैं। modकाम कर सकता है, लेकिन यह स्ट्रिंग इनपुट नहीं ले सकता।

शेष पात्रों का उपयोग करना आसान है 1, लेकिन मुझे नहीं पता कि मैं कुछ और कैसे प्राप्त कर सकता हूं।

सभी का परीक्षण करें ।

संभवत: उपयोगी: fun aरूप में ही है fun('a'), fun a bके रूप में ही है fun('a','b')और इतने पर। यह कई स्थानों पर इस्तेमाल किया जा सकता है:

gt t g    % Equivalent to 't'>'g'. Returns 1. Uses space (available)
or o r    % Equivalent to 'o' | 'r'. Returns 1.

इसका उपयोग करना 0उपलब्ध कराएगा, लेकिन मैं यह नहीं देख सकता कि इसे अभी तक कैसे उपयोगी बनाया जाए।

e (2.71828...)और jअभी भी अप्रयुक्त हैं। हालांकि ceilउपयोग करने के लिए निकालना चाहिए e।

विकल्प (प्रेरणा):

1:  ~0             % Not 0 = 1
2:  2              % Numeral
3:  3              % Numeral
4:  fix(i^i^i^i)   % Numeral
5:  5              % Numeral
6:  6              % Numeral
7:  7              % Numeral
8:  8              % Numeral
9:  9              % Numeral 
10: 1+1+1+1+1+1+1+1+1+1   % Well, not much to explain
11: ['','RR'-'!']  % RR are [82,82] in ASCII, subtract 33 (!) to get
                   % [49,49], and concatenate with the empty string to convert [49,49] to 11 
12: nnz nnnnnnnnnnnn   % Number of non-zero elements in the string containing 12 n
13: "4"/4          % "4" = 52. Divide it by 4 to get 13.

— स्टीवी ग्रिफिन
स्रोत

7

जावास्क्रिप्ट (ईएस 7), 16 पूर्णांक, 137 130 128 बाइट्स

मैंने @ETHproductions का उत्तर लिया और थोड़ी देर के लिए इसके साथ भाग गया; यह इतना बदल गया है कि मैं इसे अलग से पोस्ट कर रहा हूं। विचारों का स्वागत है। :)

""**""
-~-~{}
3
C=CSS==CSS;C<<C<<C
5
6
7
8
9
++[[]][+[]]+[+[]]
11
4444444444444444444%44
222>>2>>2
`..............i`.indexOf`i`
0XF
atob('MTY')

शेष:
$_@#!^&|/?:, ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

या, यदि स्निपेट को 1 से बदल दिया जाए !!/!//!!/!/:
$_@#^&|*?:", ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

जावास्क्रिप्ट (ईएस 7), 16 पूर्णांक, 127 बाइट्स

एक बाइट छोटी। : पी

""**""
-~-~{}
3
4
5
6
7
C=CSS==CSS;C<<C<<C<<C
9
++[[]][+[]]+[+[]]
11
`............i`.indexOf`i`
222>>2>>2
0XE
atob('MTU')
88888888888888888%88

शेष: $_@#!/^&|?:,ABDFGHIJKLNPQRVWYZcghjklmpqrsuvwyz

— darrylyeo
स्रोत

1

2 के साथ 7 बाइट्स बचाएं -~{}-~{}: पी कुल मिलाकर, हालांकि, ये बहुत अच्छे हैं। सुनिश्चित करने के लिए खदान से छोटा रास्ता ...

— ETHproductions

1

और आप अभी भी !&/^|बहुत प्रभावशाली के साथ काम करने के लिए छोड़ दिया है। यदि आवश्यकता हो, तो आप !!/!//!!/!/1 के लिए व्यापार के !/लिए उपयोग कर सकते हैं "*।

— ETHproductions

@ETHproductions बहुत बढ़िया!

— darrylyeo

1

2 बस है-~-~{}

— GOTO 0

10 के रूप में लिखा जा सकता है +!![]+[+[]], जब तक कि कोई बेहतर उपयोग न हो!

— GOTO 0

7

Dyalog APL, स्कोर 15, 89 बाइट्स

≡''
≢###
3
4
⍴⍬⍬⍬⍬⍬
6
⌈○2
8
9
1E1
⎕D⍳⊂⎕D











l:l
7--7-×7
(~0 0 0 0 0 0 0 0 0 0 0 0 0 0)⊥~0
5+5+5

_{इससे पहले की नई खबरें l:l12 का हिस्सा हैं।}

_{14 में रिक्तियाँ टैब का प्रतिनिधित्व करती हैं।}

— Uriel
स्रोत

1

मुझे लगता है कि आप 12 और 14. दोनों में जगह का उपयोग कर सकते हैं। क्या एपीएल इसके बजाय टैब का उपयोग कर सकते हैं?

— अर्जन जोहान्सन

@ SpacerrrJohansen कोई अतिरिक्त जगह नहीं है, लेकिन मैंने गलत तरीके से स्निपेट्स को अलग करने वाली लाइनें शामिल कीं

— उरेल

मेरा मतलब है, अंतरिक्ष चरित्र दो प्रविष्टियों में इस्तेमाल किया जा रहा है, 12 और 14.

— अर्जन जोहानसन

@ TherrrJohansen ओह, हां, आखिरी वाला टैब लेकर जाएगा।

— ऊरीएल

@ कुछ विचारों का उपयोग करें: 0 0 0-> 0,0,0; ]fromhex f

— ngn

7

> <> , स्कोर 20, 93 90 74 65 बाइट्स

(टील पेलिकन द्वारा 3 बाइट्स, जो किंग द्वारा बचाए गए बहुत से बाइट्स!)

iii((
2
3
ll{lll{[
5
6
7
8
!   00=0g
a
b
c
d
e
f
44*
'RA'%
999-9--
"&F#",,
1::+:++:+:+

मछली खेल के मैदान में उन्हें कोशिश करो! आप n;प्रत्येक के अंत में जोड़कर स्निपेट उनके परिणामों को प्रिंट कर सकते हैं । ध्यान दें कि 9 वें स्निपेट में एक टैब होता है, जिसे स्टैक एक्सचेंज द्वारा खाया जाता है।

स्पष्टीकरण:

में iii((, प्रत्येक iइनपुट प्राप्त करने की कोशिश करता है, लेकिन चूंकि कोई भी नहीं है, इसलिए वे ईओएफ = के -1बजाय धक्का देते हैं। फिर (निर्देश की तुलना में कम है, और चूंकि -1यह कम से कम नहीं है -1, यह एक फाल्सी को धक्का देता है 0; लेकिन दूसरा (पूछता है कि -1क्या इससे कम है 0, जो यह है, इसलिए यह एक सच्चाई को आगे बढ़ाता है 1।
2और 3स्पष्ट हैं।
के लिए ll{lll{[, पहले lस्टैक की लंबाई को धक्का देता है, जो है 0, फिर दूसरा नई लंबाई को धक्का देता है, जिससे स्टैक को लाया जाता है 0, 1। {घूमता है ढेर, छोड़ दिया अदला-बदली 1और 0। तीन और lएस ढेर लाते हैं 1, 0, 2, 3, 4। फिर सामने की ओर {घूमता है 1, और स्टैक पर [पहली 1चीज को छोड़ देता है, जो कि है 4।
5, 6, 7और 8भी स्पष्ट कर रहे हैं।
में !\t00=0g(जहां \tएक टैब का प्रतिनिधित्व करता है), टैब को !छोड़ देता है, फिर 00=दो शून्य को धकेलता है और जांचता है कि क्या वे समान हैं - वे हैं, इसलिए हमें एक सच्चाई मिलती है 1। दूसरे को धक्का देने के बाद 0, कोड की gस्थिति में चरित्र मिलता है 1,0, जो कि चरित्र कोड के साथ टैब है 9।
aके माध्यम से fप्रत्येक धक्का 10करने के लिए 15क्रमश: (संभवतः हेक्साडेसिमल अच्छा बनाने के लिए)।
44*दो 4एस धकेलता है और उन्हें एक साथ गुणा करता है, के लिए 16।
'RA'धक्का के चरित्र कोड Rऔर Aढेर करने के लिए (82 और 65 क्रमशः), तो %गणना करता है 82 mod 65 = 17।
999-9--का मूल्यांकन करता है 9 - ((9 - 9) - 9) = 18।
"&F#"के चरित्र कोड धक्का &, Fऔर #है, जो कर रहे हैं 38, 70और 35क्रमशः। तब ,विभाजन है, इसलिए हम प्राप्त करते हैं 38 / (70 / 35) = 19।
अंत में, 1::एक धक्का देता है 1और इसे दो बार डुप्लिकेट करता है, +दो को एक साथ जोड़ता है 2; :+डुप्लिकेट करता है 2और इसे पाने के लिए खुद को जोड़ता है 4; +बचे हुए 1को जोड़ता है पाने के लिए 5; फिर :+:+दो बार डुप्लिकेट और जोड़ता है, जिसके परिणामस्वरूप 20।

यह> <> के साथ अधिकतम संभव स्कोर है। किसी भी टुकड़ा कहीं एक निर्देश है कि एक गैर खाली ढेर में एक खाली ढेर में बदल जाता है को शामिल करना चाहिए, और केवल 18> <> निर्देश है कि ऐसा कर सकते हैं (अर्थात् देखते हैं i, lऔर अंक 0–9और a–f), के साथ साथ स्ट्रिंग मोड। (प्रत्येक अन्य निर्देश या तो खाली स्टैक के लिए कुछ नहीं करता है ><v^/\|_#x!{}r, या कुछ और त्रुटियों को पॉप करने की कोशिश करता है ?.+-*,%=():~$@[]on&gp।) स्ट्रिंग मोड में प्रवेश "या तो उपयोग करता है या ', इसलिए अधिकांश 18 + 2 = 20स्निपेट संभव हैं।

आप unprintables के साथ अधिक सहज से मैं कर रहा हूँ हैं, तो यह 53 बाइट्स में संभव है, जो राजा के लिए धन्यवाद: 00=, iii((i-, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 2222***, !Xll$g, 11+::+:+:++, 'Y', "Z"है, जहां X, Yऔर Zकोड के साथ पात्रों ने ले ली है 17, 19और 20क्रमशः।

— पेड़ नहीं
स्रोत

1

यह बहुत अच्छा है, मैं इस समस्या को देख रहा हूं और इस कुएं के पास कहीं भी करने में सक्षम नहीं था, लेकिन मैंने आपका अध्ययन किया और इसे थोड़ा सा गोल्फ करने में सक्षम था; 16 को बदला जा सकता है; iii ((: i $ -: i $ -: i $ - i- और 1 को परिवर्तित करने के लिए; 00 = और आप एक युगल बाइट्स द्वारा दोनों पंक्तियों को कम करते हैं।

— चैले पेलिकन

@Tealpelican, अच्छा काम, धन्यवाद!

— एक पेड़ नहीं

1

-23 बाइट्स बदलकर निम्न 2> iii((i-16> 2222***17> lll{lllll{{[{n(शायद स्केच करें, लेकिन यदि आप एक संख्या के रूप में आउटपुट करना चाहते हैं, तो कम से कम एक कम है l) 18>11+::+:+:++

— जो राजा

@ जोकिंग, वाह, यह एक बड़ा गोल्फ है! (मैं 17 के कम स्केच्य संस्करण के साथ गया था - यह नियमों को ध्यान में रखते हुए अधिक लग रहा था।)

— एक पेड़

1

कैसे के बारे में 17 => ! ll$gजहां अंतरिक्ष मूल्य 17 (डिवाइस नियंत्रण 1) के साथ नियंत्रण चरित्र द्वारा प्रतिस्थापित किया जाता है?

— जो किंग

7

मैथॉल्फ , 48 51 53 पूर्णांक, 324 बाइट्स

î
ª∞~
c±b±+
φⁿ_¥-
5
6
7
○¢i♀/
d²
♂
A
B
C
D
E
☻
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
♥
U
V
W
X
Y
Z
♫¼¼¼¼
88888]Σ
41
╔½½½½½½½½½½½
π░3§3
22#22#
τ╥└
♦⌡⌡⌡⌡⌡⌡⌡⌡⌡
!⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠
'0$
ÿ@@@@£9
))))))))))))))))))))))))))))))))))))))))))))))))))
►◄╠•╠
"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h 
♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((

+2 स्कोर (और -2 अलग बाइट्स के लिए इस्तेमाल किया गया 40) @maxb के लिए धन्यवाद ।

प्रत्येक पंक्ति एक अलग कार्यक्रम है।

प्रयुक्त बाइट्स (92 अलग बाइट्स): îª∞~c±b+φⁿ_¥-567○¢i♀/d²♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ♫¼8]Σ41╔½π░3§2#τ╥└♦⌡!⌠'0$ÿ@£9)►◄╠•╠"h ♣(

स्पष्टीकरण और TIO- लिंक:

MathGolf गणितीय गोल्फिंग चुनौतियों में एक नई गोल्फिंग भाषा है। इसमें संख्याओं के लिए एकल-बाइट बिल्डरों का भार है, जिससे यह इसके लिए एक सही चुनौती है।

1) î: लूप की 1-इंडेक्स वैल्यू को पुश करें, जो डिफ़ॉल्ट रूप से 1 है: इसे ऑनलाइन आज़माएं।
2) ª∞~: धक्का [1]; इसे दोगुना करें ([2]); पॉप सूची और स्टैक पर इसकी सामग्री को धक्का दें: इसे ऑनलाइन आज़माएं।
3) c±b±+: पुश -2; तब पॉप और इसके पूर्ण मूल्य को धक्का; धक्का -1; तब पॉप और इसके पूर्ण मूल्य को धक्का; और उन्हें एक साथ जोड़ें यह ऑनलाइन कोशिश करें।
4) φⁿ_¥-: गोल्डन अनुपात (1.618033988749895) पुश करें; इसे घन (4.23606797749979); स्टैक के शीर्ष को डुप्लिकेट करें; मोडुलो 2 (0.23606797749979) लें; उन्हें एक-दूसरे से घटाएँ: इसे ऑनलाइन आज़माएँ।
5,6,7) संख्याएँ स्वयं: इसे ऑनलाइन आज़माएँ।
8) इसे ऑनलाइन आज़माएं। 9) : पुश -3; चुकता: इसे ऑनलाइन आज़माएं।○¢i♀/ : पुश 2048; एक हेक्साडेसिमल स्ट्रिंग (800) में परिवर्तित; पूर्णांक तक डाली; धक्का 100; विभाजित:
d² 10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34, ३५,३६,३,,३ themselves ♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ) संख्याओं के लिए स्वयं पुष्पा का निर्माण करें ( ): इसे ऑनलाइन आज़माएँ।
39) ♫¼¼¼¼: 10000 रु; पूर्णांक-चार से चार बार विभाजित: इसे ऑनलाइन आज़माएं।
40) 88888]Σ: 8 पांच बार धक्का; उन्हें एक सूची में लपेटो; उस सूची का योग: इसे ऑनलाइन आज़माएं।
41) स्वयं संख्या: इसे ऑनलाइन आज़माएं।
42) ╔½½½½½½½½½½½: 86400 धक्का; पूर्णांक-दो ग्यारह बार विभाजित: इसे ऑनलाइन आज़माएं।
43)π░3§3 : पुश पीआई (3.141592653589793); कास्ट करने के लिए डाली; पॉप और इसके तीसरे 0-अनुक्रमित चरित्र को धक्का दें (4); धक्का 3; आउटपुट पूरे स्टैक में एक साथ सम्मिलित रूप से निहित है: इसे ऑनलाइन आज़माएं।
44) 48)22#22#: पुश 2 दो बार; दो (4) की शक्ति ले लो; फिर से करो; आउटपुट पूरे स्टैक में एक साथ सम्मिलित रूप से निहित है: इसे ऑनलाइन आज़माएं।
45) τ╥└: पुश 2 * PI (6.283185307179586); पॉप और 2 के नीचे की शक्ति को धक्का दें जो निकटतम है (4); पॉपिंग के बिना स्टैक + 1 के शीर्ष को धक्का दें (5); आउटपुट पूरे स्टैक में एक साथ सम्मिलित रूप से निहित है: इसे ऑनलाइन आज़माएं।
46) ♦⌡⌡⌡⌡⌡⌡⌡⌡⌡: 64 पुश; 2 से नौ बार कमी: ऑनलाइन प्रयास करें।
47) !⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠: पुश गामा (एन + 1) (डिफ़ॉल्ट रूप से 1); 2 से तेईस बार वेतन वृद्धि: ऑनलाइन प्रयास करें।
'0$: चरित्र '0' के क्रमिक मूल्य को पुश करें : इसे ऑनलाइन आज़माएं।
49) ÿ@@@@£9: पुश स्ट्रिंग "@@@@"; पॉप और इसकी लंबाई को धक्का (4); धक्का 9; आउटपुट पूरे स्टैक में एक साथ सम्मिलित रूप से निहित है:इसे ऑनलाइन आज़माएं।
50) )))))))))))))))))))))))))))))))))))))))))))))))))): 1 पचास गुना वृद्धि: इसे ऑनलाइन आज़माएं।
51) ►◄╠•╠: पुश 1,000,000; पुश 10,000,000; पॉप और पूर्णांक दोनों को एक-दूसरे के साथ विभाजित करें (10); 512 धक्का; पॉप और पूर्णांक दोनों को एक-दूसरे के साथ विभाजित करें: इसे ऑनलाइन आज़माएं।
52) "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h : पुश स्ट्रिंग "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"; इसकी लंबाई को बढ़ाएं (स्ट्रिंग को पॉप किए बिना); पिछले आइटम को छोड़कर स्टैक से सब कुछ हटा दें: इसे ऑनलाइन आज़माएं।
53) ♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((: 128 पुश; 1 से पचहत्तर बार घटाया गया: इसे ऑनलाइन आज़माएं।

बाद में कुछ और जोड़ने की कोशिश करेंगे। मेरे पास अभी भी कुछ उपयोगी चीजें हैं, जिनमें मोडुलो %और गुणा शामिल हैं *।

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

मैं इसके लिए एक समाधान पर काम कर रहा था, लेकिन मैं 1-9 को अनुकूलित करने की कोशिश में फंस गया। एक बार जब आप 10 तक पहुँच जाते हैं तो यह 38 तक पहुँचने के लिए तुच्छ हो जाता है। कुछ चीजें जिन्हें मैं पहली नज़र में देखता हूँ: 88888ΓΣαΣ-> 88888]Σया 88888§§§§Σएक का उपयोग करने की कीमत पर आपको 2 कमांड बचाता है। आप ऐसा कुछ भी कर सकते हैं "xxxxxx"h जहां अंतिम चरित्र एक गैर-ब्रेकिंग स्पेस है जो सब कुछ साफ करता है लेकिन टीओएस और आप संख्या उत्पन्न करने के लिए स्ट्रिंग की लंबाई का उपयोग कर सकते हैं। शायद इसके अलावा कुछ का उपयोग करें x, क्योंकि तब आपको मिल गया है Wxजो आपको 53 देता है जब तक आप 35 अन्य तरीके से प्राप्त कर सकते हैं।

— अधिकतम

इसके अलावा, मैंने अभी एक char/ordऑपरेटर जोड़ा है , जो 'A$-> की तरह काम करता है 67, और लंबे समय तक तार (बेस-256 पूर्णांक की तरह) के लिए भी काम करता है। यह बहुत अच्छी तरह से प्रलेखित नहीं है, लेकिन अगर आप इस उत्तर को बेहतर बनाने में रुचि रखते हैं, तो मैं किसी भी प्रश्न के लिए मैथॉल्फ के लिए चैट रूम को फिर से बना सकता हूं।

— अधिकतम

@ मैक्सब मैंने आपकी टिप्पणी तब देखी जब मैं बिस्तर पर बीमार था, लेकिन मेरे पास अब इस उत्तर को सुधारने के लिए कुछ समय है। के लिए धन्यवाद 88888]Σ। के बारे में पता नहीं था ]। के रूप में "hhhhh"h , कि काम करने के लिए प्रतीत नहीं होता है । : एस

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

1

मुझे नहीं पता कि यह यहाँ से सीधे चिपकाया जा सकता है, लेकिन कोड को एनबीएसपी के साथ समाप्त होना चाहिए, गैर-ब्रेकिंग स्पेस चरित्र। वह कमांड सब कुछ साफ़ करता है लेकिन स्टैक के ऊपर। मुझे पूरा यकीन है कि पीपीसीजी ने टिप्पणियों में यहां चरित्र को एक नियमित स्थान पर परिवर्तित कर दिया है। इसे आजमाएँ

— 12

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

— 12

6

जावा 8, 11 12 13, 39 बाइट्स

जावा में केवल संख्या (0-9) के लिए 10 प्रतीक हैं और सभी विधि कॉल और स्थिरांक के लिए एक अवधि की आवश्यकता होती है, इसलिए मुझे यकीन नहीं है कि मैं 11 से अधिक आउटपुट प्राप्त कर सकता हूं

जब ऑपरेशन लागू होते हैं, तो डिफ़ॉल्ट रूप से पूर्णांकों को डाली जाती है

@ ओलिवियरग्रेयर की मदद से +1

i->-~i
2
3
4
5
6
7
8
9
'P'^'Z'
11
"::::::::::::"::length
0xD

स्पष्टीकरण:

i->-~i

पूर्णांक लैम्ब्डा जो कोई इनपुट नहीं लेता है और रिटर्न करता है। 1. जब कोई पैरामीटर इनपुट नहीं लेता है तो डिफ़ॉल्ट मान का उपयोग उपरोक्त मेटा पोस्ट के अनुसार किया जाता है, जो पूर्णांक के लिए 0 है।

शाब्दिक पूर्णांक

'P'^'Z'

10 लौटाने के लिए दो पात्रों का XOR

शाब्दिक पूर्णांक

":::::::::::"::length

लैम्ब्डा अभिव्यक्ति जो एक 12 वर्ण स्ट्रिंग की लंबाई लौटाता है

0xD

हेक्साडेसिमल 13

यदि आप सत्यापित करना चाहते हैं तो TIO लिंक ।

— PunPun1000
स्रोत

1

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

बाइट गिनती (-6 वर्ण) को छोटा करने के लिए, 2के रूप में लिखा जा सकता है 2और 10के रूप में 'P'^'Z'। इसके अलावा, यह पात्रों X+*और उपयोगों को मुक्त करता है P।

— ओलिवियर ग्रेजायर

हमें जावा में टाइप करने के लिए लैम्बडा पैरामीटर की आवश्यकता है , इसलिए i->i.ONEयह अमान्य है।

— नाथन मेरिल

यह अधिक उत्कट उत्तर आपके साथ असहमत है।

— ओलिवियर ग्रेजायर

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

— ओलिवियर ग्रेजायर

6

गैया , स्कोर 25, 203 बाइट्स

§‼
..⌉+⌉
₵P~~
4
5
6
∂Ql
8
9
¶c
11
'¡ċ⌋u⌋
--⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻
7:,Σ
Ø!))))))))))))))
øøw<øøw<«øøw<«øøw<«øøw<«
⟩‘
₸ḣ₸K$₸ḣ₸/S₸₸/=$
]]]]]]]]]]]]]]]]]]]n
⇑’e
0(((((((((((((((((((((_
22
“B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B
3₈×
ℍḥḥ

मैं इसे एक सही स्कोर मानता हूं, क्योंकि चरित्र सीमाओं को देखते हुए अधिक निलाड का इस्तेमाल नहीं किया जा सकता है।

स्पष्टीकरण

1। §‼

§एक स्पेस कैरेक्टर है, ‼बूलियन के लिए सुसंगत है, इसलिए परिणाम 1 है।

2। ..⌉+⌉

.के लिए एक शॉर्टकट है 0.5, इसलिए यह है ceil(0.5+ceil(0.5))।

3। ₵P~~

₵Pपी है, ~बिटवाइस नेगेटिव है। डबल बिटवाइज़ नेगमेंट बस छंटनी है।

4। 4

5। 5

6। 6

7। ∂Ql

∂Qसप्ताह के दिनों के नाम वाली एक सूची है, lलंबाई है।

8। 8

9। 9

10। ¶c

cलाइनफीड का कोड पॉइंट ¶।

1 1। 11

12। '¡ċ⌋u⌋

'¡  The string "¡"
ċ   Turn it into a list of code points: [161]
⌋   Minimum: 161
u⌋  Floored square root: 12

13। --⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻

-के लिए एक आशुलिपि है -1, ⁻घटाव है। तो यह -1 - -1 - -1...13 बनाने के लिए पर्याप्त समय है।

14। 7:,Σ

पुश 7, डुप्लिकेट :, ,एक सूची में दो 7s जोड़े और योग Σ।

15। Ø!))))))))))))))

Øएक खाली स्ट्रिंग है, इसलिए Ø!1. वृद्धि )1 14 बार है।

16। øøw<øøw<«øøw<«øøw<«øøw<«

øø    Push two empty lists
w     Wrap one of them
<     [] < [[]]? (it is, so push 1)
øøw<  Do the same thing again to push another 1
«     Bitshift 1 left by 1
      Do that same thing again 3 more times to get 16

17। ⟩‘

एक स्ट्रिंग को बंद करने ‘से यह एक बेस -509 नंबर शाब्दिक बन जाता है। ⟩Gaia के कोड पेज में बाइट मान 17 है।

18। ₸ḣ₸K$₸ḣ₸/S₸₸/=$

₸     10
ḣ     doubled
₸     10
K     20 choose 10 (184756)
$     Digit list
₸ḣ₸/  20/10 (2)
S     Split the digit list at index 2 ([[1 8][4 7 5 6]])
₸₸/   10/10 (1)
=     Get the first element of that split ([1 8])
$     Join together and print 18

19। ]]]]]]]]]]]]]]]]]]]n

प्रत्येक ]सूची में ढेर को लपेटता है। ऐसा 19 बार करें और nसूची की गहराई प्राप्त करें ।

20। ⇑’e

एक स्ट्रिंग को बंद करने ’से यह कोडपेज कोड पॉइंट्स की एक सूची बन जाती है। eस्टैक पर सूची डंप करता है। ⇑कोडपेज में 20 का कोड बिंदु है।

21। 0(((((((((((((((((((((_

कमी (0 21 बार, फिर नकारात्मक _।

22। 22

23। “B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B

स्ट्रिंग “B”को आधार -24 से परिवर्तित करें , जहां 0-23 से अंक हैं ↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B। परिणाम है 23।

24। 3₈×

3 × 8।

25। ℍḥḥ

100 को ℍआधा कर दिया ḥ, और फिर से आधा कर दिया।

— बिजनेस कैट
स्रोत

5

सी, स्कोर 13

ये पूर्णांक स्थिरांक का सिर्फ एक गुच्छा हैं।

0==0
__LINE__
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
'o'/'.' 
2*2*2*2-2-2
strlen("strlenstrlens")

0==01 का मूल्यांकन करता है
मान लेता है कि कोड 2 लाइन पर है __LINE__= = 2
अखंड
अखंड
अखंड
अखंड
अखंड
अखंड
अखंड
1+1+1...= 1*10= १०
'o'111 है, '.'अप्राप्य ASCII 0x10 का प्रतिनिधित्व करता है। 111/10 = 11
(2<<2)= 8, 8*2= 16, 16-2-2= 12
स्ट्रिंग की लंबाई "strlenstrlens"= 13

— एमडी एक्सएफ
स्रोत

5

ओम , स्कोर 21 22, 160 कुल बाइट्स

╓S@Ri
ΓΓ-Γ-Γ-
αê⌠
¡¡¡¡¼
5
▀lll▀l
ÑÑÑÑÑÑÑÿWÿk
ü`½½
9
..≥°
$$J
3dd
7ƒ
2≡≡≡Σ
║F
4º
0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~
6DD++
8π
τ╛hτ*
"≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A
1111 11v11%L1111 11v11%L

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

स्पष्टीकरण

1। ╓S@Ri

वर्तमान दिनांक / समय ( ╓S) के सेकंड पुश करें । 1 से सेकंड तक समावेशी श्रेणी प्राप्त करें ( @), इसे उल्टा करें ( R), अंतिम तत्व प्राप्त करें ( i), जो हमेशा 1 होता है।

2। ΓΓ-Γ-Γ-

Γ -1 है, इसलिए यह (-1) - (-1) - (-1) - (-1) है, जो 2 है।

3। αê⌠

αêईलर का नंबर (2.71828 ...) है, ⌠सीलिंग है। 3 का परिणाम है।

4। ¡¡¡¡¼

¡काउंटर बढ़ाता है, काउंटर को ¼धक्का देता है।

5। 5

बस एक शाब्दिक है।

6। ▀lll▀l

▀lll▀एक संकुचित स्ट्रिंग शाब्दिक है जो इसके बराबर है "of >ic"। lलंबाई लेता है, इसलिए परिणाम 6 है।

7। ÑÑÑÑÑÑÑÿWÿk

पहले हम 7 न्यूलाइन वर्ण ( Ñ) और फिर एक रिक्त स्ट्रिंग ( ÿ) धक्का देते हैं । स्टैक को एक सरणी ( W) में लपेटा जाता है , और फिर उस सरणी में खाली स्ट्रिंग का सूचकांक पाया जाता है।

8। ü`½½

üएक अंतरिक्ष पात्र है। `अपने ASCII मूल्य (32) को धकेलता है, तो यह दो बार आधा हो जाता है ( ½½)।

9। 9

बस एक शाब्दिक है।

10। ..≥°

..एक शाब्दिक .चरित्र है। यह बढ़ जाता है ( ≥), जो एक संख्या के रूप में स्ट्रिंग को पार्स करता है, 0 से डिफ़ॉल्ट होता है क्योंकि यह एक वैध संख्या नहीं है, और इसे 1 में बढ़ाता है। फिर हम 10 ¹ ( °) की गणना करते हैं ।

1 1। $$J

$ रजिस्टर के वर्तमान मूल्य को धक्का देता है, शुरू में 1. इसलिए, 1 को दो बार धक्का दें, एक साथ ढेर में शामिल हों और प्रिंट करें।

12। 3dd

3 पुश करें और इसे दो बार दोहराएं।

13। 7ƒ

7 वें फाइबोनैचि संख्या को धक्का देता है।

14। 2≡≡≡Σ

पुश 2, इसे तीन बार तीन गुना, स्टैक पर 7 2 को छोड़कर। फिर स्टैक का योग ( Σ) लें।

15। ║F

║बेस -२२० नंबर शाब्दिक के लिए परिसीमन है। चूंकि यह एक पंक्ति के अंत में है, इसलिए इसे समाप्त करने की आवश्यकता नहीं है।

16। 4º

संगणक २ ^४ ।

17। 0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~

òबिटवेट निगेट है, ~अंकगणित निगेट है। इन ऑपरेटरों को मिलाकर, हम 0 17 गुना बढ़ा सकते हैं।

18। 6DD++

पुश 6, इसे दो बार डुप्लिकेट करें, और 6 + 6 + 6 की गणना करें।

19। 8π

8 वां अभाज्य अंक पुश करें।

20। τ╛hτ*

पुश 10 ( τ), hइसके मुख्य कारकों का पहला तत्व ( ) प्राप्त करें ╛, जो कि 10 से गुणा करें।

21। "≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A

पिछले स्निपेट के समान, स्ट्रिंग "≤"0. के रूप में पार्स हो जाती है। हम इसे 21 गुना घटाते हैं, फिर निरपेक्ष मान लेते हैं।

22। 1111 11v11%L1111 11v11%L

यहां हम 1111 div 11 mod 11 की गणना करते हैं, जो कि 2 है, फिर 2 प्रिंट करें। फिर इसे फिर से करें।

— बिजनेस कैट
स्रोत

5

पॉवरशेल, स्कोर 12, 91 बाइट्स। 14, 176 बाइट्स

[byte]!![byte]                    # type gets cast to bool false, inverted, to int = 1
-   -$?-shl$?                   # -bool true is -1, shift left, negative. (Tab not space)
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
22/2                                           # use the 2
'uuuuuuuuuuuu'.LENGTH                          # string length
0xd
@{z=@{};Y=@{};YY=@{};w=@{};v=@{};U=@{};zz=@{};S=@{};r=@{};q=@{};p=@{};J=@{};K=@{};m=@{}}|% COU*             # count items in hashtable (space)

संपादित करें:

13 के लिए हेक्स शाब्दिक 0xd के सुझाव के लिए अर्जन जोहान्सन को धन्यवाद और एक विकल्प के रूप में 1 + 1 + 1 + 1 को मुक्त करने के लिए 5 का पुनर्व्यवस्थापन।
स्ट्रिंग की लंबाई में परिवर्तित लंबाई लंबाई, [int] से [बाइट] और हैशटेबल को मानों के रूप में उपयोग करने के लिए, (),""कुछ की तरह पैंडरिंग 15 को मुक्त करने "ZZZZZZZZZZZZZZZA".InDeXof("A")पर डॉट या 'ई' का पुन: उपयोग नहीं किया जा सकता है।

PowerShell $ के बिना चर नहीं कर सकता, बुनियादी प्रतीकों के साथ घातांक, बिट शिफ्टिंग, पाई, छत (), आदि नहीं कर सकता है, और ज्यादातर प्रकार के लिए / बूल से और / से संख्या-के-स्ट्रिंग के रूप में, ऐसा करता है कम-वाक्य रचना संख्या पीढ़ी के लिए अपेक्षाकृत कम गुंजाइश है।

— TessellatingHeckler
स्रोत

आपने 0अभी तक उपयोग नहीं किया है, इसलिए 13 हो सकते हैं 0xd। आप 5इसके सामान्य स्थान पर रख सकते हैं , एस +के संयोजन के लिए मुक्त कर सकते हैं 1। यह आपको 14. से मिलना चाहिए। यदि आपको पात्रों को सहेजने की आवश्यकता है, तो हैशटेबल कुंजियाँ एक से अधिक अक्षर हो सकती हैं। और यदि आपके पास योग करने के लिए 1s प्राप्त करने का कुछ अतिरिक्त तरीका है, तो आप कर सकते हैं 10= 1e1।

— अर्जन जोहान्सन

@ ThanksrjanJohansen - अच्छे विचार, धन्यवाद, उनके साथ मेरे जवाब को संपादित किया

— TessellatingHeckler

मुझे 2 करने का एक अलग तरीका मिला ""-(""-(""-lt(""-""))-(""-lt(""-""))):। यह $?संक्षेप के लिए मुक्त हो जाता है, और फिर आप 1e1मेरे द्वारा सुझाई गई बात कर सकते हैं ।

— अर्जन जोहान्सन

उम t1. के दोनों संस्करणों के साथ टकराव की प्रतीक्षा करता (""-eq"")-(""-(""-eq""))है, बेहतर लगता है, qहैशटेबल में आसानी से बदल दिया जाता है।

— अर्जन जोहान्सन

5

TI-Basic (83 श्रृंखला), स्कोर 21 22 23 24 25 (1003 बाइट्स)

1:  A=A
2:  int(tan(tan(cos(cos(cos(B
3:  tanh⁻¹(√(√(√(√(√(√(√(√(√(√(C!°√(√(C!°
        √(√(√(√(√(√(C!°√(√(√(√(√(√(C!°√(
        C!°√(√(√(C!°√(C!°√(C!°√(√(√(√(√(
        √(C!°√(C!°√(C!°√(C!°
4:  4
5:  cosh(sinh⁻¹(cosh(sinh⁻¹(...sinh⁻¹(cosh(D    with 25 repetitions of cosh(
6:  6
7:  7
8:  8
9:  9
10: ₁₀^(₁₀^(E
11: 11
12: F nPr F/sin(tan⁻¹(...(sin(tan⁻¹(F nPr F     with 143 repetitions of sin(tan⁻¹(
13: det([[G≤G]...[G≤G]]ᵀ[[G≤G]...[G≤G           with 26 repetitions of G≤G
14: ln(tanh(not(H))...tanh(not(H)))
        ln(tanh(not(H)))^⁻not(H                 with 14+1 repetitions of tanh(not(H))
15: iPart(e^(e^(e^(I
16: sum(dim(identity(sum(dim(identity(sum(
        dim(identity(sum(dim(identity(J≥J
17: K nCr K+K nCr K+...+K nCr K                 with 17 repetitions of K nCr K
18: abs(i-i-...-i                               with 20 repetitions of i
19: rand→L:log(LL...LL→M:log(L→N:N⁻¹M           with 19 L's inside the log
20: mean(seq(OOO,O,O,sinh(sinh(cos⁻¹(O
21: ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(³√(ππ³√(π³
        √(π³√(ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(
        π³√(³√(ππ³√(ππ
22: 22
23: 3(3(3×√(3(3(3×√(3(3×√(3(3(3×√(3×√(3×√(
        3(3×√(3(3×√(3(3(3×√(3(3×√(3×√(3(3(
        3×√(3(3×√(3×√(3×√(3(3(3×√(3(3×√(3(
        3(3×√(3×√(3(3(3×√3
24: Fix 0
    sin⁻¹(ᴇ0
    AnsAnsAnsAnsAnsAnsAns
25: 5*5

Http://tibasicdev.wikidot.com/one-byte-tokens का संदर्भ लें कि कौन सी चीजें चुनौती देती हैं और यहां अनुमति नहीं देती हैं।

ये सभी पूर्ण कार्यक्रम हो सकते हैं, क्योंकि किसी प्रोग्राम की अंतिम पंक्ति अपने आप प्रिंट हो जाती है। लेकिन (17 को छोड़कर, जो कई लाइनें लंबी हैं) वे होम स्क्रीन पर स्निपेट भी हो सकते हैं।

इस बिंदु पर, मुझे उपलब्ध टोकन के बचे हुए किसी भी गैर-मूल्य को प्राप्त करने का कोई अन्य तरीका नहीं दिख रहा है। यदि कोई सुधार किया जाना है, तो इसे पहले अधिक रूढ़िवादी से ऊपर के कुछ समाधानों को शामिल करना होगा।

स्पष्टीकरण

A=Aएक बूलियन 1 है क्योंकि चर Aखुद के बराबर है।
Bडिफ़ॉल्ट रूप से 0 है, tan(tan(cos(cos(cos(Bलगभग 2.21 है, और फिर हम मंजिल लेते हैं।
C!°रेडियन में 1 डिग्री है, लगभग 0.017। इस की कुछ सकारात्मक शक्ति ताह (2) है, लगभग 0.964। हम निहित गुणा का उपयोग करके बाइनरी में उस शक्ति को एनकोड करते हैं और√( और फिर लेते हैं tanh⁻¹(।
4 सीधा है
cosh(sinh⁻¹(X $\sqrt{1+X^2}$
6-9 सीधे हैं
₁₀^( 10 की शक्तियों के लिए निर्मित एक बाइट है, और 10 ^ 10 ^ 0 = 10 ^ 1 = 10।
११ है ११।
5. पर प्रयुक्त चाल का एक और उदाहरणF nPr F है।sin(tan⁻¹(X को सरल बनाता है $\frac{1}{\sqrt{1+1/X^2}}$
G≤G1 है, इसलिए [[G≤G]...[G≤G]]एक 13x1 कॉलम वेक्टर है। अपने संक्रमण के उत्पाद को अपने साथ रखना मैट्रिक्स को देता है [[13]], जिसका निर्धारक 13 है।
not(H)है 1. tanh(not(H))बस कुछ संख्या 0 या 1 के बराबर नहीं है, और पहले लॉग में प्रदान की गई ln(XXX....X)ln(X)^⁻1संख्या को सरल करेगाXX 0 नहीं है (ताकि लॉग मौजूद है) और 1 नहीं (ताकि हम विभाजित न हों द्वारा 0)।
e^(e^(e^(F लगभग 15.15 को मूल्यांकन करता है, और फिर हम मंजिल लेते हैं।
J≥Jहै 1. identity(एक 1x1 पहचान मैट्रिक्स का निर्माण करता है, dim(अपनी पंक्ति और स्तंभ आयामों को पाता है, और sum(उन्हें प्राप्त करने के लिए जोड़ता है 2. फिर हम ऐसा करते हैं, 2x2 मैट्रिक्स के आयामों को जोड़कर 4 प्राप्त करते हैं, और फिर से, 4x4 मैट्रिक्स के आयामों को जोड़ते हैं। 8 पाने के लिए, और फिर से, 16 पाने के लिए 8x8 मैट्रिक्स के आयामों को जोड़ते हुए।
K nCr K द्विपद गुणांक 0 का चयन 0 है, या 1. एक साथ जोड़ना 17 1 का 17 देता है।
i-i-...-i ifies18i, और लेने के लिए सरल करता है abs( से 18 मिलता है।
rand→LL के लिए एक यादृच्छिक वास्तविक संख्या संग्रहीत करता है, लेकिन हमें परवाह नहीं है कि यह क्या है। हम कंप्यूटिंग कर रहे हैंlog(L)⁻¹log(L^19) , जो 19 को सरल बनाता है।
sinh(sinh(cos⁻¹(I4 से थोड़ा अधिक है, इसलिए seq(III,I,I,sinh(sinh(cos⁻¹(Iवह सूची देता है {0 1 8 27 64}जिसका अंकगणितीय माध्य 20 है।
चाल का एक और उदाहरण 3. प्राप्त करने के लिए 3. यहाँ, कुछ शक्ति π21 देना चाहिए; हम निहित गुणा का उपयोग करके टर्नरी में उस शक्ति को कूटबद्ध करते हैं और ³√(।
22 को 22 है।
ट्रिक का एक और उदाहरण 3 और 21 प्राप्त करने के लिए उपयोग किया जाता है। हम 3 की शक्ति को सांकेतिक शब्दों में बदलना करते हैं, जो 23 में समान है, जो 3×√(घनमूल के रूप में और (गुणन के लिए उपयोग किया जाता है।
Fix 0दशमलव के बाद 0 अंक प्रदर्शित करने के लिए सेटिंग है, पूर्णांकों के लिए सभी मानों को गोल कर रहा है। sin⁻¹(ᴇ0mult / 2 का मूल्यांकन करता है, और 2/2 खुद से 7 गुना गुणा 23.59 के बारे में देता है, जो 24 के लिए गोल होता है।
5*525 है। (यह 55 प्राप्त करने के लिए उपयोग करने के लिए अधिक रूढ़िवादी होगा , और 25 के लिए वहां उपयोग किए गए समाधान को अनुकूलित करेगा। लेकिन इस तरह से बहुत सारी जगह बचती है, और *बहुत उपयोगी चरित्र नहीं है क्योंकि निहित गुणन मौजूद है।)

— मिशा लावरोव
स्रोत

Xmax डिफ़ॉल्ट रूप से 10 है, Ymax = 10, Ymin = Xmin = -10 और कुछ अन्य डिफ़ॉल्ट मानों के साथ।

— lirtosiast

@lirtosiast ये सभी दो बाइट्स हैं।

— मिशा लावरोव

मुझे नियमों की व्याख्या के बारे में निश्चित नहीं है, लेकिन मुझे लगता है कि आप अभी भी उनमें से किसी एक बाइट को दोहराए बिना उपयोग कर सकते हैं (टोकन के बजाय वर्णों को बाइट्स मानते हुए)

— lirtosiast

मुझे लगता है कि व्याख्या के बारे में अस्पष्ट संदेह है। किसी भी मामले में, वर्णों को बाइट्स के रूप में गिना जाता है, यह Xfact = 4 जैसा कुछ होना चाहिए, क्योंकि Xmax ° के साथ संघर्ष करता है। हम शायद उस बिंदु से एक बिंदु, 2-बाइट कमांड से एक और बिंदु और TI-84-केवल आदेशों में से एक तीसरा बिंदु प्राप्त कर सकेंगे।

— मिशा लावरोव

4

एसओजीएल , स्कोर 16 18 20, 109 बाइट्स, 47 अक्षर इस्तेमाल किए

=                    push ""=""
ρ:¾/U                ceil(isPalindrome("")/(isPalindrome("")*(3/4))) -> ceil(1/(3/4)) -> ceil(4/3)
3                    push 3
MM¼÷                 100/(100*1/4)
æ⁄                   length of "aeiou"
6                    push 6
7                    push 7
Nτ                   log2(256)
9                    push 9
L                    push 10
⁹’                   byte with the 11th SOGL code point
Ιζrkk"⁸              `⁸`s UTF-8 codepoint to string, take off 1st 2 chars
'⁰                   messy compression
īuHHHHHHHHHHHHHH±    floor(0.1) `-1` 14 times, then change sign
aIIIIIIIIIIIIIII     A `+1` 15 times, A = 0
4²                   4^2
lllllllllllllllll”l  length of "lllllllllllllllll"
222222222++++++++    2+2+2+2+2+2+2+2+2
δ“○“-                429-420
Μ℮‘                  compressed string of "2ŗ" where ŗ defaults to 0

— dzaima
स्रोत

4

ब्रेकीलॉग , 16 पूर्णांक, 86 बाइट्स

1
2
3
4
5
6
7
8
9
ℕ<<<<<<<<<<
≜+₁₁
Ịbkkkkkkkị
Ḥl
ℤ₇×₂ṅ
"____**"pᶜ¹
⟦h>>>>>>>>>>>>>>>>ȧ

इसे ऑनलाइन आज़माएं! (इनपुट नियंत्रित करता है कि कौन सा प्रोग्राम 1 से एन तक चलाया जाता है)

व्याख्या

                       The output is...

1                      1
2                      2
3                      3
4                      4
5                      5
6                      6
7                      7
8                      8
9                      9
ℕ<<<<<<<<<<            Strictly bigger than ... strictly bigger than 0
≜+₁₁                   0 + 11
Ịbkkkkkkkị             "12" converted to an integer
Ḥl                     The length of "Hello, World!"
ℤ₇×₂ṅ                  -(-7 × 2)
"____**"pᶜ¹            The number of unique permutations of "____**"
⟦h>>>>>>>>>>>>>>>>ȧ    The absolute value of stricly less than ... stricly less than 0

— Fatalize
स्रोत

1

प्रोलॉग के बारे में बस सोचा: 1, क्योंकि आपको हमेशा अंत में एक डॉट की आवश्यकता होती है।

— झूठी

4

जेली , स्कोर 22, 177 बाइट्स

1: Ṇ  : logical NOT. When there is no input, 0 is assumed, so this returns NOT(0)=1
2: ~A~A  : ~ is bitwise NOT and A is absolute value, implicit 0 input
         : 0~ = -1;   0~A = 1;   0~A~ = -2;  0~A~A = 2.
3: 3  : literal 3
4: -ı-²²×-Ḟ:
   -ı-     : literal complex number -1-1j
   ²²×-    : square (2j), then square(-4), then multiply by (×) negative 1 (-) to get 4+0i
   Ḟ       : get the real component, which is 4
5: 5  : literal 5
6: 6  : literal 6
7: 7  : literal 7
8: 8  : literal 8
9: ØDṪ : tail(Ṫ) of list of digits (ØD) to return 9
10: ⁵  : literal 10
11: 11 : literal 11
12: CNCNCNCNCNCNCNCNCNCNCNC : again, 0 is taken as input because there is no input
                            : C is complement and N is negate
                            : so each NC returns 1-(-n)=n+1 and is equivalent to increment, returning 12
13: “>>>>>»L    : encodes "#GlomAbducens" with “>>>>>» then returns the length in characters (13) with L
14: ‘‘‘‘‘‘‘‘‘‘‘‘‘‘   : default input is 0 again, and each ‘ increments it to get 14
15: Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;ỊS : default input is 0 again.
                                   : each Ị returns abs(0)<1 = 1
                                   : these are concatenated together with ; then summed with S to get 15
16: ⁴  : builtin literal 16
17: ,,,,,,,,,,,,,,,,,ŒḂŒḊ : Each , is the pair dyad: x,y = [x,y] and x,[y,z] = [x,[y,z]]. 
                          : Thus each , increased the depth by 1, then ŒḊ returns the depth: 17
18: 9Ḥ : 9 doubled = 18
19: E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E : each E returns areallelementsidentical([0]) = 1
                                          : 19 of these are summed with +
20: 44440b44ạ/ : 44440 base 44 = [22,42,0].
               : ạ/ takes the absolute difference of terms: ||22-42|-0| = 20
21: ”TOHH : ”T is the character literal "T". OHH returns its ascii value 84 (O) halved twice (HH) = 21
22: literal 22

एक बार में सभी प्रयास करें या एक समय में एक प्रयास करें (तर्क है कि आपको कौन सा आउटपुट चाहिए)।

अप्रयुक्त वर्ण:

¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑÞßæçðȷñ÷øœþ !"#$%&'()*.:<=?@BFGIJKMPQRUVWXYZ[\]^_`acdefghijklmnopqrstuvwxyz{|}¶°¹³⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḲḶṂỌṚṢṬỤṾẈỴẒȦĊĖḞĠḢİĿṀṄȮṖṘṠẆẊẎŻḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«’

— fireflame241
स्रोत

आप 2 और 4A दोनों के लिए उपयोग कर रहे हैं , नहीं?

— डेनिस

@ डेनिस माय टीआईओ लिंक सही था, लेकिन मेरी व्याख्या अलग थी। फिक्स्ड

— फायरफ्लेम 241

1

समझा। Btw यदि आप 22¹£€Yमुख्य लिंक में रखते हैं, तो आप एक ही बार में सभी स्निपेट निष्पादित कर सकते हैं। tio.run/##0rNyan8///hzjauOsc6Ry5jLt0jG3UPbTq0icuUy4zLnMuC6/…

— डेनिस

4

रेंग, स्कोर 40, 149 बाइट्स

यहाँ कोशिश करो!

1.  e
2.  2
3.  ::l
4.  4
5.  5
6.  i`i`i`i`i`i`+++++
7.  7
8.  8
9.  9
10. A
11. ÇÇÇÇ¹
12. C
13* [[[[[[[[[[[[[mn~
14. E
15. F
16. G
17. H
18. I
19. J
20. K
21. L
22. M
23. N
24. O
25. P
26. Q
27. R
28. S
29. T
30. U
31. V
32. W
33. X
34. Y
35. Z
36. 6²
37. "%"
38* &fæ¦
39. D3*
40. 11±$1±±±±±±±±$11±$1±±±±$±$

सभी बड़े अक्षर नंबर हैं, इसलिए यह अच्छा है। सभी लेकिन इनमें से दो स्निपेट हैं। जो दो कार्यक्रम हैं:

13. [[[[[[[[[[[[[mn~
38. &fæ¦

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

— कोनोर ओ ब्रायन
स्रोत

4

सीजाम, स्कोर 27, 168 बाइट्स

1-3: X , Y,Z

चर X, YऔरZ क्रमशः 1, 2, और 3 के लिए प्रारंभ किए जाते हैं।

4: ",,,,",

स्ट्रिंग को पुश करें ,,,,और लंबाई लें।

5-9: 5 , 6, 7, 8,9

संख्यात्मक शाब्दिक।

10-20 : A-K

प्रांतीयकृत चर।

21: U)))))))))))))))))))))

वैरिएबल Uको इनिशियलाइज़ किया गया है 0। Uइसे 22 बार धकेलें और बढ़ाएँ।

22: 22

न्यूमेरिक शाब्दिक।

23: ';(((((((((';((((((((

चरित्र को धकेलें ;और पाने के लिए इसे 9 बार घटाएं 2, फिर धक्का दें ;और पाने के लिए इसे 8 बार घटाएं 3।

24: 4m!

4 की फैक्ट्री लें।

25: TT=TT=+TT=TT=TT=TT=TT=++++

TT=धक्का देता है 1। यह कोड के बराबर है 1 1+1 1 1 1 1++++।

26: N:i~W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-

Nएक स्ट्रिंग को धक्का देता है जिसमें एक नई रेखा होती है। :iइसे चरित्र कोड की सूची में परिवर्तित करता है, उपज है [10]। ~यह unpacks, दे रही है10 ।W-एक जोड़ने के बराबर है। 10 सोलह बार वृद्धि 26 देता है।

27: LLLLLLLLLLLLLLLLLLLLLLLLLLL0]0#

एक सूची में 0 का सूचकांक खोजें जहां 0 27 वें सूचकांक पर है।

अभी भी उपलब्ध वर्ण: $%&*./1<>?@MOPQRSV[\^_`abcdefghjklmnopqrstuvwxyz{|}

संभावित विस्तार के लिए कुछ नोट्स:

मुझे किसी अन्य चीज़ के लिए चर का उपयोग करने के लिए 10-20 को बदलना पड़ सकता है। यदि मुझे संख्या 1 से अधिक है, तो मैं उपयोग कर सकता हूं* (और संभवतः बिटवाइज़ ऑपरेटरों का , लेकिन मुझे नहीं लगता कि वे बहुत मदद करेंगे)।
मेरे पास अभि भी है S , जो भी अच्छा होगा मैं करूँगा।
अगर मैं 26 को बदलूं N{}/iW-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-, तो: उपलब्ध होगा।
मैं कुछ खाली सूचियों को धक्का दे सकता हूं और मौजूदा चर के साथ अधिक शून्य प्राप्त कर सकता हूं। मैं can भी प्राप्त कर सकता हूं, लेकिन यह तब तक बहुत उपयोगी नहीं लगता जब तक कि मैं इसे किसी तरह पूर्णांक तक नहीं डाल सकता, और m(के लिए m[) और iपहले से ही ले लिया गया हो।
सरणी हेरफेर के संदर्भ में, मैं कर सकता हूं:
- %या के साथ एक मानचित्र का उपयोग करेंf
- के साथ एक तह का उपयोग करें *
- कुछ सैटवाइज ऑपरेशन करें
- आधार रूपांतरण (यह आशाजनक लगता है, लेकिन मुझे नहीं पता कि मुझे आधार नंबर कैसे मिलेगा)
- उपयोग करके सरणियों का निर्माण करें |:M1|2|3|

— फल तोड़ना
स्रोत

बस एक नोट, आप 21 U)))))))))))))))))))))और 22 बना सकते हैं 22जो 1बाद के स्निपेट के लिए मुफ्त होगा ।

— बिजनेस कैट

@BusinessCat धन्यवाद, संपादित।

— फल जू

पाई को पूर्णांक में बदलने के लिए, आप इस तथ्य का उपयोग कर सकते हैं कि आधार रूपांतरण :iअंक सूची (जैसे [P]1bदेता है 3) पर एक निहितार्थ करता है ।

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

अगर आपको 23 साल से ज्यादा का समय नहीं लगता है तो आप ''इसके बजाय उपयोग कर सकते हैं ';और फिर (अंकों के चारों ओर लपेटने के लिए पर्याप्त उपयोग कर सकते हैं (इसलिए (प्रत्येक अंक के लिए लगभग 65k )। यह ;कुछ और के लिए मुक्त होगा , लेकिन मुझे यकीन नहीं है कि यह कितना उपयोगी है।

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

@MartinEnder मैं यह करूँगा कि अगर मुझे इसके लिए कोई उपयोग दिखाई दे ;, लेकिन फिलहाल मैं नहीं कर सकता।

— 22:38 पर फल

4

हास्केल , स्कोर 13, 86 बाइट्स

pi/pi
sum[sum[]^sum[],sum[]^sum[]]
3
4
5
6
7
8
9
length"eeeeeeeeee"
11
2+2+2+2+2+2
0xD

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

तेरह के स्कोर को संरक्षित करते हुए मेरे पत्र को ओवरलैप करने का एक तरीका खोजने के लिए अर्जन जोहान्स का धन्यवाद। (इस उत्तर को हटाए जाने के दौरान मुझे इसके बारे में सूचित करने के लिए उनके रास्ते से बाहर जाने के लिए भी।)

pi/piहै 1.0।
sum[]मूल्यांकन 0, 0^0करने के लिए 1और sum[1,1]करने के लिए 2। 3करने के लिए 9सिर्फ खुद को डिकोड।
length"eeeeeeeeee"स्ट्रिंग की लंबाई पैदावार, जो है 10।
2+2+2+2+2+2है 12।
0xDके लिए हेक्साडेसिमल है 13।

— Laikoni
स्रोत

आपके पास कुछ पत्र ओवरलैप हैं।

— xnor

@xnor इशारा करने के लिए धन्यवाद। अब तय होना चाहिए।

— लाईकोनी

आप कितनी ऊंची गिनती कर सकते हैं?

चुनौती:

स्कोरिंग:

नियम:

जावास्क्रिप्ट (ईएस 7), स्कोर 17, 176 बाइट्स

व्याख्या

जेली , 47 पूर्णांक, 519 बाइट्स

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

1 - 10

11 - 20

21 - 30

३१ - ४०

४१ - ४ 41

ब्रेनफक , स्कोर 2, 255 144 10 बाइट्स

व्याख्या

नीम , स्कोर 38, 327 बाइट

अजगर 2, 15

जाप , 448 बाइट, स्कोर 42

स्पष्टीकरण

पीएचपी, स्कोर 17, 130 बाइट्स

PHP, स्कोर 16, 94 बाइट्स

PHP, स्कोर 14, 84 बाइट्स

आर, स्कोर १३ १४

MATL , स्कोर 21 22 23 संख्या (273 बाइट्स)

व्याख्या

आगे सुधार के लिए कुछ विचार

विंडोज पर विम 8, स्कोर 13, 104 बाइट्स

स्पष्टीकरण

गणितज्ञ, स्कोर १३

05AB1E , स्कोर 18, 67 बाइट्स

पिंगपोंग , स्कोर 127

ऑक्टेव, स्कोर 14, 74 बाइट्स

जावास्क्रिप्ट (ईएस 7), 16 पूर्णांक, 137 130 128 बाइट्स

जावास्क्रिप्ट (ईएस 7), 16 पूर्णांक, 127 बाइट्स

Dyalog APL, स्कोर 15, 89 बाइट्स

> <> , स्कोर 20, 93 90 74 65 बाइट्स

मैथॉल्फ , 48 51 53 पूर्णांक, 324 बाइट्स

जावा 8, 11 12 13, 39 बाइट्स

गैया , स्कोर 25, 203 बाइट्स

स्पष्टीकरण

सी, स्कोर 13

ओम , स्कोर 21 22, 160 कुल बाइट्स

स्पष्टीकरण

पॉवरशेल, स्कोर 12, 91 बाइट्स। 14, 176 बाइट्स

TI-Basic (83 श्रृंखला), स्कोर 21 22 23 24 25 (1003 बाइट्स)

स्पष्टीकरण

एसओजीएल , स्कोर 16 18 20, 109 बाइट्स, 47 अक्षर इस्तेमाल किए

ब्रेकीलॉग , 16 पूर्णांक, 86 बाइट्स

व्याख्या

जेली , स्कोर 22, 177 बाइट्स

रेंग, स्कोर 40, 149 बाइट्स

सीजाम, स्कोर 27, 168 बाइट्स

हास्केल , स्कोर 13, 86 बाइट्स