13

चुनौती

आपका लक्ष्य एक प्रोग्राम लिखना है जो किसी अन्य प्रोग्राम को प्रिंट करता है। उस मुद्रित प्रोग्राम को एक और प्रोग्राम प्रिंट करना चाहिए, और नए प्रोग्राम को अंत तक एक और प्रोग्राम प्रिंट करना चाहिए।

नियम

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

शुभ लाभ!

code-challenge code-generation

— कछुआ
स्रोत

अधिकतम स्कोर है 2^2048, या 3.2317e616।

— orlp

बड़े स्कोर की तुलना करना आसान बनाने के लिए, कृपया अपने स्कोर में एक सन्निकटन को उस रूप में शामिल करें a*10^bजहां 1<=a<10और bएक प्राकृतिक संख्या है।

— दोष

2

दरअसल, मेरी पिछली गणना गलत थी। मान लिया जाए कि कार्यक्रम बाइट्स में होना चाहिए अधिकतम संभव स्कोर <टिप्पणी के लिए बहुत लंबा है> या 1.2673e614।

— orlp

20

सीजेएम, 4.56 × 10 ⁵²⁶ कार्यक्रम

2D#2b{"\256b_(256b:c'\s`_:(er`":T~{;38'ÿ*`{:T~{;63'ÿ*`{:T~{;88'ÿ*`{:T~{;114'ÿ*`{:T~{;140'ÿ*`{:T~{;166'ÿ*`{:T~{;192'ÿ*`{:T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}_~

सटीक स्कोर: 254 ²¹⁹ + 254 ¹⁹² + 254 ¹⁶⁶ + 254 ¹⁴⁰ + 254 ¹¹⁴ + 254 ⁸⁸ + 254 ⁶³ + 254 ³⁸ + 254 ¹³ + 3

फ़ाइल आकार सीमा का पालन करने के लिए सभी कार्यक्रमों को आईएसओ-8859-1 एन्कोडिंग का उपयोग करके सहेजना होगा।

@ChrisDrost का धन्यवाद जिन्होंने बग को इंगित किया और नेस्टिंग दृष्टिकोण का सुझाव दिया।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

254 ²¹⁹ + 2 ⁹ 4.56 × 10 ⁵²⁶ कार्यक्रम

स्कोर का लाइन शेयर निम्नलिखित, बहुत सरल प्रोग्राम ¹ द्वारा प्राप्त किया जा सकता है ।

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

इस प्रोग्राम को चलाने से प्रोग्राम तैयार होता है

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

और 254 ^{219 के} बाद - 1 और पुनरावृत्तियों, कार्यक्रम

