अलग-अलग प्रिंटर का उपयोग करके 1 से 15 प्रिंट करें

22

एक बहुमुखी पूर्णांक प्रिंटर बनाना अच्छा है और सभी, लेकिन एक ही कोड लिखना जो बहुत सारे विभिन्न संख्याओं को प्रिंट करता है बोझिल है। क्या ऐसी स्क्रिप्ट बनाना आसान नहीं होगा जो किसी संख्या को आउटपुट करती हो, लेकिन आपको अगली संख्या प्राप्त करने के लिए एक नई स्क्रिप्ट भी देती है?

चुनौती:

एक कोड लिखें जो एकल पूर्णांक Nऔर एक निष्पादन योग्य कोड को आउटपुट करता है । अगला कोड आउटपुट होना चाहिए N+1और एक कोड जो आउटपुट कर सकता है N+2। इस रास्ते को तब तक जारी रखें जब तक आप पहुंच नहीं जाते N = 15। (अंतिम मुद्रित संख्या 15 होनी चाहिए)।

नियम:

  • कोई इनपुट नहीं (मान लें कि इनपुट खाली है)।
  • पूर्ण कार्यक्रम या फ़ंक्शन या अन्य सुविधाजनक प्रारूप की अनुमति है।
  • पहला कोड आउटपुट होना चाहिए 1।
  • आप अग्रणी शून्य उत्पादन नहीं कर सकते। यानी आप मुद्रित नहीं कर सकते 01के लिए 1।
  • आउटपुट प्रारूप पर होना चाहिए N, Code_for_N+1। ध्यान दें कि आउटपुट एक अल्पविराम और एक एकल स्थान द्वारा अलग किया गया है। कोड के N+1पास कोई उद्धरण चिह्न नहीं है। N , Code_for_N+1स्वीकार नहीं किया जाता है (अल्पविराम के सामने स्थान)। अनुगामी newlines ठीक हैं।
  • आउटपुट का पहला वर्ण संख्या होना चाहिए। (कोई अग्रणी स्थान, या ans = N)।
  • मुद्रित संख्या अगले कोड का हिस्सा नहीं होनी चाहिए (कोड में यह संख्या हो सकती है, लेकिन आप कोड के भाग के रूप में आउटपुट नंबर नहीं ले सकते)
    • उदाहरण: इसके लिए आउटपुट N=2हो सकता है 2, printer 2:। इस मामले में, printer 2के लिए कोड है N=3। आप संपूर्ण आउटपुट का उपयोग नहीं कर सकते: 2, printer 2कोड के रूप में N=3।
  • स्क्रिप्ट विभिन्न भाषाओं में हो सकती है
  • डेटाटिप्स अप्रासंगिक हैं (संख्या एक स्ट्रिंग हो सकती है), लेकिन इसे किसी भी चीज (उद्धरण चिह्न, कोष्ठक आदि) से घिरा नहीं जा सकता है।
  • यदि कोई कोड आउटपुट है, N=15तो उसे या तो प्रिंट करना होगा STOP!(बोनस देखें), या बिलकुल भी प्रिंट न करें (स्पेस या लाइनलाइन भी नहीं)।
    • के लिए कोड N=15क्रैश नहीं हो सकता है (लेकिन STDERR के लिए आउटपुट ठीक है)।
    • यदि आप N=15प्रिंट 16या कुछ और (बोनस मामले को छोड़कर) कोड के लिए आउटपुट कोड अयोग्य घोषित कर दिया जाता है ।
  • निर्मित में क्वाइन ऑपरेटरों को अनुमति नहीं है।
  • फ़ाइल सिस्टम के माध्यम से स्रोत फ़ाइल तक पहुँचने की अनुमति नहीं है।

बोनस:

-10 बाइट्स यदि कोड 15 प्रिंट करता है तो एक कोड भी बनाता है जो प्रिंट करता है " STOP!"

पायथन सिंटैक्स का उपयोग करने वाले उदाहरण: (जाहिर है, ये केवल चयनित पूर्णांक के लिए काम करेंगे, 1 से 15. तक नहीं)

N = 1
print "1, print 2"
1, print 2

