न्यूनतम इनपुट से अधिकतम उत्पादन

Question

जाहिर है, कोड गोल्फिंग सब से कम से कम कोड बनाने की है। कौन वास्तव में परवाह करता है कि वास्तविक आउटपुट क्या है?

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

नियम:

1. तीन स्वतंत्र स्निपेट लिखें (पूर्ण कार्यक्रम / कार्य नहीं)।

2. स्निपेट उसी भाषा में होना चाहिए।

3. स्कोर आउटपुट बाइट्स की कुल संख्या है।

4. आउटपुट परिणाम, STDOUT, आदि के रूप में हो सकते हैं।

5. स्निपेट में कोई त्रुटि नहीं हो सकती है।

6. स्निपेट्स आउटपुट के विभिन्न रूपों का कारण हो सकता है।

7. अनुगामी न्यूलाइन वर्णों की गणना नहीं की जाती है।

8. पहला स्निपेट 1 बाइट या न्यूनतम लंबाई होना चाहिए जो कम से कम 1 बाइट आउटपुट का उत्पादन करता है।

9. दूसरा स्निपेट उससे एक बाइट लंबा होना चाहिए।

10. तीसरा स्निपेट पहले की तुलना में दो बाइट्स लंबा होना चाहिए।

Comments

हाँ, मुझे लगता है कि उत्पादन को सैद्धांतिक रूप से सीमित करने की आवश्यकता है, आपको शायद यह भी निर्दिष्ट करना चाहिए कि यह नियतात्मक होना चाहिए (जब तक कि मुझे गलतफहमी और यादृच्छिकता कुछ ऐसा नहीं है जो आप वास्तव में चाहते हैं ...)

— FryAmTheEggman

क्या हमें यह मानने की अनुमति है कि प्रत्येक स्निपेट एक ताजा आरईपीएल उदाहरण पर चलाया जाता है?

— SuperJedi224

@ SuperJedi224 हां।

— एडम डे

" आउटपुट के विभिन्न रूपों " में "फ़ॉर्म" क्या है ?

— लुइस मेंडू

@LuisMendo एग स्निपेट संदेश बॉक्स को पॉप अप कर सकता है, जबकि अन्य प्रिंट STDOUT को।

— Adám

Answer 1

gs2, 412 + 5.37 * 10 ⁹⁰² + 10 ^{10 903.1} बाइट्स

1. f-बाइट स्ट्रिंग के 1\n2\nFizz\n4\nBuzz\n...\nFizzBuzzरूप में धक्का 412।

2. fôअपने सभी क्रमपरिवर्तन को मुद्रित करता है, इसलिए 412! * 412वर्ण।

3. fôôउस 412 के सभी क्रमांकनों को प्रिंट करता है! -भुगतान सूची, जहां प्रत्येक तत्व 412 वर्ण लंबा है, इसलिए 412 * (412!)!बाइट्स।

EDIT: चीजों को परिप्रेक्ष्य में रखने के लिए, यह कम से कम है

10^{1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000}

बाइट्स, अब तक के अन्य सभी उत्तरों को बौना कर रहे हैं।

Answer 2

पायथ, 26 + 1140850688 + (4.37 × 10) ^20201781 )

मुझे पता नहीं है कि तीसरे कार्यक्रम के लिए आउटपुट की सटीक लंबाई की गणना करना संभव है या नहीं। मैं केवल सीमाएं दे सकता हूं। यह कुछ 4.37 × 10^20201781और के बीच प्रिंट होगा1.25 × 10^20201790 अक्षरों अक्षरों के ।

G
yG
yyG

यह प्रिंट:

abcdefghijklmnopqrstuvwxyz
['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']
[[], [''], ['a'], ['b'], ['c'], ..., ['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']]

पहला एक वर्णमाला को प्रिंट करता है, दूसरा एक वर्णमाला के सभी सबसेट को और तीसरा एक को अक्षर के सबसेट के सबसेट को दर्शाता है, जो कि लंबाई की सूची है 2^(2^26) ~= 1.09 × 10^20201781।

जाहिर है कोई भी कंप्यूटर कभी भी इस बड़ी सूची की गणना नहीं कर सकेगा और इसका उत्पादन कर सकेगा।

Comments

यदि मेरी गणना सही है तो इसमें 2 ^ (2 ^ 26-1) * (2 ^ 25 * 26 + 2 ^ 26 * 4) + 2 ^ (2 ^ 26) * 2 = 6.239 * 10 ^ 20201789 अक्षर होने चाहिए। ध्यान दें कि प्रत्येक स्ट्रिंग एक ही बार दिखाई देती है, इसलिए यह आपकी ऊपरी सीमा का लगभग आधा हिस्सा है।

— jimmy23013

यदि @ jimmy23013 और मेरी गणना दोनों सही हैं, तो इन तीन नंबरों का एकत्रीकरण तीसरे कार्यक्रम की आउटपुट लंबाई के बराबर होना चाहिए।

— लीजियनममाल 978

Answer 3

CJam, 17 + 34 + 72987060245299200000 = 72987060245299200051 आउटपुट बाइट्स

आसान तुलना के लिए, यह लगभग 7.3 * 10 ^{19 है} ।

P
PP
Ke!

प्रिंटों:

3.141592653589793
3.1415926535897933.141592653589793
012345678910111213141516171819012345678910111213141516171918012...

ठीक है, पिछले एक के [0 1 2 ... 19]साथ क्रमबद्ध संख्या के साथ सभी क्रमपरिवर्तन शामिल हैं। मैं इसे आज़माने की सलाह नहीं दूंगा ... ( 4e!स्वाद पाने के लिए इसे आजमाएँ ।)

इसे यहाँ टेस्ट करें: प्रोग्राम 1 , प्रोग्राम 2 , प्रोग्राम 3 का साने संस्करण ।

Answer 4

जैली , आउटपुट के 1.2 × 10 ²⁵⁶⁸ बाइट्स

ȷ
ȷ*
ȷ*!

1000 , 1000 ¹⁰⁰⁰ और 1000 ^{1000 की} गणना करता है ^!।

इसे ऑनलाइन आज़माएँ: पहला कार्यक्रम | दूसरा कार्यक्रम |तीसरा कार्यक्रम (संशोधित)