{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

यह अंतिम गैर-खाली प्रोग्राम एक त्रुटि ^{2 से} बाहर निकलता है और कुछ नहीं (खाली प्रोग्राम) प्रिंट करता है।

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

मान लें कि स्ट्रिंग पहले से ही स्टैक पर है।

{      e# Push a code block.
  \    e# Swap the string on top of the code block.
       e# This will cause a runtime error if there is no string on the stack.
  256b e# Convert the string (treated as a base-256 number) to integer (I).
  _(   e# Copy the integer and decrement the copy.
  256b e# Convert the integer into the array of its base-256 digits.
  :c   e# Cast each base-256 digit to character. Converts from array to string.
  '\s  e# Push a string that contains a single backslash.
  `    e# Push its string representation, i.e., the array ['" '\ '\ '"].
  _:(  e# Push a copy and decrement each character. Pushes ['! '[ '[ '!].
  er   e# Perform transliteration to replace "s with !s and \s with [s.
       e# This skips characters that require escaping.
  `    e# Push its string representation, i.e., surround it with double quotes.
  Q    e# Push an empty string.
  ?    e# Select the first string if I is non-zero, the empty string otherwise.
  \    e# Swap the selected string with the code block.
  "_~" e# Push that string on the stack.
}      e#
_~     e# Push a copy of the code block and execute it.
       e# The stack now contains the modified string, the original code block
       e# and the string "_~", producing an almost exact copy of the source.

254 ¹⁹² 2 5.35 × 10 ⁴⁶¹ अधिक कार्यक्रम

यह वह जगह है जहां चीजें थोड़ा पागल हो जाती हैं।

पहला कार्यक्रम अत्यधिक संकुचित है। एक समान प्रोग्राम लिखकर, जो खाली प्रोग्राम के बजाय, अंततः उपरोक्त अनुभाग से पहला प्रोग्राम बनाता है, हम स्कोर को 254 ¹⁹² प्रोग्राम ³ से सुधार सकते हैं ।

कार्यक्रम

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{"\256b_(256b:c'\s`_:(er`":T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}_~

पिछले अनुभाग के पहले कार्यक्रम के समान है, और 254 ¹⁹² पुनरावृत्तियों के लिए पूर्व और इसके आउटपुट को चलाने से बाद का उत्पादन होता है।

मान लें कि स्ट्रिंग पहले से ही स्टैक पर है:

{                           e# Push a code block.
  "\256b_(256b:c'\s`_:(er`" e# Push that string on the stack.
                            e# The characters inside it behave exactly as
                            e# they did in the previous section.
  :T~                       e# Save the string in T and evaluate it.
  {                         e# If the integer I is non-zero, keep the generated
                            e# string; else:
    ;                       e#   Pop the code block from the stack.
    219'ÿ*`                 e#   Push a string of 219 ÿ's (with double quotes).
    {Q?\"_~"}               e#   Push that block on the stack.
    s                       e#   Push its string representation.
    (\                      e#   Shift out the { and swap it with the tail.
    T                       e#   Push T.
  }?                        e#
  \                         e# Swap the selected string with the code block
                            e# or T with the tail of the code block.
  "_~"                      e# Push that string on the stack.
}                           e#
_~                          e# Push a copy of the code block and execute it.

मूर कार्यक्रम

पिछले खंड का पहला कार्यक्रम अभी भी अत्यधिक संकुचित है, इसलिए हम एक समान विधि लागू कर सकते हैं और एक कार्यक्रम लिख सकते हैं, जो 254 ¹⁶⁶ पुनरावृत्तियों के बाद , उपरोक्त कार्यक्रम का उत्पादन करता है।

इस तकनीक को बार-बार दोहराते हुए जब तक हम 255 बाइट सीमा तक नहीं पहुँच जाते, तब तक हम कुल 254 ¹⁶⁶ + 254 ¹⁴⁰ + 254 ¹¹⁴ + 254 ⁸⁸ + 254 ⁶³ + 254 ³⁸ + 254 ¹³ + 1 9 1.59,000 10 ³⁹⁹ प्रोग्राम जोड़ सकते हैं। पिछले वर्गों के उन।

¹ _{न्यूलाइन को स्पष्टता के लिए जोड़ा गया।}_{मेटा पर}
² _{प्रति आम सहमति , यह डिफ़ॉल्ट रूप से अनुमत है।}
³ _{या 0.00000000000000000000000000000000000000000000000000000012%}

— डेनिस
स्रोत

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— डेनिस

5

जावास्क्रिप्ट, 1000 कार्यक्रम

x=999;
q=";alert(x=999?`q=${JSON.stringify(q)+q}`.split(x).join(x-1):``)";
alert(
    x ? `x=999;q=${JSON.stringify(q)+q}`.split(x).join(x-1) // basically .replaceAll(x, x-1)
      : ``
)

क्या यह वैध है, ठीक तीसरे नियम को समझने के तरीके पर निर्भर करता है।

— Ypnypn
स्रोत

यह तकनीकी रूप से एक क्वीन नहीं है, क्योंकि यह एक समान कॉपी के बजाय अपने स्वयं के स्रोत कोड के संशोधित संस्करण को प्रिंट करता है। यह स्पष्ट रूप से कुन जैसी तकनीकों का उपयोग करता है। मुझे लगता है कि हमें @TheTurtle से स्पष्टीकरण की आवश्यकता होगी।

— जॉन सिप

5

@ जॉन और येपनीन यह कुछ ऐसा है जैसे मैंने कल्पना की थी। यह काम।

— कछुआ

6

आप अभी भी कोड की लंबाई सीमा से काफी नीचे हैं। आप 999 को कुछ बड़े में क्यों नहीं बदलते?

— DankMemes

4

रूबी, 1.628 × 10 ^ 237 कार्यक्रम

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;_="a=%#x-1;_=%p;puts _%%[a,_]if a";puts _%[a,_]if a

मेरे पर्ल जवाब के रूप में एक ही दृष्टिकोण, लेकिन क्योंकि रूबी पहले से ही बड़े ints को संभालती है, इसलिए इसे हेक्स के रूप में संग्रहीत करना आसान है।

रूबी, 9.277 × 10 ^ 90 कार्यक्रम

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;b=0xf;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-("%x"%a).length));_="a=%#x;b=%#x;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-('%%x'%%a).length));_=%p;puts _%%[a,b-1,_]if a";puts _%[a,b-1,_]if a

इसलिए यह प्रयास पिछले क्विन-लाइक पर थोड़ा भिन्न है, लेकिन सभी अतिरिक्त कार्यों के कारण मुझे कहीं भी नंबर नहीं मिल रहा है जितना कि एक दूसरे के पास ... एक और दृष्टिकोण की कोशिश करना दिलचस्प था!

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

4

पायथन 2, 9.7 * 10 ^ 229 प्रोग्राम

O=0
if len(hex(O))<191:print"O=0x%x"%(O+1)+open(__file__).read()[-68:]

— नीला
स्रोत

अच्छा, स्ट्रिंग पुनरावृत्ति के बारे में नहीं सोचा था!

— डोम हेस्टिंग्स 13

2

सी, 2.2 * 10 ^ 177 कार्यक्रम

#define S(s)char*q=#s,n[]="#####################################################################################################";i;s
S(main(){while(n[i]==91)n[i++]=35;i==101?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})

यह सही नहीं है, लेकिन बहुत अच्छा है। मेरा मतलब है कि यह बिल्कुल 255बाइट्स लंबा है और एक ही लंबाई के कार्यक्रम उत्पन्न करता है। आप शायद कुछ और कार्यक्रमों को पाने के लिए कुछ और सोच सकते हैं, लेकिन मैं इसे अभी के लिए छोड़ दूंगा।

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

चार्ट की सीमा #(= 35) से [= (91) तक सीमित है। ऐसा इसलिए है क्योंकि मैं किसी भी "या \स्ट्रिंग में नहीं चाहता , क्योंकि उन्हें भागने की जरूरत है।

कार्यक्रम पीढ़ी समाप्त होती है जब चार सरणी में सभी मान nहोते हैं [। फिर यह एक साधारण डमी प्रोग्राम main(){}को आउटपुट करता है, जो खुद कुछ नहीं करता है।

#define  S(s) char *q = #s; /* have the source as a string */ \
char n[] = "#####################################################################################################"; \ 
int i; \
s /* the source itself */
S(main() {
    while(n[i]=='[') /* clear out highest value, so next array element be incremented */
        n[i++]='#'; 
    i==101 /* end of array reached? output dummy program */
        ? q = "main(){}"
        : n[i]++; /* count one up in the whole array */
    printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)", n, q);
})

प्रदर्शन के रूप में यह काम करना चाहिए कि मैंने अभी सीमाएं बदल दी हैं, इसलिए केवल ASCII- कोड के बीच के अक्षर 35और 36उपयोग किए जाते हैं और केवल 4 सरणी तत्व हैं।

परिणामी कार्यक्रम हैं

% echo > delim; find -iname 'program_*.c' | xargs -n1 cat delim

#define S(s)char*q=#s,n[]="####";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$###";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="###$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$##$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="####";i;s
S(main(){})

यह 2^4 + 1 = 17विभिन्न कार्यक्रमों का उत्पादन करता है।

इसलिए उपरोक्त कार्यक्रम ((91-35)+1)^101 + 1 = 57^101 + 1 ~= 2.2 * 10^177विभिन्न कार्यक्रमों को आउटपुट करता है। मुझे पूरा यकीन नहीं है कि यह मायने रखता है, या अगर मेरी गणना भी सही है

— MarcDefiant
स्रोत

1

क्या आप यह शामिल कर सकते हैं कि यह 2.2 * 10^177(जो तुलना करना चाहते हैं) के बारे में है?

— दोष

यह कैसे गणना करने के लिए पता नहीं था, लेकिन मैंने इसे शामिल किया ;-)