---
N = 15
print 15
15

---
N = 15   (Qualifies for the -10 bytes bonus)
print "15, print 'STOP!'"
15, print 'STOP!'

print 'STOP!'
STOP!

----

N = 15   (Qualifies for the -10 bytes bonus)
print "15, disp('STOP!')"
15, disp('STOP!')        (disp('STOP!') outputs STOP! in MATLAB)

----
N = 15   (This one is not OK. The submission is disqualified)
print "15, print 16"
15, print 16

मानक गोल्फिंग नियम लागू! बाइट्स जीतने में सबसे छोटा कोड (एन = 1 के लिए)!

code-golf  string 
— स्टीवी ग्रिफिन
स्रोत
तो, कहते हैं, f=>f+""अमान्य होगा? ( f+""फ़ंक्शन का निर्माण कोड लौटाता है।)
— कॉनर ओ'ब्रायन
@ इसके बिना C possibleO'B it, क्या यह कार्य प्राप्त करना भी संभव है ...
— nicael
@nicael यह पहले से ही किया गया है, कम से कम js उत्तर में
— कॉनर ओ'ब्रायन
1
@ C @O'Bʀɪᴇɴ ... व्यवहार्य तरीके से: D
— nicael
नियम भ्रमित कर रहे हैं, क्या मैं कुछ आउटपुट कर सकता हूं 14, print(14+1)या नहीं?
— 15:39 पर nyuszika7h

जवाबों:

39

पायथ + ///, 15 बाइट्स - 10 = 5

pPt`S15", STOP!

यह 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, STOP!पायथ में प्रिंट करके लेता हैrange(1,15+1) शुरू और अंत कोष्ठक से छीन और छीन , और इसके तुरंत बाद ", STOP!"

अगले चौदह कार्यक्रम /// में हैं, जो सीधे उन सभी कार्यक्रमों को आउटपुट करते हैं जिनमें शामिल नहीं हैं /या \। तो दूसरा कार्यक्रम

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

देता है 2और तीसरा कार्यक्रम 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15। दंडात्मक कार्यक्रम, 15, STOP!प्रिंट 15, STOP!, अंतिम कार्यक्रम है STOP!।

— lirtosiast
स्रोत
3
चीकी। मुझें यह पसंद है। :)
— मार्टिन एंडर
क्या catभाषा के रूप में गिना जाता है?
— 11:25
@ मिनीबिस प्राणिकता catपरीक्षण नहीं करता है, इसलिए नहीं।
— 14:
1
कार्यक्रम # 2 और ऊपर भी PHP में काम करते हैं। :)
— इल्मरी करोनें
31

जावास्क्रिप्ट, 131238 - 10 = 131228 बाइट्स

अनुभवहीन दृष्टिकोण उम्मीद से बदतर निकला। अधूरेपन में मुझे इसकी उम्मीद करनी चाहिए थी। लेकिन मुझे लगा कि मैं इसे वैसे भी साझा करूंगा। यहां पूरा कोड ।

विचार: Iteratively भागने और जोड़ने N-1, ... 

alert("14,alert(\"15, alert(\\\"STOP!\\\")\")")
— flawr
स्रोत
7
मुझे लगता है कि पीपीसीजी के किसी भी उत्तर में यह सबसे अधिक बैकस्लैश है।
— lirtosiast
1
मैं मानता हूँ कि इस के लिए NP ++ और regex का उपयोग किया गया है =)
— त्रुटी
19
Haha, यह -10 बहुत मदद करता है: D
— nicael
2
मैंने थोड़ा कम भोली 87573-बाइट समाधान बनाया है ।
— लीजनमोनमल 978
आप बिना बोनस के कुछ बाइट्स बचा सकते हैं।
— Rɪᴋᴇʀ
8

सीजेएम, 26 25 24 बाइट्स

1{", "2$)@"_~"](_F<@*}_~

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

बाद के कार्यक्रमों में पहले नंबर की वृद्धि हुई है। यह 16 बार कार्यक्रम चलाता है।

या उसी स्कोर के लिए बोनस के साथ:

1{", "\2$)_G<\@`+"_~"+"STOP!"`?}_~

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

बाद के कार्यक्रमों में पहले नंबर की वृद्धि हुई है। यह 16 बार कार्यक्रम चलाता है।

बोनस के लिए वैकल्पिक समाधान:

1{", "\2$)Gmd@`+"_~"+"STOP!"`\?}_~
— मार्टिन एंडर
स्रोत
2
@FryAmTheEggman cjam.tryitonline.net/ इस कार्यक्रम को एनकोड करने के लिए बेस 64 का उपयोग करता है, जो पोस्टमाँलिंक को टिप्पणियों में थोड़ा आसान बना देता है। </selfpromotion>
— डेनिस
@ डेनिस धन्यवाद, यह थोड़ा सिरदर्द था: पी लुक्स जैसे कि मार्टिन ने अपना लिखा, वैसे भी।
— फ्राईअमईएग्गमैन
@FryAmTheEggman के बाद ही मैंने आपका लिंक देखा, हालांकि सुझाव के लिए धन्यवाद। ;)
— मार्टिन एंडर
7

जावास्क्रिप्ट (ईएस 6), 62 61 बाइट्स - 10 बोनस = 51 स्कोर

_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)

व्याख्या

एक समाधान जो यह नहीं पढ़ता है वह स्वयं का सोर्स कोड है और यह हास्यास्पद रूप से लंबा नहीं है।

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

_=>
  "1, "                // print the first number
  +(f=n=>`_=>"`+(      // f = recursive function for printing program N
    n<16?              // for programs 2 - 15:
      n+`, "+(${       // add N to the output of the nested function
        f(n+1)         // nest the code of program N + 1
      })`
    :`STOP!"`          // program 16 just outputs "STOP!" for the bonus
  ))(2)                // start from program 2