बाइट गिनती के उद्देश्यों के लिए, जेली के वर्तमान संस्करणȷ में बाइट 0xa0 के रूप में एन्कोड किया जा सकता है ।

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

जेली में, ȷपायथन e(वैज्ञानिक संकेतन) के रूप में संख्या शाब्दिक के अंदर इस्तेमाल किया जा सकता है । उदाहरण के लिए, 300003ȷ4 लौटाता है । जेली की वैज्ञानिक संकेतन में, गुणांक 1 में चूक हो जाती है और प्रतिपादक 3 में चूक हो जाती है , और सभी समान संख्या में लौट आते हैं।ȷ1ȷ31000

ȷ      Return 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
 *     Hook; compute 1000 ** 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
  !    Return 1000!.
 *     Fork; compute 1000 ** 1000!.

Comments

क्या आपके पास एपीएल के बराबर है ⍳?

— 18

@NBZ हाँ। एपीएल के के बराबर ıहै R(सीमा)। ıऔर ȷकुछ पूरी तरह से जेली में असंबंधित। मैं कुछ मिनटों में एक स्पष्टीकरण जोड़ दूँगा।

— डेनिस

जेली में मेरा पहला प्रयास: कितना आउटपुट होता ȷRRहै?

— 18

@ एनबीजेड मोटे तौर पर 2.4 मेगाबाइट।

— डेनिस

मैं देख रहा हूँ ȷRRहै ⍳¨⍳1000। मैं चाहता था ⍳⍳1000। डायलॉग में, ⍳⍳7स्कोर 91244, ⍳⍳8803487, ⍳⍳9स्कोर 7904816, क्योंकि यह 1 × 2 × 3 × 4 × ... सरणी में सभी सूचकांकों को सूचीबद्ध करता है। तो ⍳⍳1000सैद्धांतिक रूप से (WS FULL!) प्रत्येक 1000 तत्वों की 1000 सूचियों की एक सरणी उत्पन्न करता है!

— Adám

Answer 5

Hexagony , 1 + 3 + 6 = 10 बाइट्स

खैर ... बहुत प्रभावशाली स्कोर नहीं है, लेकिन कम से कम मैं यह कह सकता हूं कि यह इष्टतम है। एकल बाइट्स के साथ कुछ को प्रिंट करना और समाप्त करना असंभव है , इसलिए हम दो बाइट्स के साथ शुरू करते हैं:

!@

अनफोल्डेड कोड है

 ! @
. . .
 . .

यह एक बाइट को प्रिंट करता है और समाप्त करता है।

कोड के तीन बाइट्स के लिए, हम आउटपुट के तीन बाइट्स प्रिंट कर सकते हैं। उदाहरण के लिए:

o!@

या सामने आया:

 o !
@ . .
 . .

प्रिंट करता है 111। से कोई छोटे अक्षर dके लिए zकाम करता है और प्रिंट अपने चरित्र कोड। कोड के 3 बाइट्स के साथ 3 बाइट्स प्रिंट करने के लिए केवल 23 तरीके हैं।

अंत में, चार बाइट्स के लिए, 6 बाइट्स प्रिंट करने के 169 तरीके हैं। चूंकि उनमें से कोई भी सीधे-सीधे समाधान की तुलना में अधिक दिलचस्प (विषम नियंत्रण प्रवाह को छोड़कर) कुछ भी नहीं करता है, मैं इसे प्रस्तुत करूंगा:

o!!@

सामने आया:

 o !
! @ .
 . .

आपने यह अनुमान लगाया। यह प्रिंट करता है111111 ।

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

Comments

इसलिए ... कहा जाता है कि ब्रूट फोरसर सार्वजनिक रूप से उपलब्ध है? मैं ब्रूट फोर्सिंग कार्यक्रमों में दिलचस्पी लेना चाहता हूं जो आउटपुट 12345और पड़ाव हैं। । जिज्ञासा के लिए अन्याय।

— क्विंटोपिया

@ क्विंटोपिया यह GitHub रेपो में है, लेकिन इसके साथ 8-बाइट प्रोग्राम ढूंढना सौभाग्य है। ;)

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

खैर, उनमें से केवल 7 अज्ञात हैं, और आपने पहले से ही सत्य-मशीन कार्यान्वयन को खोजने में 7 बाइट समाधान खोजने की अपनी क्षमता का प्रदर्शन किया है ...

— क्विंटोपिया

Answer 6

गंभीरता से, 2025409 बाइट्स

1 बाइट:

N

(उत्पादन के 11,756 बाइट्स का उत्पादन करता है)

2 बाइट्स:

Nñ

153,717 बाइट्स का उत्पादन करता है

3 बाइट्स:

9!!

1,859,936 बाइट्स का उत्पादन करता है

गंभीरता से अभी तक "सभी सबसेट" या "सभी संयोजन" जैसी चीजों की सुविधा नहीं है, इसलिए इस पर स्कोर अपेक्षाकृत कम है।

Comments

ऐसा क्या करता Nहै जो इसे इतना उत्पादन करता है?

— जियोकॉवेल

बीयर की 99 बोतलों के बोल

— क्विंटोपिया

Answer 7

पायथन 3, 1 + 22 + 23 = 56

9
id
abs

उत्पादन

9
<built-in function id>
<built-in function abs>

9 प्रिंट करें और फिर के लिए परिभाषा idऔर abs।

Answer 8

भूलभुलैया , 1 + 2 + 4 = 7 बाइट्स

एक और कम स्कोर, जिसे मैं मुख्य रूप से पोस्ट कर रहा हूं क्योंकि मैंने इसे भाषा के लिए इष्टतम साबित किया है।

हेक्सागोनी की तरह, भूलभुलैया एक बाइट के साथ प्रिंट और समाप्त नहीं कर सकता है, इसलिए हम दो बाइट्स के साथ शुरू करते हैं:

!@

एक शून्य प्रिंट करता है और समाप्त होता है।

तीन बाइट्स के लिए, हम अनुभवहीन समाधान को हरा नहीं सकते हैं:

!!@