— MarcDefiant

wolframalpha.com =)

— दोष

1

पर्ल, 1 × 10 ^ 163

अन्यथा यह एक बहुत ही बुनियादी क्वीन है, जितना संभव हो उतना कम वर्णों को सिकोड़ें, जो केवल काउंटर के न चलने पर ही चलता है 0।

use bigint;$i=9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999||die;$_=<<'e';eval
print"use bigint;\$i=$i-1||die;\$_=<<'e';eval
${_}e
"
e

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

1

आम लिस्प, 10 ¹¹³ -1

(LET ((X
       99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999))
  (WHEN #1=(PLUSP X)
    #2=(SETF *PRINT-CIRCLE* T)
    #3=(PRINT (LIST 'LET `((X ,(1- X))) (LIST 'WHEN '#1# '#2# '#3#)))))

113 निन्यानवे हैं।
अगले कार्यक्रम में 8 के बाद 112 बच्चे हैं
अगले कार्यक्रम में 7 के बाद 112 बच्चे हैं
...

नाइन की संख्या कोड के अधिकतम आकार, 256 द्वारा सीमित है, प्रिंटर द्वारा शुरू किए गए रिक्त स्थान को ध्यान में रखते हुए।

— कोर निपात
स्रोत

1

पर्ल, 1.4 * 10 ^ 225

use bignum;open$F,__FILE__;$_=<$F>;s/0x\w+/($&-1)->as_hex/e;0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff&&print

अजगर के समान दृष्टिकोण; एक ही परिणाम!

— सिकंदर-ब्रेट
स्रोत

0

> <> , 65534 (?) कार्यक्रम

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

":?!;1-r00gol?!;a0.�

आप इसे यहाँ ऑनलाइन आज़मा सकते हैं ।

इस कार्यक्रम का सार यह है कि यह बहुत अंत में चरित्र के उत्पादन को बदलता है और फिर मुद्रण से पहले इसके संख्यात्मक मूल्य को घटाता है। मुझे 65534 प्रोग्राम मिले क्योंकि कोड के अंत में कैरेक्टर की एससीआई वैल्यू 65533 है, इसलिए पहले प्रोग्राम की गिनती हमारे पास 65534 है (यदि आप खाली प्रोग्राम 65535 गिनते हैं, तो मुझे लगता है)। आखिरी कार्यक्रम "लौटा" कुछ भी नहीं है; यह केवल तब समाप्त होता है जब वर्ण मान 0 होता है।

मुझे पूरा यकीन है कि यह सभी पुनरावृत्तियों के लिए एक चरित्र को प्रिंट करने में सक्षम होगा: मैं कितने वर्ण> <> मुद्रित कर सकता हूं, इसके लिए कोई निश्चित स्रोत नहीं मिल सकता है, लेकिन संख्यात्मक रूप से 65533 के नीचे वर्ण हैं।

मुझे बताएं कि क्या इसके कार्यान्वयन में कोई समस्या है; मैं अपनी प्रविष्टि की वैधता के बारे में थोड़ा अनिश्चित हूं।

व्याख्या

मैंने बेशर्मी से> <> विकी और एक टिप्पणी जो मैंने यहां एक बार देखी थी से छद्म-क्वीन बनाने के लिए एकल उद्धरण चिह्न का उपयोग करने के विचार को चुरा लिया है।

":?!;1-r00gol?!;a0.�
"                     begins string parsing
 :?!;                 terminates program if final character is 0, numerically
     1-               decrements final character by 1
       r              reverses stack
        00g           grabs quotation mark (fancy way of putting " ")
           ol?!;      prints and terminates if stack is empty
                a0.   jumps back to o to loop

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

— गोभी
स्रोत

0

पायथन, 1 × 10 ^ 194 कार्यक्रम

n=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
if n:print open(__file__).read().replace(str(n),str(n-1))

यह एक फ़ाइल से चलाया जाना चाहिए, नहीं एक इंटरैक्टिव उत्तर । यह एक क्वीन नहीं है।

@ 3 कछुए को बचाने में मेरी मदद करने के लिए @ कछुए का धन्यवाद, जो कि नाइन के लिए अधिक जगह है!
2 बाइट बचाने में मेरी मदद करने के लिए @poke का धन्यवाद, जो कि नाइन के लिए अधिक जगह है!

— पनीर प्रेमी
स्रोत

@ पनीर प्रेमी if n!=0बेमानी है। आप बस लिख सकते हैं if n।

— कछुए

आप दो स्थानों से भी छुटकारा पा सकते हैं; तर्कों के if n:बीच और बाद में replace।

— प्रहार

0

बैश, 52 कार्यक्रम

पूरी तरह से अनायास, और (उम्मीद) ठोस रूप से अंतिम स्थान पर।

echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo

— क्रिस
स्रोत

एक प्रोग्राम जो प्रिंट्स प्रोग्राम करता है

सीजेएम, 4.56 × 10 526 कार्यक्रम

254 219 + 2 9 4.56 × 10 526 कार्यक्रम

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

254 192 2 5.35 × 10 461 अधिक कार्यक्रम

मूर कार्यक्रम

जावास्क्रिप्ट, 1000 कार्यक्रम

रूबी, 1.628 × 10 ^ 237 कार्यक्रम

रूबी, 9.277 × 10 ^ 90 कार्यक्रम

पायथन 2, 9.7 * 10 ^ 229 प्रोग्राम

सी, 2.2 * 10 ^ 177 कार्यक्रम

पर्ल, 1 × 10 ^ 163

आम लिस्प, 10 113 -1

पर्ल, 1.4 * 10 ^ 225

> <> , 65534 (?) कार्यक्रम

व्याख्या

पायथन, 1 × 10 ^ 194 कार्यक्रम

बैश, 52 कार्यक्रम

सीजेएम, 4.56 × 10 ⁵²⁶ कार्यक्रम

254 ²¹⁹ + 2 ⁹ 4.56 × 10 ⁵²⁶ कार्यक्रम

254 ¹⁹² 2 5.35 × 10 ⁴⁶¹ अधिक कार्यक्रम

आम लिस्प, 10 ¹¹³ -1