परीक्षा

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

— user81655
स्रोत
1
एक फंक्शन के बॉडी पाने के लिए जावास्क्रिप्ट के बिल्ट-इन फीचर का इस्तेमाल नहीं करने के लिए +1 (क्विनिंग के लिए ग्रे एरिया)
— 02 JavaScript
2
@Callodacity "" + (n=>m)फ़ंक्शन के शरीर को प्राप्त करने के रूप में कैसे नहीं गिना जाता है n=>m?
— नील
@ नील वास्तव में आप सही हैं इसकी गिनती होती है - मैंने इस बात को नजरअंदाज कर दिया था कि चूंकि मैं केवल कार्यक्रम 1 को देख रहा था और आउटपुट के माध्यम से नहीं गया था
— A output
सभी बैकस्लैश कहां गए !?
— Noodle9
5

मतलाब, 226 212 - 10 = 202 बाइट्स

कुछ बाइट्स के लिए @StewieGriffin को धन्यवाद =)

'awFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)

पहला भाग एक स्ट्रिंग है जो दूसरी पंक्ति (नीचे), वास्तविक कोड (सिर्फ 9 द्वारा स्थानांतरित) का प्रतिनिधित्व करता है। मतलाब में, तार पात्रों से भरे हुए होते हैं, इसलिए आप आसानी से एक अदिश को जोड़ / बदलकर पारियों का प्रदर्शन कर सकते हैं। तो कार्यक्रम बस एक ही स्ट्रिंग * फिर से, एक ही स्ट्रिंग बाहर निकालता है, लेकिन कोड में जिसके परिणामस्वरूप स्थानांतरित कर दिया।

* बिल्कुल नहीं: पहला बाइट काउंटर है जिसे प्रत्येक पुनरावृत्ति में बढ़ाने की आवश्यकता है।

स्ट्रिंग के साथ रानी चाल को बेशर्मी से यहाँ से चुराया गया था ।

'awFjw|Dro)w1:26B?G:>DwF0\}xy*0Dnu|nDwFdw~v;|}{1w1:26B?2505)05<B5w1:24:5w1;Cnwm25<B5>B5w1;Cnwm26B500fDnwmDmr|y1w2';
n=ans;if n(1)-96>15;n='Stop!';else;n=[num2str(n(1)-96),', ',39,n(1)+1,n(2:end),39,59,n(2:end)-9,''];end;disp(n)