यह समाप्त होने से पहले दो बाइट्स प्रिंट करता है। कुछ अन्य विकल्प हैं, जैसे कि मुद्रण या उसके -1साथ । वहाँ एक बहुत अच्छा समाधान है, जो स्रोत कोड रोटेशन का उपयोग करता है:(!@~!@,!@

!>@

यह एक शून्य प्रिंट करता है, फिर स्रोत बनने के लिए स्थानांतरित करता है @!>। उस बिंदु पर यह एक मृत अंत को हिट करता है, चारों ओर मुड़ता है, और !समाप्त करने से पहले रास्ते पर फिर से निष्पादित करता है ।

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

!!>@

दो शून्य प्रिंट करें, पर शिफ्ट करें @!!> , एक और दो शून्य प्रिंट करें।

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

Answer 9

बैश, 1726 बाइट्स

(मैंने इसे अभी ठीक कर दिया है। कृपया विचार करें।

1 बाइट :"

आउटपुट:

>

307 बाइट्स: id

आउटपुट:

uid=501(geokavel) gid=20(staff) groups=20(staff),701(com.apple.sharepoint.group.1),12(everyone),61(localaccounts),79(_appserverusr),80(admin),81(_appserveradm),98(_lpadmin),33(_appstore),100(_lpoperator),204(_developer),395(com.apple.access_ftp),398(com.apple.access_screensharing),399(com.apple.access_ssh)

1418 बाइट्स: zip (प्रिंट्स टू एसटीडीयूएसटी)

कॉपीराइट (c) 1990-2008 Info-ZIP - सॉफ्टवेयर लाइसेंस के लिए 'zip "-L" टाइप करें।
ज़िप 3.0 (5 जुलाई 2008)। उपयोग:
ज़िप [-पोजिशन] [-b पथ] [-t mmddyyyy] [-n प्रत्यय] [zipfile सूची] [-xi सूची]
  डिफ़ॉल्ट कार्रवाई सूची में से zipfile प्रविष्टियों को जोड़ना या बदलना है, जो
  विशेष नाम शामिल कर सकते हैं - मानक इनपुट को संपीड़ित करने के लिए।
  यदि zipfile और सूची को छोड़ दिया जाता है, तो zip stdin को stdin संपीड़ित करता है।
  -f Freshen: केवल परिवर्तित फ़ाइलें -u अद्यतन: केवल परिवर्तित या नई फ़ाइलें
  zipfile में -d प्रविष्टियों को हटाएं-zipfile में जाएं (OS फाइलें हटाएं)
  -r निर्देशिका -j रद्दी (रिकॉर्ड नहीं) निर्देशिका नामों में पुनरावृत्ति
  -0 स्टोर केवल -L को LF को CR LF (-L CR LF से LF में बदलें)
  -1 तेजी से सेक -9 बेहतर सेक
  -q शांत ऑपरेशन -v क्रिया ऑपरेशन / प्रिंट संस्करण की जानकारी
  -सी एक-लाइन टिप्पणी जोड़ें -z zipfile टिप्पणी जोड़ें
  - @ स्टडिन से नाम पढ़ें-नवीनतम प्रविष्टि के रूप में पुराने के रूप में zipfile बनाते हैं
  -x निम्नलिखित नामों को शामिल करें -i में केवल निम्नलिखित नाम शामिल हैं
  -F फिक्स zipfile (-FF अधिक प्रयास करें) -D निर्देशिका प्रविष्टियों को न जोड़ें
  ए-एडजस्टेबल सेल्फ एक्सट्रैक्टिंग एक्स-जे जंक जिपफाइल प्रीफिक्स (अनजिप्सफैक्स)
  -T परीक्षण zipfile अखंडता -X eXclude eXtra फ़ाइल विशेषताएँ
  -वे संदर्भित फ़ाइल के बजाय लिंक के रूप में प्रतीकात्मक लिंक को स्टोर करते हैं
  -ई एनक्रिप्ट -n इन प्रत्ययों को संपीड़ित नहीं करता है
  -2 अधिक मदद दिखाओ

Comments

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

— जियोकॉवेल

इसके साथ दो समस्याएं हैं: 1. पहला कमांड कोई आउटपुट नहीं देता है, क्योंकि STDERR एक स्वीकृत आउटपुट विधि नहीं है। 2. डू का आउटपुट इस बात पर निर्भर करता है कि वर्तमान फ़ोल्डर में कौन सी फाइलें / निर्देशिकाएं हैं, इसलिए यह सभी स्वयं-निहित या प्रतिलिपि प्रस्तुत करने योग्य नहीं है।

— डेनिस

@ डेनिस आपको कैसे पता चलेगा कि पहला एसटीडीआरआर है, अगर यह सिर्फ मुद्रण उपयोग है? ठीक है, अब मैं देख रहा हूं कि दूसरा नियम कैसे टूटता है

— geokavel

इसके लिए जिप की आवश्यकता होती है। जिप बैश के साथ शामिल नहीं है।

— no --zɐɹƆ 18

@CrazyPython मैं मैक ओएस एक्स पर आम उपयोगिताओं या डिफॉल्ट बैश के साथ यदि आवश्यक हो तो शीर्षक को बदल सकता था।

— जियोकावल डेका

Answer 10

MATL , 313

भाषा के वर्तमान संस्करण ( 3.1.0 ) का उपयोग किया जाता है, जो इस चुनौती से पहले है।

1. कोड (पूर्वनिर्धारित शाब्दिक: संख्या 2 का उत्पादन करता है, जो स्पष्ट रूप से मुद्रित होता है):

   H
   

   आउटपुट (1 बाइट):

   2
   

2. कोड (संख्या पी का उत्पादन करता है, जो कि 15 दशमलव तक मुद्रित होता है):

   YP
   

   आउटपुट (17 बाइट्स):

   3.141592653589793
   

3. कोड (संख्या 1 से 99 तक, जो बीच में रिक्त स्थान के साथ डिफ़ॉल्ट रूप से मुद्रित होते हैं):

    99:
   

   आउटपुट (295 बाइट्स):

   1  2  3  4  5  6  7  8  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 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 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
   

Answer 11

प्रसंस्करण, 39 बाइट्स

नियतात्मक

1 बाइट :

print(X);

आउटपुट 0।

9 बाइट्स :

print(PI);

आउटपुट 3.1415927

29 बाइट्स :

print(P3D);

आउटपुट processing.opengl.PGraphics3D

गैर-नियतात्मक,> = 129 बाइट्स

> = 32 बाइट्स:

print(g);

आउटपुट processing.awt.PGraphicsJava2D@ + [mem-address]

> = 32 बाइट्स:

print( g);

आउटपुट processing.awt.PGraphicsJava2D@ + [mem-address]

> = 65 बाइट्स: (इस सुझाव के लिए @anOKsquirrel को धन्यवाद)

print(g,g);

आउटपुट

processing.awt.PGraphicsJava2D@ + [mem-address]
processing.awt.PGraphicsJava2D@ + [mem-address]

Comments

दूसरे खंड में आप 1, जी या जी, जी जैसे कुछ का उपयोग कर सकते हैं? या यहां तक ​​कि जी + जी?

— एकवॉस्केलर

Answer 12

जावास्क्रिप्ट, 1 + 3 + 18 = 18 22

बहुत दिलचस्प जवाब नहीं है, लेकिन शायद सबसे अच्छा जावास्क्रिप्ट सक्षम है।

alert(1)
alert(.1)
alert(1/9)

@UndefinedFunction की बदौलत 4 अंक जोड़े गए !

पाठ के रूप में आउटपुट:

1
0.1
0.1111111111111111

Comments

यदि आप लिखते हैं alert()तो आपको आउटपुट मिलता है undefined(कम से कम सफारी में)।

— जियोकॉवेल

@geokavel ओह सच में? क्रोम में यह सिर्फ एक खाली चेतावनी दिखाता है। मैंने फ़ायरफ़ॉक्स की जाँच नहीं की है। सफारी में स्कोर और भी कम होगा। : s

— user81655

alert(.1)देता है 0.1, और alert(1/9)देता है0.1111111111111111

— 5

@UndefinedFunction अच्छा सुझाव, धन्यवाद!

— user81655

लेखन alertमुझे देता हैfunction alert() { [native code] }

— ev3commander

Answer 13

Befunge, 2 + 4 + 6 = 12

.@
..@
...@

लंबाई 2 से छोटा कोई भी स्निपेट या तो आउटपुट नहीं कर सकता, या इसका आउटपुट समाप्त नहीं कर सकता।

Befunge में, .एक पूर्णांक के रूप में स्टैक के शीर्ष मूल्य को आउटपुट करता है, इसके बाद एक स्थान होता है। एक स्थान एक नई रेखा नहीं है, इसलिए इसे गिनती में शामिल किया गया है। इसके अतिरिक्त, स्टैक 0 से भरा "असीम" है, इसलिए प्रोग्राम आउटपुट (क्रमशः):

0 
0 0 
0 0 0 

Comments

..<@8 बाइट प्रिंट करता है।

— jimmy23013

Answer 14

स्माइलबासिक, 1 + 4 + 10 = 15 बाइट्स

कार्यक्रम 1:

किसी चीज को प्रिंट करने का सबसे छोटा तरीका कौन सा है? (प्रिंट) और एक एकल चरित्र। यह या तो एक संख्या या एक चर नाम हो सकता है, और इससे कोई फर्क नहीं पड़ता क्योंकि वे सभी समान लंबाई वाले हैं।

?1
1

कार्यक्रम 2:

अब हमारे पास कुछ और चीजों तक पहुंच है। सबसे लंबी अभिव्यक्ति जो बनाई जा सकती है, वह स्थिरांक #Y, #L या #R में से एक होगी, जिसमें क्रमशः मान 128, 256 और 512 हैं। हालांकि, इसके बजाय, मैं एक अल्पविराम का उपयोग करता हूं ताकि (इस मामले में) 3 अतिरिक्त स्थान मुद्रित हो सकें।

?1,
1   

कार्यक्रम 3:

3 वर्णों के साथ, आप ई-संकेतन संख्या लिख ​​सकते हैं:

?1E9
1000000000

Answer 15

HQ9 +, 71304

9

"99 बोतल बीयर" के 11,884-चरित्र गीत प्रिंट

99

दो बार "99 बोतल बीयर" प्रिंट करता है

999

प्रिंट्स "99 बोतल बीयर" तीन बार

Answer 16

जाप -Q, आउटपुट 1.0123378918474279e+150बाइट्स

पूरी संख्या है

1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,568

बाइट्स।

# 1

M

आउटपुट

{"P":3.141592653589793,"Q":1.618033988749895,"T":6.283185307179586}

67 बाइट्स के लिए। (झबरा का श्रेय)

# २

LÆ

आउटपुट

[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]

जो कि 501 बाइट्स है।

(श्रेय @ कोशगी)

# 3

;Eá

प्रारूप में 95 मुद्रण योग्य ASCII वर्णों के सभी क्रमपरिवर्तन को आउटपुट करता है ["...","...","..."...], जो है

$1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,001$ आउटपुट के बाइट्स।

---

यदि आप -FJapt में ध्वज का उपयोग करते हैं, तो आप आउटपुट बाइट्स की एक अनंत राशि प्राप्त कर सकते हैं । यह क्या करता है कि अगर कार्यक्रम की अंतिम अभिव्यक्ति झूठी का मूल्यांकन करती है, तो यह ध्वज में निर्दिष्ट मान को बदले में आउटपुट करता है। इसलिए मुझे लगता है कि जाप के लिए स्कोर -F"Insert Super Long String Here"अनंत है।

Comments

आप दूसरे से बाहर 501 बाइट्स प्राप्त कर सकते हैं ।

— झबरा

और 4 बाइट्स या पहले से बाहर एक जोखिम भरा 8 ।

— झबरा

ए-हा! मुझे पता था किundefined 1 बाइट पाने का एक तरीका है $:।

— झबरा

@ शैगी या मैं K26 बाइट्स का उपयोग कर सकता हूं और प्राप्त कर सकता हूं , लेकिन आपका 501 बटर सिर्फ जीनियस है

— अज्ञानता का अवतार

क्या आउटपुट को नियतात्मक नहीं होना चाहिए?

— झबरा

Answer 17

Malbolge , 1 + 2 + 3 = 6 बाइट्स

(=aN
(&a`M
(=a`_L

इसे ऑनलाइन आज़माएँ: पहला , दूसरा , तीसरा

आउटपुट:

r
ll
xxx

ब्रूट मजबूर। मान लिया गया \0कि यह एक मान्य आउटपुट कैरेक्टर नहीं है

के साथ \0:

cP
cbO
cbaN

आउटपुट:

\0
\0\0
\0\0\0

Answer 18

scg , 1 + 27 + 188 = 216

पेहला:

1

केवल 1 प्रिंट करता है, क्योंकि स्टैक को प्रोग्राम के अंत में आउटपुट किया जाता है।

दूसरा:

.d

प्रिंट डिबग जानकारी, जो इस तरह दिखना चाहिए:

Stack: []
Array Markers: []

तीसरा:

99r

स्टैक में 99 जोड़ता है, फिर रेंज फ़ंक्शन का उपयोग करता है। आउटपुट 01234567891011 .... (यह उन समयों में से एक है जो मैं चाहता हूं कि मैं फैक्टरियल फंक्शन लागू करूं। मैंने ऐसा नहीं किया है)

Answer 19

मारबेलस 1 + 1 + 2 = 4 बाइट्स ऑफ़ आउटपुट

दो-बाइट निर्देश होने से यहां Marbelous हैमस्ट्रिंग है। व्यर्थ टिप्पणी या अनावश्यक व्हाट्सएप एक विषम बाइट गिनती प्राप्त करने का एकमात्र तरीका है।

"A" प्रिंट करें और समाप्त करें:

`A

खाली ईओएल टिप्पणी के साथ "बी" प्रिंट करें और समाप्त करें

`B#

"सीडी" प्रिंट करें और समाप्त करें:

`C`D

Answer 20

Mathematica, 6 + 461 + 763 = 1230 1225 618 163 बाइट्स आउटपुट

%  (* -> Out[0] *)

?D  (* ->

D[f, x] gives the partial derivative ∂ f/∂ x. 
                                              n        n
D[f, {x, n}] gives the multiple derivative ∂  f/∂ x . 
D[f, x, y, …] differentiates f successively with respect to x, y, ….
D[f, {{x , x , …}}] for a scalar f
        1   2
     gives the vector derivative (∂ f/∂ x , ∂ f/∂ x , …). 
                                             1             2
D[f, {array}] gives a tensor derivative.

*)

?Do (* ->

Do[expr, {i   }] evaluates expr i    times. 
           max                   max
Do[expr, {i, i   }] evaluates expr with the variable i successively taking on the values 1 through i    (in steps of 1). 
              max                                                                                   max
Do[expr, {i, i   , i   }] starts with i = i   . 
              min   max                    min
Do[expr, {i, i   , i   , di}] uses steps di. 
              min   max
Do[expr, {i, {i , i , …}}] uses the successive values i , i , ….
               1   2                                     1   2
Do[expr, {i, i   , i   }, {j, j   , j   }, …] evaluates expr looping over different values of j, etc. for each i. 
              min   max        min   max

*)

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

Answer 21

जावास्क्रिप्ट, 72 बाइट्स

इस में काम करता है मोज़िला JSShell जावास्क्रिप्ट कमांड लाइन दुभाषिया ।

1 बाइट: 1

आउटपुट 1

35 बाइट्स: gc

आउटपुट

function gc() {
    [native code]
}

36 बाइट्स: run

आउटपुट

function run() {
    [native code]
}

Comments

तो ... Node.js? ..

— कैलक्यूलेटरफल

@CalculatorFeline मैं Node.js से परिचित नहीं हूं, लेकिन मेरे मैक पर यदि आप jsकमांड लाइन पर टाइप करते हैं, तो आपको एक जावास्क्रिप्ट शेल मिलता है।

— जियोकॉवेल

-bash: js: command not foundकृपया अधिक बताएं।

— कैलक्यूलेटरफलिन

@CalculatorFeline मुझे एक ही संदेश मिल रहा है। शायद उन्होंने jsबैश के नवीनतम संस्करण में निकाल लिया ।

— जियोलेवल

gcTIO नोड में मौजूद नहीं लगता है, इसलिए कृपया एक कार्यान्वयन ढूंढें या इस उत्तर को निकालें।

— कैलक्यूलेटरफैनलाइन

Answer 22

ऑक्टेव, 2818417 बाइट्स

e

के लिए 14 बाइट्स ans = 2.7183\n

pi

के लिए 14 बाइट्स ans = 3.1416\n

doc

संपूर्ण प्रलेखन प्रदर्शित करें। 2818389 बाइट्स, dd इसे ऑनलाइन आज़माएं! क्योंकि evalcकाम नहीं किया।

Answer 23

SmileBASIC 4, 1 + 13 + 15 = 29 बाइट्स

यह कुछ समायोजन के साथ 12Me21 के SmileBASIC 3 उत्तर के समान होने जा रहा है।

1

पहले की तरह, कुछ आउटपुट के लिए कोड की सबसे छोटी मात्रा 2 बाइट्स: ?( PRINT) और कुछ सिंगल-बाइट अभिव्यक्ति है। आम सहमति है कि है PRINTकरता नहीं एक नई पंक्ति का उत्पादन जब यह कारण जिस तरह से पाठ स्क्रीन काम करता है के लिए, अगली पंक्ति में अग्रिम। तो इसका परिणाम आउटपुट के एक बाइट में होता है।

?1
1

2

3 बाइट्स के साथ, हम कुछ अलग कर सकते हैं। SB4 का परिचय INSPECT, के रूप में उपनाम है ??, जो एक एकल मूल्य के बारे में जानकारी प्रिंट करता है। यदि हम इसे एक खाली स्ट्रिंग देते हैं, उदाहरण के लिए, यह एसबी 3 की तुलना में बहुत अधिक उत्पादन कर सकता है। यह हमें 13 बाइट्स मिलती है।

??"
STRING: (0)""

3

हमारे पास काम करने के लिए 4 बाइट्स हैं, इसलिए हमें यह तय करना होगा कि हमें अपने आउटपुट को अधिकतम करने के लिए क्या करना चाहिए। साथ ??जाना एक सुरक्षित शर्त है; हमारी अभिव्यक्ति पर उपयोग करने के लिए हमारे पास केवल 2 बाइट्स हैं, लेकिन INSPECTमूल रूप से इसका अतिरिक्त उत्पादन मुफ्त है। इसलिए मैं इसका उपयोग लेबल स्ट्रिंग को प्रिंट करने के लिए करता हूं। यह 15 बाइट्स है।

??@A
STRING: (2)"@A"

कुल 29 बाइट्स है।

Answer 24

माइक्रोस्क्रिप्ट II, 23 + 47 + 71 = 141 बाइट्स

1: C

निरंतरता की कठोरता को कड़ाई से परिभाषित नहीं किया गया है, लेकिन संदर्भ कार्यान्वयन में यह अपने आप चलता है, एक 23 बाइट स्ट्रिंग उत्पन्न करता है।

<Continuation @t=\d\d\dus>( \dएक अंक का प्रतिनिधित्व करता है, जो अंक बदलता है)।

मेरे कंप्यूटर पर, कम से कम, यह वास्तव में, लगभग 180 और लगभग 400 माइक्रोसेकंड को चलाने के बीच ले जाता है।

पहला प्रयोग मैंने कभी इस निर्देश के लिए किया है।

2: CP

आउटपुट के 47 बाइट्स- बीच में एक नईलाइन के साथ पहले एक से दो बार आउटपुट।

3: CPP

काफी सरल। आउटपुट के 71 बाइट्स- बीच में newlines के साथ पहले एक से तीन बार आउटपुट।

Comments

क्या यह निर्धारक है? अगर मैं आपको सही समझता हूं, तो इसमें अलग-अलग अंक होते हैं ...

— Adám

@ एनबीजेड यह हर बार सटीक एक ही तार का उत्पादन नहीं करता है, लेकिन यह हर बार उसी लंबाई के तारों का उत्पादन करता है जो मैंने अब तक परीक्षण किया है।

— सुपरजेडी २२४

हो सकता है कि इसे छोड़ दें-जैसा है, लेकिन एक वैकल्पिक उत्तर प्रदान करें जो वास्तव में नियतात्मक है?

— आदम डे

Answer 25

पॉवरशेल, ~ 4300 बाइट्स

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

लंबाई 1, 107 बाइट्स

?

यह के लिए एक उपनाम है Where-Object। यह अतिरिक्त जानकारी के लिए पूछते हुए एक उपयोगकर्ता संकेत को आउटपुट करेगा:

cmdlet Where-Object at command pipeline position 1
Supply values for the following parameters:
Property: 

लंबाई 2, 113 बाइट्स

rp

यह के लिए एक उपनाम है Remove-ItemProperty। यह अतिरिक्त जानकारी के लिए पूछते हुए एक उपयोगकर्ता संकेत को आउटपुट करेगा:

cmdlet Remove-ItemProperty at command pipeline position 1
Supply values for the following parameters:
Path[0]: 

लंबाई 1 स्निपेट की तुलना में मुश्किल से अधिक है।

लंबाई 3, ~ 4100 बाइट्स

gps

यह एक ऐसा उपनाम है Get-Processजिसके लिए सिस्टम पर सभी चल रही प्रक्रियाओं की एक स्वरूपित तालिका आउटपुट होगी:

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName                                                                                          
-------  ------    -----      ----- -----   ------     -- -----------                                                                                
     85       8     1232       4452    46     0.14    544 armsvc                                                                                               
    151      10     6800       9888    39     0.58   5116 audiodg                                                                                              
    480      25     6060      17200   124     0.84   4536 AuthManSvr            
...

Comments

"आउटपुट बदल सकता है" - यह एक ख़ामोशी है। प्रैक्सिस में, मशीन को उसी स्थिति में रीसेट करना असंभव होगा। शायद तीसरे के लिए एक अधिक निर्धारक विकल्प?

— आदाम

अव्यवहारिकता नियतत्ववाद को प्रबल नहीं करती है ... जब तक कि आप "नियतात्मक" की एक अलग परिभाषा का अर्थ नहीं करते हैं, उस स्थिति में आपको चुनौती में स्पष्ट रूप से राज्य करना चाहिए।

— AdmBorkBork

आपके अनुसार, लगभग हर कार्यक्रम नियतात्मक है, ठीक उसी मशीन की स्थिति को देखते हुए। एकमात्र अपवाद सही RNG के साथ उपकरण होगा, उदाहरण के लिए माइक्रोफोन शोर या कैमरा इनपुट पर आधारित।

— अड्म

@ एनबीजेड सच। मैं निश्चित रूप से उम्मीद करूंगा कि लगभग हर कार्यक्रम निर्धारक है। क्या आप शायद "अपरिवर्तनीय" का इरादा कर रहे हैं?

— AdmBorkBork

Answer 26

जावास्क्रिप्ट, आउटपुट के 312 + 318 + 624 = 1254 बाइट्स

$
$$
$+$

दो कार्यों $और$$ के लिए शॉर्टकट के रूप में, सभी प्रमुख ब्राउज़रों 'शान्ति में उपलब्ध हैं document.querySelectorऔर document.querySelectorAllक्रमशः। अलग-अलग ब्राउज़रों के पास देशी कोड एक दूसरे से कुछ अलग तरीके से जुड़े होते हैं, और IE प्रत्येक फ़ंक्शन में सादे JS का उपयोग करता है जिसके परिणामस्वरूप बहुत लंबा प्रतिनिधित्व होता है।

बाइट गिनती के लिए, मैं कभी-कभी संशोधित कंसोल डिस्प्ले के बजाय प्रत्येक के स्ट्रिंग प्रतिनिधित्व की लंबाई ले रहा हूं, इसलिए कुल बाइट्स निम्नलिखित प्रत्येक ब्राउज़र के लिए हैं:

• क्रोम: 56 + 57 + 112 = 225 बाइट्स
• IE: 312 + 318 + 624 = 1254
• फ़ायरफ़ॉक्स: 33 + 33 + 66 = 132

(मैं IE परिणाम "आधिकारिक" गिनती होने पर विचार कर रहा हूं क्योंकि यह सबसे लंबा है।)

गैर-कंसोल ब्राउज़र वातावरण के लिए, सबसे बड़े आउटपुट निम्नलिखित में से आते हैं:

1
!1 // Or '{}' if being fed to a function instead of beginning a statement
Map

ब्राउज़र द्वारा परिणाम की लंबाई:

• क्रोम: 1 + 5 (या 15 यदि {} उपयोग योग्य है) + 32 = 38 (या 48) बाइट्स
• IE: 1 + 5 (या 15 {}उपयोग योग्य है) + 38 = 44 (या 54)
• फ़ायरफ़ॉक्स: 1 + 5 (या 15 {}उपयोग योग्य है) + 36 = 42 (या 52)

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

• मौजूदा चर: हम सभी मूल उपलब्ध चर को अधिकतम तीन वर्णों के साथ पा सकते हैं Object.getOwnPropertyNames(window).filter(x=>x.length<=3), और फिर mapउन्हें बड़े लोगों को निर्धारित करने के लिए उनके स्ट्रिंग आउटपुट के लिए। (ध्यान दें कि कुछ ब्राउज़रों जैसे कि फ़ायरफ़ॉक्स में, कुछ विशेष कंसोल वेरिएबल को इस तरह एक्सेस नहीं किया जा सकता है क्योंकि वे विंडो की संपत्ति नहीं हैं।)
• JS के पास सीमित संख्या में प्रकार के शाब्दिक हैं जो इतने कम वर्णों के साथ बनाए जा सकते हैं:
  • कल्पना के अनुसार, दशमलव संख्या एक दशमलव अंक होनी चाहिए ( 1234567890) वैकल्पिक रूप से .और अधिक दशमलव अंकों और / या एक प्रतिपादक भाग के बाद, या .एक या अधिक दशमलव अंकों के बाद और वैकल्पिक रूप से एक प्रतिपादक भाग होना चाहिए। संख्या के अन्य प्रकार या तो होना चाहिए 0o, 0xया 0b(या रूपों अपरकेस), एक या अधिक संख्याएं। हमारे उद्देश्यों के लिए, हम निम्नलिखित को घटा सकते हैं:
    • केवल दस एकल-वर्ण संख्याएँ हैं, जो पूर्णांक 0 के माध्यम से हैं। 9. केवल दो-वर्ण संख्या पूर्णांक 0-99 हैं (0-9 के बाद दशमलव जोड़कर), और संख्या 0.1 से 0.9 के माध्यम से प्रारंभिक शून्य को छोड़ कर । केवल तीन-वर्ण संख्या 0-999 हैं, जिसमें 0x0-0xf, 0o0-0o7, ​​0b0, और 0b1 शामिल हैं, घातीय 1e1 9e9 (10 वर्ण), और संख्या 0.1-9.9.9 और .99 के माध्यम से ।99। जबकि तकनीकी रूप से एक नंबर शाब्दिक नहीं है, NaN को तीन वर्णों में भी संदर्भित किया जा सकता है।
  • स्ट्रिंग्स, सरणियाँ, और regexps, जिनमें से प्रत्येक अधिकतम केवल सामग्री का एक ही वर्ण ले सकता है। एक सरणी $, अल्पविराम, या एकल-अंक संख्या से भरा जा सकता है । केवल एक तत्व के साथ सारणी को तत्व के रूप में तार के लिए मजबूर किया जाता है। खाली सरणियाँ खाली तार बन जाती हैं।
  • पर्यावरण के आधार पर, तीन वर्णों वाली सरल वस्तुओं का निर्माण करना संभव है या नहीं भी हो सकता है। आमतौर पर, {}एक स्क्रिप्ट की शुरुआत में अकेले एक वस्तु बनाने के बजाय एक बाड़े के रूप में माना जाएगा। eval({})अपरिभाषित eval({$})देता है, $फ़ंक्शन लौटाता है । अपर्याप्त वर्ण के चारों ओर हैं {}में() ।
• ऐसे कोई कीवर्ड नहीं हैं जो उपयोग करने के लिए पर्याप्त हैं। कीवर्ड if, in, do, new, for, try,var , और letसभी दो अन्य पात्रों की एक न्यूनतम का उपयोग करने, सीमा से अधिक की आवश्यकता होगी।
• उपलब्ध एकल ऑपरेटरों शामिल ~, +, -, !, ++, और --। दो-वर्ण ऑपरेटर केवल एक एकल वर्ण चर के साथ उपयोग किए जा सकते हैं, जिनमें से केवल एक है ($ ) है, जो पैदावार देता है NaN। अन्य चार ऑपरेटरों को किसी एक या दो-चरित्र मूल्य के साथ उपयोग किया जा सकता है, जिनमें से हैं:
  • कई चर। (कुछ शान्ति पर $, $_, $0, $1, $2, $3, $4, $,$$ , $x)। जब इन ऑपरेटरों के साथ प्रयोग किया जाता है, परिणाम के लिए सीमित हैं -1, true, false, और NaN।
  • 109 नंबर। परिणाम: पूर्णांकों -100 99 के माध्यम से, -0.9 -0.1 के माध्यम से, true, false।
  • खाली तार। परिणाम:-1 , 0( -0हो जाता है 0toString पर), true।
  • किसी एक-वर्ण के भिन्न मानों के परिणाम एक-वर्ण वाले अपर संचालक के साथ जुड़े होते हैं। नए परिणाम: कोई नहीं।
• प्रयोग करने योग्य द्विआधारी ऑपरेटरों (जो कमरे दोनों ऑपरेंड के लिए छोड़ दिया है करने के लिए एक एकल वर्ण होना चाहिए) कर रहे हैं +, -, *, /, %, <,> , &, |, ^। उनका उपयोग केवल प्रत्येक पक्ष पर एकल-वर्ण मान के साथ किया जा सकता है। मूल्यों के विकल्प में शामिल हैं $और पूर्णांक 0-9। इनमें से सभी संयोजनों के परिणामों में Infinity, ऊपर उल्लिखित कुछ संख्याएँ और बाइनरी मान शामिल हैं, और कई अंश जो 19 वर्णों या उससे कम के तार से जुड़े हुए हैं ( 1/719 वर्ण हैं, जो 1/9कि ऊपर दिए गए केवल 18 के विपरीत है), और $पूर्व या पाठ का पाठ प्रतिनिधित्व एकल-अंक पूर्णांक या उसके बाद।
• अंत में, सभी शेष ऑपरेटर और अभिव्यक्ति: सदस्य ऑपरेटर . को एक मौजूदा चर और एक पहचानकर्ता की आवश्यकता होती है जो संपत्ति का उल्लेख करता है। यहां इसके सभी उपयोगों का परिणाम है undefined। मान को ( )रिटर्न में मान देना, जैसा कि इसके साथ असाइन करना है =। ()किसी फ़ंक्शन के रूप में किसी मान को कॉल करने के लिए `` का उपयोग करना या अपरिभाषित या सभी उपलब्ध मूल्यों के साथ त्रुटियां।

यह सब जोड़ते हुए, क्रोम कंसोल का उपयोग करते समय कुल 1651 संभावित आउटपुट होते हैं। एक, दो और तीन वर्णों के लिए सबसे लंबा आउटपुट है $,$$ और $+$क्रमशः।

Answer 27

डीसी , 2 + 5 + 18 = 25 बाइट्स

1: Ffपैदावार ( यह ऑनलाइन प्रयास करें! ):

15

2: Fdfपैदावार ( यह ऑनलाइन प्रयास करें! ):

15
15

3: Fd^fपैदावार ( यह ऑनलाइन प्रयास करें! )

437893890380859375

जिनमें से कोई भी विशेष रूप से दिलचस्प dcनहीं है , लेकिन आउटपुट के ढेर को थूकने के लिए वास्तव में महान नहीं है। मुझे पसंद है कि प्रत्येक उत्तर पिछले पर बनाता है। वैसे भी, Fसिर्फ 15 की संख्या है; fपूरे ढेर को प्रिंट करता है; dडुप्लिकेट टॉप-ऑफ-स्टैक; ^टॉप-ऑफ-स्टैक की शक्ति के लिए टॉप-ऑफ-स्टैक को उठाता है (इस मामले में, 15 ^ 15)। मुझे विश्वास नहीं होता कि इसमें टॉप किया जा सकता है dc।

Answer 28

रूबी, 3 + 14 + 28 = 45 बाइट्स

मैंने ऐसा क्यों किया।

p

प्रिंट करता है nil।

$>

प्रिंट करता है #<IO:<STDOUT>>।

dup

की तर्ज पर कुछ प्रिंट करता है #<Object:0x0000000003610988>।

irb

इंटरएक्टिव रूबी का एक उदाहरण लॉन्च करता है। बाहर निकलने पर, लौटी हुई वस्तु #<IRB::Irb: @context=#<IRB::Context:0x0000000003643040>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x00000000038900a0>>121 के लिए है, लेकिन चूँकि इसके लिए आपको ^Dवास्तव में irb उदाहरण से बाहर निकलने के लिए प्रेस या कुछ करने की आवश्यकता होती है , मुझे यकीन नहीं था कि यह वास्तव में "3 बाइट्स" में एक समाधान के रूप में गिना जाएगा इसलिए मैं नहीं हूँ वास्तव में इसे स्कोर में शामिल करें जब तक कि यह ठीक न हो जाए।

Answer 29

पर्ल 6, 53 (17 + 18 + 18) बाइट्स

e
-e
e*e

1. e आउटपुट $e$ 15 दशमलव स्थानों के लिए
2. -e आउटपुट $-e$ 15 दशमलव स्थानों के लिए
3. e*e आउटपुट $e^2$, लेकिन अजीब तरह से, यह एक और दशमलव स्थान देता है

Answer 30

रूनिक एनचेंमेंट्स, आउटपुट के 4,000,000 बाइट्स

पहला कार्यक्रम है:

a@

2 बाइट्स लेता है: स्टैक से एक मान पुश करें, स्टैक से एक मूल्य प्रिंट करें, और समाप्त करें। इस मामले में यह प्रिंट करता है 10(हालांकि 0 से 16 तक कोई पूर्णांक मान भी मान्य है)

3 बाइट्स के लिए:

aY@

प्रिंट्स 10000, फिर से, a16 समावेशी के माध्यम से 1 हो सकता है (मूल कार्यक्रम की तुलना में अधिक आउटपुट उत्पन्न करने के लिए, 0 अन्य ऑपरेटरों के तहत संभावित रूप से मान्य है) और ऐसे कई ऑपरेटर नहीं हैं जो एक इनपुट लेते हैं और किसी भी आउटपुट का उत्पादन करते हैं; बहुत कम अब उत्पादन। XCYZ:Eकेवल वास्तविक विकल्प हैं। aY@केवल वही है जो सबसे अधिक आउटपुट देता है।

P$!;

भाषा विनिर्देश के अनुसार, यह असीम रूप से चलता है। हालाँकि जैसा कि दुभाषिया में "ठीक है, पर्याप्त है" अधिकतम निष्पादन सीमा है, यह 4 वर्णों में प्राप्त होने वाला सबसे अधिक उत्पादन है (और 128kib से अधिक के लिए ~ 130,000 बाइट्स के बाद TIO कट जाता है) और दुभाषिया भाषा को परिभाषित करता है , यह काम करता है। और जब मैंने उस दहलीज को एक बार पहले (10k चरणों से 1 मिलियन तक) उठाया है, तो मैं इसके साथ किसी भी समय खिलवाड़ करने की योजना नहीं बनाता।

बड़ा?

अगर मैं यहां की गई तीन धारणाओं का आह्वान करता हूं , तो निश्चित है।

`AA@

जो काम करता है Ack(65,Ack(65,64)) , जो शुरू में एकरमैन फंक्शन में जाने के लिए बहुत बड़े मूल्य नहीं हैं - निश्चित रूप से पुराने पोस्ट में 255 से छोटा - लेकिन इसकी ठीक है, हम 4 निर्देशों में दो बार एक को कॉल कर सकते हैं।

और केवल भगवान ही जानता है कि वह क्या छापेगा।

_{नोट: Aअनुदेश तब से Mathमेटा-निर्देश बना दिया गया है , जो स्टैक पर 3 वस्तुओं का उपभोग करता है: किस निर्देश को निष्पादित करने के लिए एक चर और फिर दो इनपुट, x और y। जैसे कि यह कार्यक्रम वास्तव में कुछ भी नहीं करता है, क्योंकि दोनों न तो Aऔर न ही @एक गणित फ़ंक्शन के लिए मैप करते हैं और क्योंकि दो बाद की कॉल का परिणाम स्टैक अंडरफ़्लो में होता है।}