यहाँ कंसोल से कॉपी किए गए अनुक्रम की अंतिम कुछ पंक्तियाँ हैं:

>> 'mwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
13, 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
14, 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
15, 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
STOP!
— flawr
स्रोत
5

जावास्क्रिप्ट, 50 47 44 42 44 * बाइट्स

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1)

यह एक ऐसा फंक्शन है जो अपने शरीर (सिर्फ a) को निकालता है और इसमें प्रतिस्थापन करता है। फ़ंक्शन बॉडी प्राप्त करना जावास्क्रिप्ट की एक अंतर्निहित सुविधा है, हालांकि स्पष्ट रूप से एक क्वीन ऑपरेटर नहीं है (यदि यह अमान्य है, तो उत्तर हटा देगा)।

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1);
alert(a());
स्निपेट का विस्तार करें

मामले में यह ठीक से वहाँ काम नहीं करता है (क्योंकि मेरे लिए यह नहीं है), आप वहाँ एक उदाहरण देख सकते हैं ।

* - ऐसा लगता है कि स्निपेट बिना परिणाम का उत्पादन करता है a=, जिससे आगे की कॉल असंभव हो जाती है

— nicael
स्रोत
1
"फंक्शन बॉडी पाने के लिए एक बिलियन फीचर" एक क्वीन ऑपरेटर के समान नहीं है? मैं यह नहीं कह रहा हूं कि यह अमान्य है, मैं बस सोच रहा हूं कि अंतर क्या है?
— स्टेवि ग्रिफिन
मैं सिर्फ एक पर काम कर रहा था। o_o क्या आप नहीं कर सकते .replace(x++,x)?
— कॉनर ओ'ब्रायन
3
@StewieGriffin क्वीनिंग के लिए बनाए गए अन्य, एक वैध विशेषता है।
— कॉनर ओ'ब्रायन
@Stewie लेकिन "क्वीन ऑपरेटर" पूरे प्रोग्राम को वापस करने के लिए माना जाता है, जबकि मेरे उदाहरण में यह क्वीन बनाने के उद्देश्य के बिना एक फ़ंक्शन को पुनः प्राप्त करता है (पूरे प्रोग्राम कोड को वापस करने के लिए कोई अंतर्निहित नहीं है)। जैसा कि आपने फ़ंक्शन की अनुमति दी है, हालांकि यह समान हो सकता है, इसलिए मैं सोच रहा था।
— निकेल
a=_=>(x=1)+(x<15?`, ${a}`:"").replace(x,x+1)काम करता है ?
— कॉनर ओ'ब्रायन
5

पायथन 2.7.10, 196 92 - 10 = 82 बाइट्स

व्ही !!! यह मजेदार था। अभी बहुत कम है। : पी

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

स्पष्टीकरण:

मैंने इसकी शुरुआत की:

a='a=%r;print a%%a';print a%a

वह सिर्फ एक साधारण रानी है। यह है कि एक काउंटर के साथ जोड़ा गया:

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)';print n,a%(n+1,a)

nएक काउंटर वैरिएबल है जो शुरुआत में छपा होता है। फिर जब इसका n=भाग प्रिंट करता है , तो यह भाग के n+1लिए विकल्प देता है %d। तो यहाँ से यह असीम रूप से गिना जाएगा।

और यहाँ अंतिम संस्करण है। यह 15 पर रोकने के लिए एक अगर क्लॉज जोड़ता है, और "STOP!" भी।

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

पुराना कोड:

a= ['if num==15:print"STOP!!!";exit()','print num','print"a=",a','print"num=",num+1', 'for s in a:print s']
num= 1
print num
if num==15:print"STOP!!!";exit()
print"a=",a
print"num=",num+1
for s in a:print s

जीतने के लिए कभी नहीं, लेकिन मज़ा। : पी बहुत छोटा है, हालांकि मैं अभी भी एक मौका नहीं है। : पी

— Rɪᴋᴇʀ
स्रोत
वाह। क्या आप एक स्पष्टीकरण जोड़ सकते हैं क्योंकि यह अच्छा है लेकिन मुझे पता नहीं है कि क्या चल रहा है: D
— Sherlock9
@ शर्लक 9 किया। सराहना करने के लिए धन्यवाद।
— R
अगर मैं इसे काटता हूं और एक इंटरेक्टिव अजगर 2.7.6 सत्र में पेस्ट करता हूं, तो यह शिकायत करता है कि elseएस से पहले कोई स्थान नहीं है ।
— eric
@eric मैं अजगर का उपयोग कर रहा हूँ 2.7.10 और यह मेरे लिए काम करता है ...
— R '
3

पावरशेल , (215-10) = 205 197 167 106 104 103 बाइट्स

$d='$c=(,1*{2}).count;$d={0}{1}{0};(("$c, $d"-f[char]39,$d,($c+1)),$c)[$c-eq15]';"1, $d"-f[char]39,$d,2

(यदि आपका एकमात्र उपकरण PowerShell है, तो हर समस्या एक कील की तरह दिखती है। रुको ...)

मूल रूप से, हम मूल कोड के लगभग$d एक बड़े-लम्बे-लम्बे तार के बराबर सेट करने के साथ शुरू करते हैं । यह आउटपुट और फिर प्रारूप ऑपरेटर के साथ ठीक से स्थापित करने के लिए , , खड़े-इन, incrementing में नंबर एक हर बार अनुभाग।1$d-f{0}{1}{2}{2},1*{2}

,x*yPowerShell में ऑपरेशन की एक नई सरणी बनाता yआइटम, जिनमें से प्रत्येक के बराबर है x। उदाहरण के लिए, ,2*3के बराबर है@(2,2,2) ।

इसका अर्थ है, पहला आउटपुट होगा 1, $c=(,1*2).length;$d=(etc...), इसलिए जब दूसरा कोड निष्पादित किया जाएगा , तो $cसरणी की गिनती के बराबर होगा @(1,1), या 2, आदि। नोट जो $cमूल कोड में एक चर के रूप में उपयोग नहीं किया जाता है, बस बाद के रनों में।

बंद हो जाता है जब यह 15 की गणना करता $cहै कि क्या बराबर होता है 15और फिर एक सरणी में अनुक्रमित होता है, तो 0 तत्व $c, $dजैसा कि ऊपर वर्णित है, अन्य बस है 15। इस प्रकार, जब $c15 वर्ष का होता है, तो यह आउटपुट 15और कुछ नहीं होगा। बोनस के लिए अर्हता प्राप्त नहीं करता है, क्योंकि "15, {0}STOP!{0}"-10 सार्थक होने के लिए 5 अक्षर बहुत लंबे हैं।

चौड़ाई के एक PowerShell टर्मिनल की आवश्यकता है> ~ 150। या आपके लिए अतिरिक्त लाइनब्रेक को मैन्युअल रूप से हटाने के लिए (कि टर्मिनल सहायक रूप से उत्पादन चादर पर डालता है) जब कॉपी-पेस्ट कोड। या आप एक चर में उत्पादन पर कब्जा करने के लिए और फिर उस चर को फिर से निष्पादित करें। आदि।

संपादित करें 1 - "रोक" को हटाकर कुछ बाइट्स सहेजे गए! शब्दों।
संपादित करें 2 - Durr, हर बार उपयोग न करें। बस इसे एक बार कॉल
करें 3 संपादित करें - एक क्वीन होने की आवश्यकता नहीं है, इसलिए प्रारंभिक रन बहुत छोटा हो सकता है
संपादित करें 4 - स्ट्रिंग्स का उपयोग करने से बदला गया सरणियों की गणना करने के लिए $c, जिसने दो बाइट्स को बचाया। मुझे पूरा यकीन है कि यह इस दृष्टिकोण के लिए लगभग इष्टतम है।
5 संपादित करें - मोडिंग के बजाय सीधे समानता की गिनती करके एक और बाइट को बचाया

— AdmBorkBork
स्रोत
विंडोज 10 कंसोल विंडो अब आउटपुट रैप लाइनब्रेक की प्रतिलिपि नहीं बनाती है।
— नील
2

जावास्क्रिप्ट, 79 - 10 = 69 बाइट्स

s='STOP!';for(i=15;i;){s=i--+',alert("'+s.replace(/[\\"]/g,"\\$&")+'")'};alert(s)

Function.prototype.toStringकिसी भी तरह से उपयोग किए बिना ।

— नील
स्रोत
2

Befunge, 57 - 10 = 47 बाइट्स

1:'!`'#*j:.',,1+:9`''*'0++,1#;:0g:48*`j@,1+;"!POTS",,,,,@

यह एक कमाल है। इसे यहाँ आज़माएँ ।

— MegaTom
स्रोत
The right casing for the stop message is STOP!
— user48538
@zyabin101 fixed.
— MegaTom
2

Batch, 73 + 5 - 10 = 68 bytes

@set a=STOP!
@for /l %%a in (15,-1,1)do @set a=%%a, @echo !a!
@echo %a%

Requires CMD /V:ON so I added 5 bytes for that.

— Neil
स्रोत
2

Python 2.7, 107 characters

By using recursion and not writing a quine, I thought I could save a lot, which is true, but not good enough. Although not a winner, I think the approach is fun to share.

I started by making up a string for N=4, escaping the \ and " characters.

print "1, print \"2, print \\\"3, print \\\\\\\"4, print \\\\\\\\\\\\\\\"STOP!\\\\\\\\\\\\\\\"\\\\\\\"\\\"\""

Then I created a lambda function that creates this string, based on a start index and a stop index, using recursion. This is it:

l=lambda n,m:str(n)+", print "+"\\"*(2**(n-1)-1)+"\""+l(n+1,m)+"\\"*(2**(n-1)-1)+"\"" if n<m else "STOP!"

Use it like this:

print l(1,15)

Output: [32902 characters, too long to handle]

So, it seems that my kolmogorov complexity approach isn't that successful ;-)

— agtoever
स्रोत
2

SMBF, 28 bytes

\x10 represents a literal byte (decimal value 16). The integer is output as an integer (byte). So the first character output is \x01. The program then prints ", ". When printing its own source, it prints an extra + at the beginning.

+.<-<<.>.>[[<]>.[.>]<[-]], \x10

Explanation:

+.                                  Increment number and print
  <-                                Pre-decrement loop counter
    <<.>.>                          Print comma and space from own source
          [             ]           Only execute if loop counter != 0
           [<]>.                    Move to left of source, then print `+`
                [.>]                Print entire source.
                    <[-]            Zero out the loop counter so this program halts.
                         , \x10     The comma, space, and loop counter used earlier.
                                    Input is empty, so `,` doesn't do anything.

Note that you cannot run this in a standard interpreter because it requires a hex literal in the input. You also need a special terminal for hex output to work properly.

— mbomb007
स्रोत
1

Bash, 78 74 73 - 10 = 63 bytes (Example, can't win)

p='if(($((++a>15))));then unset a p;fi;echo ${a-STOP\!}${p+, $p}';eval $p

Coming in late, but saw bash hadn't been tried so gave it a go. First gulf challenge and quine-like puzzle. They're fun!

Explanation:

This works because a steps from 1 to 15 and is then unset along with p. The script (stored in p) prints them both out if they're set and "STOP!" otherwise. The initially unset a is set to 0 because it appears in an arithmetic expansion.

— Noodle9
स्रोत
1

𝔼𝕊𝕄𝕚𝕟, 30 chars / 47 bytes (non-competitive)

⟮a=1)+(a<ḏ?⬬+ⒸⅩ222+ᶈ0:⬯)ē(a,⧺a

Try it here (Firefox only).

Finally found a good ol' true quine for 𝔼𝕊𝕄𝕚𝕟.

Explanation

Here's the true quine that I used: ⟮ⒸⅩ222+ᶈ0

You see it in my answer? Hopefully, y'all will be able to expand from there.

— Mama Fun Roll
स्रोत
1

Keg+PHP, 19-10=10 bytes

ï_(. \,,,)\!POTS(,

Counts from 1 to 15 and then stops. TIO

Keg, 13 bytes

ï_(. \,,,).
— A̲̲
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.