चक नॉरिस ने अनंत को गिना। दो बार

चक नॉरिस पीछे की ओर अनंत तक गिना जा सकता है।

इसके अलावा, हालांकि शायद कम ज्ञात है, चक नॉरिस अंग्रेजी के अलावा थोड़ा स्पेनिश बोल सकता है ।

चुनौती

एक प्रोग्राम (या फ़ंक्शन) लिखें जो दो अलग-अलग भाषाओं में चलाया जा सकता है। एक भाषा में कार्यक्रम को अनुक्रम का उत्पादन करना चाहिए

1, 1, 2, 2, 3, 3, 4, 4, ...

और दूसरी भाषा में इसे अनुक्रम उत्पन्न करना चाहिए (अग्रणी शून्य सहित)

1, 2, ..., 9, 01, 11, 21, 31, ..., 89, 99, 001, 101, 201, ...

नियम

प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा में । मानक खामियों को मना किया जाता है।
एक ही भाषा के विभिन्न संस्करण (जैसे कि पायथन 2/3) विभिन्न भाषाओं में नहीं गिने जाते हैं। संबंधित भाषाएं (जैसे C / C ++ या Matlab / Octave) अलग-अलग होती हैं।
कोई इनपुट नहीं लिया जाएगा।
उपयोगकर्ता द्वारा रोके जाने तक कार्यक्रम को अनुक्रम की आउटपुट शर्तों को जारी रखना चाहिए। चूंकि कार्यक्रम अपने आप बंद नहीं होगा, इसलिए आउटपुट अंत में उत्पादित नहीं किया जा सकता है। इसका उत्पादन तब किया जाना चाहिए जब प्रोग्राम चलता है, या तो लगातार या बैचों में।
आउटपुट STDOUT या समकक्ष का उपयोग कर सकता है, या ग्राफिक विंडो में प्रदर्शित किया जा सकता है। अनुक्रम शब्दों के बीच किसी भी गैर-संख्यात्मक विभाजक को अनुमति दी जाती है, जब तक कि प्रत्येक शब्द को उसके पड़ोसी शब्दों से स्पष्ट रूप से अलग किया जा सकता है। अगर स्क्रीन को शब्दों के बीच साफ किया जाए तो यह स्वीकार्य भी है।
या तो अनुक्रम के 0बजाय शुरू कर सकते हैं 1। उस मामले में, "दो बार" अनुक्रम 0में अन्य संख्याओं की तरह, दोहराया जाना चाहिए।
"बैकवर्ड" अनुक्रम में अग्रणी शून्य महत्वपूर्ण हैं। उदाहरण के लिए, दसवां शब्द है 01; न तो 1है और न ही 001स्वीकार्य हैं।
यदि दो भाषाएं अलग-अलग वर्ण एन्कोडिंग का उपयोग करती हैं, तो कार्यक्रम को इसके बाइट्स द्वारा परिभाषित किया जाता है , न कि इसके पात्रों द्वारा। अर्थात्, बाइट्स दो भाषाओं में समान होनी चाहिए।
बाइट्स में सबसे छोटा कोड जीतता है।

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

8

डाउनवोटर्स, सुधार के लिए कोई सुझाव?

— लुइस मेंडो

29

चक नॉरिस गिनती के लिए बहुत शक्तिशाली है, अगर उसने किया, तो पहली संख्या वह गिनता है जो अनंत से अधिक होगी और ज्ञात गणित के दायरे को चकनाचूर कर देगा। इसलिए, मैं प्रतिस्पर्धा करने से इनकार करता हूं।

— मैजिक ऑक्टोपस Urn

11

@carusocomputing, बहुत बुद्धिमान ने दुनिया भर में पुश-अप की कमी को देखते हुए चक नॉरिस ने उन सभी को किया।

— वॉसनाम

33

चक नॉरिस इस चुनौती को 0 बाइट्स में पूरा कर सकते हैं। वह सिर्फ कंप्यूटर को देख सकता है और कंप्यूटर जो चाहे वह करता है।

— कोडोस जॉनसन

17

चक नॉरिस ने इस चुनौती को जीतने की कोशिश नहीं की, उन्होंने आपको हारने की अनुमति दी।

— Nat

18

05AB1E / जेली , 14 13 बाइट्स

अदनान के लिए -1 बाइट धन्यवाद (गैर-पॉपिंग प्रिंट के साथ तीन प्रतियों से बचें)

कच्चे बाइट्स (हेक्साडेसिमल):

31 5b 3d 3d 3e 5d fc 06 b6 3b 87 08 15

में 05AB1E के कोड-पेज :

1[==>]üε¶;‡ηΩ

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

में जेली के कोड-पेज :

1[==>]‘©Ṛ;⁷®ß

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

कैसे?

05AB1E कार्यक्रम नई पंक्तियों द्वारा अलग प्रत्येक प्रविष्टि के साथ डबल गिनती प्रिंट:

1[==>]üε¶;‡ηΩ
1             - push 1 onto the stack
 [            - start infinite loop:
  =           - print top of stack
   =          - print top of stack
    >         -   increment the top of the stack (pop(1), x+=1, push)
     ]        - end the infinite loop
      üε¶;‡ηΩ - this code is never executed nor is it parsed

जेली कार्यक्रम नई पंक्तियों द्वारा अलग प्रत्येक प्रविष्टि के साथ उलट गिनती प्रिंट करता है।

पार्सर संलग्न शाब्दिक के बीच [और के ]रूप में एक मान्य शाब्दिक व्यवहार करेगा , अन्यथा ये बाइट्स अपरिभाषित टोकन हैं और जैसे कि कोड में लाइनों को अलग करने वाले टोकन के बराबर हो जाते हैं। ==>शाब्दिक के रूप में पार्स नहीं करता है, इसलिए कोड प्रभावी है:

1 - link 1 (not executed but parsed)
1 - literal 1

==> - link 2 (not executed but parsed)
=   - left equals right? (vectorises)
 =  - left equals right? (vectorises)
  > - is greater than the right argument? (vectorises)

‘©Ṛ;⁷®ß - Main link: no arguments
‘       - increment (implicit 0 on left increments to 1 on the first pass)
 ©      - copy the result to the register and yield it
  Ṛ     - reverse, this has an implicit decimal list build, e.g. 142 -> [2,4,1]
    ⁷   - a newline character
   ;    - concatenate, e.g. [2,4,1] -> [2,4,1,'\n']
     ®  - recall the number from the register, e.g. 142
        - The chain has reduced to one item of arity 0, causing a pre-evaluation print:
        -     ...and since the list contains a character it gets smashed together
        -     e.g. [2,4,1,'\n'] prints 241 followed by a newline character
      ß - call this link with the same arity, e.g. as a monad with left = 142

— जोनाथन एलन
स्रोत

मैं जाँच की है नहीं अगर यह जेली के लिए काम करता है, लेकिन अगर यह काम करता है, तो आप की जगह ले सकता Ð,,से ==।

— अदनान

कि जेली में पार्स करना चाहिए। मैंने गैर-पॉपिंग प्रिंट के लिए info.txt में देखा था, और यह नहीं देखा। धन्यवाद।

— जोनाथन एलन

26

पायथन 2 / सी (क्लैंग) , 109 107 100 84 95 88 89 88 87 84 बाइट्स

i=0;
#/*
while 1:i+=1L;print`i`[::-1]
'''*/
a(){for(;;)printf("%i %1$i ",++i);}//'''

अजगर: यह ऑनलाइन कोशिश करो!

C: यह ऑनलाइन कोशिश करो!

पायथन कोड में एल सीमांकक का हिस्सा है।

स्पष्टीकरण:

C कोड में, यह पहले i से 0. पर सेट होता है, फिर यह एक टिप्पणी शुरू करता है ( बयानों के #लिए C में मान्य कोड है #include) जहां पायथन कोड जाता है। टिप्पणी के अंत में, यह एक फ़ंक्शन को परिभाषित करता है जो हमेशा एक चर को बढ़ाता है और इसे दो बार प्रिंट करता है, स्पेस-सीमांकित। इसके बाद एक टिप्पणी शुरू होती है।

पायथन कोड में, i=0;मैं शून्य पर सेट करता हूं। पायथन अगली पंक्ति की उपेक्षा करता है क्योंकि #एकल-पंक्ति टिप्पणी शुरू करता है। फिर यह हमेशा के लिए इसे बढ़ाता है और इसे एक लंबी संख्या में बदल देता है और इसके उल्टे स्ट्रिंग प्रतिनिधित्व को प्रिंट करता है। लंबे समय से 'एल' सीमांकक का हिस्सा है। उसके बाद, यह सी कोड टिप्पणी करने के लिए एक बहु-पंक्ति स्ट्रिंग शुरू करता है, जो बाद में समाप्त होता है।

-2 बाइट्स @LuisMendo को धन्यवाद। -7 बाइट्स @ZacharyT को धन्यवाद। -6 और बाइट्स @ZacharyT की बदौलत। +11 बाइट्स @ mbomb007 के लिए एक बग को ठीक करने के लिए। -7 बाइट्स @Doorknob को धन्यवाद। +1 बाइट को @Doorknob की बदौलत बग ठीक करने के लिए। -1 बाइट @ @ यान को धन्यवाद। -1 और बाइट @yoann को धन्यवाद। -3 बाइट्स @Cyoce को धन्यवाद।

— कॉमरेड स्पार्कलपनी
स्रोत

हम्म, मुझे लगता है कि आप सी कोड में प्रत्यावर्तन इस्तेमाल कर सकते हैं -a(i){printf("%i %i ",i,i);a(i+1)}

— enedil

whileसी कोड के लिए लूप का उपयोग क्यों नहीं किया जाता है?

— enedil

@enedil यह अधिक बाइट्स लेता है।

— कॉमरेड स्पार्कलपनी

मुझे लगता है कि आप `i`इसके बजाय का उपयोग कर सकते हैंstr(i)

— साइओस

आप for(;;)printf("%i %1$i ",i++);एक बाइट को बचाने के लिए उपयोग कर सकते हैं । 1$एक है स्थितीय तर्क है कि बताता है printf(प्रारूप स्ट्रिंग के बाद) पहला तर्क प्रदर्शित करने के लिए।

— योना

12

जेली / पायथ, 15 बाइट्स

.V1_`b;"1üÉÉ$

Unprintables एसई सॉफ़्टवेयर द्वारा मंगाई गई हैं, इसलिए यहां एक हेक्सडंप है:

00000000: 2e56 315f 6062 3b22 7f31 fcc9 c924 0b    .V1_`b;".1...$.

साथ दौड़ो jelly f fileऔर pyth fileक्रमशः ।

व्याख्या

सबसे पहले पायथ भाग आता है। .Vअपने इनपुट से शुरू होने वाले इंक्रीमेंट क्रम पर एक अनंत लूप चलाता है, जो यहां है 1। फिर हम _कड़े ( `) लूप इंडेक्स ( b) और उल्टे इसे आउटपुट करते हैं। ;पाश समाप्त करने के लिए है, और" एक स्ट्रिंग शाब्दिक ताकि पार्सर उस पर गला घोंटना नहीं है के रूप में कार्यक्रम के बाकी का इलाज करने के लिए आवश्यक है।

जेली भाग को जेली कोडपेज से शेष कार्यक्रम के पहले अनुवाद द्वारा समझाया जाएगा:

¶1‘ṄṄ$¿

¶एक लाइन फ़ीड के रूप में कार्य करते हैं, प्रभावी रूप से यह एक कड़ी है कि कभी नहीं कहा जाता बनाकर कार्यक्रम के पहले भाग की अनदेखी। फिर हम शुरू करते हैं 1और थोड़ी देर के लूप ( ¿) का उपयोग करते हैं ṄṄ$(दो बार प्रिंट करते हैं) इसकी स्थिति के रूप में, और वेतन वृद्धि ( ‘) लूप बॉडी के रूप में मान।

संयोग से, अजगर के हिस्से को बदलने के साथ 14 बाइट्स में एक वैध जेली / 05AB1E जमा 1[DR,>] करना होगा , लेकिन वर्तमान इंटरपीटर में एक बग होता है जो इसे रोकता है।

— Doorknob
स्रोत

1

@JonathanAllan आप सही हैं, यह मेरे पाठ संपादक द्वारा जोड़ी गई अनुगामी नई पंक्ति थी।

— दरवाज़े

11

पर्ल / जावास्क्रिप्ट, 87 बाइट्स

s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}

पर्ल

s/0;print/console.log;m/s;$_=s/s/s/m;while(++$_){print((/s,$_+`
`+$_||/&&reverse.$/))}

एक तंत्र मैं जे एस / पर्ल polyglots में एक बहुत उपयोग किया है तथ्य यह है कि प्रतिस्थापन में ऐसी हर सीमांकक स्वीकार कर सकते हैं दुरुपयोग, उपयोग कर रहा है =इसका मतलब है मैं प्रारंभिक व्यर्थ प्रतिस्थापन का उपयोग कर सकते है (पहले की जगह 0;printके साथ console.log;mकी एक ध्वज के साथ /sमें $_, जो वर्तमान में है undef) , फिर मल्टीलाइन मोड ( ) के साथ $_बदलने के परिणाम के लिए सेटिंग , जो है । अब है और मैं लूप शुरू करता हूं , इसके बाद वेतन वृद्धि । अगले मैं कॉल करता हूं , एक नियमित अभिव्यक्ति में गुजरता है जो मेल खाता है ( अंत में जो एक खाली स्ट्रिंग से मेल खाता है) और ऑपरेटर का उपयोग करके एक नई रेखा के साथ समाप्‍त होने का रिवर्स भेजते हैं (ss/m0$_0while$_print||&&$_$/से आरंभिक है "\n")। यह अनंत को पीछे की ओर गिनता है।

जावास्क्रिप्ट

s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}

यहाँ पर पर्ल असाइनमेंट में बहुत सारे वेरिएबल असाइनमेंट हैं s///। मैं चर की स्थापना की sऔर mके रूप में 0, उर्फ console.logकरने के लिए print, कुछ व्यर्थ विभाजन चलाने के लिए, सेट $_करने के लिए 0और शुरू whileपाश incrementing $_, फोन printमें गुजर 0( m/s, इस के लिए कॉल शुरू होता है mपर्ल में है, लेकिन जे एस में मानक विभाजन के रूप में व्यवहार किया जाता है) और हमारे लक्ष्य स्ट्रिंग ( $_+"\n"+$_) अल्पविराम ऑपरेटर के माध्यम से, जो सूची में अंतिम आइटम लौटाता है। मैं पर्ल कोड के अंतिम टुकड़े से बचता हूं ( &&reverse.$/) क्योंकि $_+"\n"+$_सत्य होगा और इसलिए मैं पर्ल कोड के अंत वाली वस्तु का ||उत्पादन करने के लिए उपयोग कर सकता हूं RegExpजिसका कभी मूल्यांकन नहीं किया जाता है।

पर्ल 5 और नोड 6 का उपयोग करके परीक्षण किया गया।

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

8

NodeJS / PHP, 131 106 बाइट्स

-25 बाइट्स @ थिट्स के लिए धन्यवाद

<!--
printf=(_,i)=>process.stdout.write(i+i),strrev=i=>i+" "//--><?
for($i=0;;)printf("%s ",strrev($i++));

बेहतर आउटपुट स्वरूपण और बेहतर अनंत लूप हैंडलिंग के लिए ब्राउज़र JS के बजाय NodeJS का उपयोग करना।

जावास्क्रिप्ट का
प्रयास करें ऑनलाइन PHP का प्रयास करें

ध्यान दें कि 128KB के बाद TIO आउटपुट कट जाता है।

— जस्टिन मेरिनर
स्रोत

1

102 बाइट्स 0 पर शुरू <?←for($i=0;;)printf("%s ",strrev($i++));:। 84 बाइट्स (लेकिन आपके दृष्टिकोण के रूप में आधा अच्छा नहीं): <?for(;;)echo strrev(++$i),_;या <?for(;;)echo strrev(++$i),_;।

— टाइटस

@ टिट्स i>>1नंबर दोहराने के लिए अच्छा विचार है , लेकिन मुझे write(i)एक स्पेस को शामिल करने के लिए बदलना पड़ा , और क्योंकि write()वह नंबर स्वीकार नहीं करता है। और आपके पास एक टाइपो ( strrev=i=i>>1-> strrev=i=>i>>1) था जिसने एक और बाइट जोड़ी। समाप्त करने के लिए छोटा किया जा रहा है write(i+i)और strrev=i=>i+" "।

— जस्टिन मेरिनर

7

वी / ब्रेन-फ्लैक क्लासिक , 27 , 26 बाइट्स

(()){[[({}())[]]]}é1òÙæ_æ

Hexdump:

00000000: 2828 2929 7b5b 5b28 7b7d 2829 295b 5d5d  (()){[[({}())[]]
00000010: 5d7d e931 f2d9 e65f 01e6                 ]}.1..._..

इसे ऑनलाइन आज़माएं! V में (थोड़ा संशोधित किया गया है ताकि यह समाप्त हो जाए ताकि आप आउटपुट देख सकें। TIO पर, V केवल आउटपुट देता है यदि प्रोग्राम समाप्त हो जाता है)

इसे ऑनलाइन आज़माएं! ब्रेन-फ्लैक क्लासिक में

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

वी स्पष्टीकरण:

é1              " Insert a '1'
  ò             "   Recursively:
   Ù            "   Duplicate this number
    æ_          "   Flip this line
      <C-a>     "   Increment the number on this line
           æ    "   Flip it back (the '_' is implicit because it's at the end of the program)

BFC स्पष्टीकरण:

#Push a one onto the main stack
(())

#Forever:
{

  #Print twice:
  [[

    #Increment the top of the stack.
    #Evaluates to *i + 1*
    ({}())

    #Minus one
    []
  ]]

#Endwhile
}

— DJMcMayhem
स्रोत

3

जैसे ही मैंने उन भाषाओं को देखा जिन्हें मैं जानता था कि आपने इसे पोस्ट किया है।

— रिले

यह "ब्रेन-फ्लैक क्लासिक" क्यों है? क्या एक अलग ब्रेन-फ्लैक है?

— nmjcman101

@ nmjcman101 ब्रेन-फ्लैक क्लासिक ब्रेन-फ्लैक का मूल संस्करण था। अंतर को यहां और अधिक विस्तार से समझाया गया है , लेकिन मैंने इसे उठाया इसका कारण यह है कि इसमें स्पष्ट आउटपुट है, जो आधुनिक मस्तिष्क-फ्लैक नहीं करता है। (अनंत उत्पादन के लिए अनुमति)

— DJMcMayhem

4

रेटिना / पायथन 2, 61 बाइट्स

#{*M`
#*M`
"""

}`$
1
""";i=1
while 1:print str(i)[::-1];i+=1

रेटिना | अजगर २

— mbomb007
स्रोत

मैंने str()`` के साथ बदलने की कोशिश की , लेकिन स्पष्ट रूप से रेटिना कोड को परेशान किया। मुझे नहीं पता क्यों?

— अधिकारिक

आप वैसे भी ऐसा नहीं कर सकते। यदि यह बड़ी संख्या में बनाने जा रहा है और ठीक से काम कर रहा है, तो यह होना ही चाहिए str, अन्यथा आपको Lपरिणाम मिलेंगे । लेकिन यह वास्तव में रेटिना में काम करता है । आपने जो कहा था, उससे कहीं अधिक बदल दिया होगा, जैसे किसी अलग रेखा पर कुछ हिलाना।

— mbomb007

3

आर / ऑक्टेव , 83 80 78 71 बाइट्स

-3 बाइट्स लुइस मेंडो की बदौलत

i=0;
while(1)
#{
print(c(i<-i+1,i))
#}
disp(flip(num2str(i)))
i+=1;
end

#{ }#एक ऑक्टेव ब्लॉक टिप्पणी है और #ऐसा केवल आर के लिए टिप्पणी के लिए होता है। आर दुभाषिया केवल अगली पंक्ति को whileलूप के शरीर के रूप में देखता है , और ऑक्टेव दुभाषिया ऑक्टेव कोड के ठीक आगे निकल जाता है

R भाग 1 से शुरू होने वाली संख्याओं के जोड़े को प्रिंट करता है, और ऑक्टेव भाग 0 से शुरू होने वाले पीछे की संख्या को प्रिंट करता है।

मैं पूरी तरह से बहिष्कृत होने की उम्मीद करता हूं (यहां तक कि भाषाओं के समान संयोजन से); मैं अभी हाल ही में इतना मैटलैब और आर कोड लिख रहा हूं कि मुझे लगा कि मैं इसे शॉट दूंगा।

इसे ऑनलाइन आज़माएं! - ऑक्टेव लिंक

— ग्यूसेप
स्रोत

क्या शीर्ष एक होना चाहिए i=i+1?

— ज़ाचरी

1

@ZacharyT दुर्भाग्य से, +=आर में काम नहीं करता है, तो हाँ, यह उस तरह होना चाहिए।

— ग्यूसेप

है endआवश्यक?

— BLT

1

@ बीएलटी, हाँ, यह ऑक्टेव के लिए लूप के अंत को चिह्नित करता है।

— ग्यूसेप

ठीक है धन्यवाद। मैं सोच रहा था कि चूंकि यह कभी भी समाप्त नहीं होने वाला था ( while(1)) आप उन बाइट्स को बचा सकते हैं।

— BLT

3

रूबी / पायथन 2: 68 64 बाइट्स

i=0
"#{loop{p i+=1,i}}"
exec('while 1:print str(i)[::-1];i+=1')

रूबी परिप्रेक्ष्य

चर का सरल init:

i = 0

"#{}"स्ट्रिंग प्रक्षेप के लिए वाक्यविन्यास है। मैं इसके बजाय अभिव्यक्ति को निष्पादित करने के लिए इसका उपयोग करता हूं।

"#{loop{p i+=1,i}}"

pके लिए एक आशुलिपि है puts। loopएक अनंत लूप बनाता है।

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

अजगर का दृष्टिकोण

अजगर के दृष्टिकोण से, एक आम है i=0। अगला, पायथन में स्ट्रिंग प्रक्षेप के लिए अलग-अलग वाक्यविन्यास हैं, इसलिए यह रेखा बस त्याग दी गई है। आगे एक अनंत लूप है जो दूसरों ने पोस्ट किया है।

— enedil
स्रोत

3

बैश / चेक , 50 28 बाइट्स

^{पायथन से बैश में स्विच करके बाइट्स के एक गुच्छा को बचाने के लिए @ डॉर्कनब को धन्यवाद}

#>
#v
 #p<p<)#
seq 1 inf|rev

जोर से मारना:

#>
#v
 #p<p<)#

ये केवल कुछ टिप्पणियां हैं, जिन्हें अनदेखा किया गया है।

seq 1 inf|rev

1 से अनंत तक जाने का क्रम शुरू करें, फिर परिणाम पर जाएं rev।

जाँच करने के लिए:

#>

यह तुरंत 2 डी मोड में बदल जाता है, सही जा रहा है। >IP अधिकार को निर्देशित करता है, जिसका कोई प्रभाव नहीं है। यह लाइन की शुरुआत के चारों ओर घूमता है और #फिर से हिट करता है, जो 2 डी मोड से बाहर निकलता है। यह तब >1D मोड में हिट होता है, जो 0 से स्टैक तक जाता है। क्योंकि यह 1 डी मोड में है, आईपी अगली पंक्ति में लपेटता है।

#v

#आईपी को फिर से 2 डी मोड में स्विच करता है और vइसे नीचे की ओर निर्देशित करता है।

 #p<p<)#

पहला #स्विच फिर से 1D मोड पर वापस आ जाता है। pएक संख्या के रूप में टीओएस को आउटपुट करता है (लेकिन इसे पॉप नहीं करता है), और फिर <एक नई रेखा प्रिंट करता है। यह दो बार किया जाता है, और फिर संख्या बढ़ जाती है )। #2 डी मोड में फिर से स्विच करता है, इसलिए आईपी लाइन की शुरुआत में लपेटता है, #1 डी मोड पर स्विच करने के लिए हिट करता है, आदि।

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

1

बैश #टिप्पणियों के लिए उपयोग करता है और "उलट संख्या" कार्य को बहुत आसानी से कर सकता है seq 1 inf|rev:।

— दरवाज़े

रूबी कोड i=1;loop{puts i.to_s.reverse;i+=1}एक बाइट छोटा है

— dkudriavtsev

3

CJam /> <>, 27 23 बाइट्स

"la,:naonao
"1{_sW%n)}h

CJam को:

इसे ऑनलाइन आज़माएं! - ध्यान दें कि आपको आउटपुट देखने के लिए 60 सेकंड की सीमा तक इंतजार करना होगा, लेकिन यह ऑफ़लाइन काम करता है।

"la,:naonao
"

यह एक बहु-पंक्ति स्ट्रिंग शाब्दिक को परिभाषित करता है जिसका उपयोग कभी नहीं किया जाता है।

 1{_sW%n)}h

दूसरी पंक्ति इस प्रकार है:

1     e# Push 1:               | 1 
{     e# Forever:              | 1
  _   e#   Duplicate:          | 1 1
  s   e#   Convert to string:  | 1 "1"
  W%  e#   Reverse:            | 1 "1"
  n   e#   Print with newline: | 1
  )   e#   Increment:          | 2
}h    e# End loop

को> <>:

एक स्ट्रिंग शाब्दिक शुरू होता है।

 la,:naonao

स्ट्रिंग शाब्दिक की सामग्री। प्रत्येक वर्ण कोड व्यक्तिगत रूप से स्टैक में धकेल दिया जाता है।

आईपी "फिर से पहुंचने के लिए चारों ओर लपेटता है , जो स्ट्रिंग मोड को समाप्त करता है।

la,

lस्टैक की लंबाई लेता है, a10 धक्का देता है, और ,विभाजित करता है। यह हमें स्टैक / 10 की लंबाई देता है।

    :nao

:डुप्लिकेट, nएक संख्या के रूप में प्रिंट करता है, a10 को धकेलता है, और oएक वर्ण कोड (एक नई पंक्ति) के रूप में प्रिंट करता है।

nao

वही चीज। नंबर को प्रिंट करें उसके बाद एक नई लाइन। स्टैक की लंबाई अब फिर से 10 है (मूल स्ट्रिंग शाब्दिक सामग्री स्टैक पर है)।

आईपी फिर चारों ओर घूमता है ", जिससे 10 और तत्वों को धक्का दिया जा सकता है। अगली बार, l२० लौटाता है, इसलिए २ छपा हुआ है, आदि।

दूसरी पंक्ति को आईपी द्वारा कभी नहीं छुआ जाता है।

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

2

Röda / C (gcc) , 90 बाइट्स

main(){f(0);}f(a){a=1//1{[` $a`[::-1]];a++}while[]/*
;for(;;a++)printf("%d %d ",a,a);/**/}

Röda: यह ऑनलाइन कोशिश करो!

C: यह ऑनलाइन कोशिश करो!

व्याख्या

यह इस तथ्य का दुरुपयोग करता है कि //रोडा में आंतरिक विभाजन है, लेकिन सी में एक पंक्ति टिप्पणी है।

दोनों भाषाओं में, main(){}मुख्य कार्यक्रम को दर्शाता है, और वे दोनों fडमी तर्क के साथ कार्य करते हैं 0।

Röda में, a=1//1int विभाजन करता है और परिणाम 1को असाइन करता हैa । C a=1समान कार्य देखता है और करता है, लेकिन उस असाइनमेंट के बाद सब कुछ C के लिए एक टिप्पणी है। वहां से, दो भाषाओं की शाखा बंद हो जाती है।

Röda

हमारे पास एक अनंत लूप है while[]( एक खाली स्थिति सत्य है )। इसके अंदर, ` $a`पूर्णांक aको एक स्ट्रिंग (एक प्रमुख स्थान के साथ) में परिवर्तित करता है जिसके बाद [::-1]इसे उलट देता है (और यह एक प्रक्षेपवक्र अंतरिक्ष के साथ आउटपुट करता है)। तब का मूल्यa एक से बढ़ जाता है।

लूप के बाहर, एक बहुस्तरीय टिप्पणी शुरू होती है /* फ़ंक्शन के अंत से ठीक पहले और समाप्त ।

सी

बाकी पंक्ति को नजरअंदाज करने के बाद, कार्यक्रम दूसरी पंक्ति में जाता है। हम एक अर्धविराम से शुरू करते हैं क्योंकि a=1कथन को समाप्त करने की आवश्यकता है। उसके बाद, हम लूप के लिए एक साधारण मुठभेड़ करते हैं जो पुनरावृति चर को प्रिंट करता है, aप्रत्येक पुनरावृत्ति पर दो बार।

लूप के लिए, /*रोडा की समाप्ति */टिप्पणी को अनदेखा करने के लिए बस वहाँ है ।

— क्रिक्टी लिथोस
स्रोत

2

QBIC / QBasic 4.5 , 58 बाइट्स

do
p=p+1
if q then
'?`_f!p$|
else
?p,p,
end if
loop

यह इस तथ्य का भारी दुरुपयोग करता है कि सभी निचले अक्षरों को QBIC दुभाषिया द्वारा शाब्दिक QBasic कोड के रूप में देखा जाता है और QBIC की QBasic परत के साथ ही पारित कर दिया जाता है। दोनों भाषाएँ इस कोड को किस तरह से देखती हैं:

LOC         QBasic                    QBIC
-------------------------------------------------------
do                   Start an infinite loop
p=p+1                Increment p, starts off as 0
if q then    q = 0, goto ELSE         q = 1, execute IF
'?`_f!p$|    ' = comment, invalid     '?` is a 'code literal', passing PRINT to QBASIC
             syntax is ignored        followed by QBIC code to flip p cast as string.
else         q=0, execute             q=1, so ignored
?p,p,        PRINT p twice,
             separated by tab
end if               End of the branching logic
loop                 Wrap around for the next pass

— steenbergh
स्रोत

2

लेजरलैंग / > <> , 163 बाइट्स

!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

पहली बार गोल्फ, तो यह शायद यह हो सकता है की तुलना में थोड़ा बड़ा है। मैं> <> का उपयोग करना चाहता था, लेकिन चूंकि कुछ लोगों ने पहले से ही दूसरे अनुक्रम को बनाने के लिए इसका इस्तेमाल किया था, इसलिए मैंने फैसला किया कि मैं पहले अनुक्रम को एक बार बनाना चाहता हूं।

कोशिश करें> <> ऑनलाइन!
LaserLANG के लिए, इसे आज़माने के लिए एक ऑफ़लाइन दुभाषिया की आवश्यकता होती है। यह यहाँ पाया जा सकता है ।

laserLANG

!\
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

निष्पादन शुरू होता है !जिस पर पूरी तरह से ध्यान नहीं दिया जाता है। यह तब तक पहुँचता है \और पिछले कई पात्रों की यात्रा शुरू करता है जिन्हें यह पूरी तरह से अनदेखा करता है। अंत में यह दूसरे तक पहुंचता है\ मज़ा शुरू होता है। मैंने मूल रूप से "हैलो, वर्ल्ड!" के पीछे का विचार लिया। लूप और कंडेनड के साथ ही मैं भी कर सकता था। यह इस तथ्य से निपटने के लिए एक चुनौती थी कि लेज़रलैंग केवल मेमोरी काउंटर को घटाने / बढ़ाने के बारे में है जब प्रोग्राम काउंटर क्रमशः बाएं / दाएं जा रहा है। मुझे लगता है कि मैंने सोचा नहीं था कि कुछ चालें करके सबसे बाइट्स को यहां बचाया जा सकता है।

> <>

!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l

निष्पादन शुरू होता है, !जिस पर इसे छोड़ना पड़ता है \। यह तब भी जारी रहता है जब लेज़लन कोड नहीं था। मुझे एहसास नहीं था कि <> केवल फ्लोट डिवीजन के लिए समर्थन था, इसलिए पहले एक छोटा और सरल ट्रंकेशन थोड़ा भ्रमित था।

— Aroymart
स्रोत

2

Befunge-98 / > <> , 32 बाइट्स

\r.#%a/# :_::p#+a#1,#
>l::naonao

इससे पहले कि मैंने देखा कि कितने ><>जवाब थे। कुछ पृष्ठभूमि: \एक दिशा बदलने वाला ऑपरेटर है> <>, इस मामले में इसे नीचे धकेल दिया जाता है, जबकि बेफ़ुंज में यह स्टैक पर शीर्ष दो वस्तुओं को स्वैप करता है। Befunge कोड ऐसा दिखता है:

\r.#%a/# :_::p#+a#1,#

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

नई सुर्खियों द्वारा अलग किए गए बैकवर्ड नंबरों को प्रिंट करता है। Befunge प्रत्येक नंबर के बाद स्वचालित रूप से एक स्पेस प्रिंट करता है, इसलिए प्रत्येक अंक को स्पेस से अलग किया जाता है। बार-बार अंतिम अंक प्राप्त होता है, इसे प्रिंट करता है और संख्या को 10 तक विभाजित करता है जब तक कि यह 0. नहीं है। फिर वृद्धि और दोहराएं।

> <> कोड तुरंत दूसरी पंक्ति में जाता है।

>l::naonao

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

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

— मजाक कर रहा है
स्रोत

1

रूबी / स्टैक्ड , 37 बाइट्स

0#/0[1+:tostr rev out]
loop{p p$.+=1}

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

यह प्रिंट 1 1 2 2... रूबी में और 1 2 3 ... 01 11 21...स्टैक्ड में।

व्याख्या

रूबी में:

0#/0[1+:tostr rev out]
loop{p p$.+=1}

टिप्पणी को हटाने के बाद, यह बन जाता है:

0
loop{p p$.+=1}

यहां एकमात्र प्रासंगिक रेखा अंतिम है। pअपना तर्क देता है, इसलिए p pअपने तर्क को दो बार छापता है। $.शुरू होता है 0, इसलिए $.+=1वेतन $.वृद्धि मूल्य लौटाता है। इसलिए, यह प्रत्येक संख्या को 1दो बार से प्रिंट करता है ।

स्टैक्ड में:

0#/0[1+:tostr rev out]
loop{p p$.+=1}

यह निम्नलिखित टोकन के बराबर है:

0 #/ 0 [ 1 + : tostr rev out ] loop { p p $ . + = 1 }

पहले दो प्रासंगिक नहीं हैं (मूल रूप से, 0एक कम एफ यूनिएशन में बदलना )। फिर, 0स्टैक पर धकेल दिया जाता है। इसके बाद, फ़ंक्शन [1+:tostr rev out]को स्टैक पर धकेल दिया जाता है।loopइस फ़ंक्शन को पॉप करता है और इसे असीम रूप से निष्पादित करता है।

फ़ंक्शन के अंदर स्टैक के शीर्ष को बढ़ाता है ( 1+), इसे डुप्लिकेट करता है ( :), इसे एक स्ट्रिंग में परिवर्तित करता है ( tostr), इसे उलट देता है ( rev) और इसे आउटपुट करता है ( out)। इस प्रक्रिया को असीम रूप से दोहराया जाता है। चूंकि लूप अनंत है, उस टोकन के बाद आने वाली कोई भी चीज अनिवार्य रूप से दुभाषिया द्वारा नजरअंदाज की जाती है।

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

1

> <> / जेली , 37 बाइट्स (25 जेली के कोडपेज में)

01+:nao:nao!
DU;⁷Ṙ€
®‘©Çß

कोशिश करें> <> ऑनलाइन!

ऑनलाइन जेली का प्रयास करें!

> <> दो बार अनंत को अनुक्रम प्रिंट करता है, जेली पीछे की ओर गिना जाता है।

> <> केवल शीर्ष पंक्ति से संबंधित है:

और यहां लाइनफीड पर कुछ बाइट्स बचाने के लिए @ चैलेंजर 5 को धन्यवाद

01+:nao:nao!                           Stack at: 1st run   2nd run ...
0                 Push a 0             0         -
 1                Push a 1             0,1       1,1   
  +               Pop 2, add them      1         2 
   :              Duplicate top item   1, 1      2, 2
    n             Pop top, show as num 1         2
     a            Push the number 10   1, 10     2, 10
      o           Pop and show 10 as an ACII char (ie '\lf')
                                       1         2
         :nao     And again, for repetition
             !    ><> wraps around; this skips pushing a 0 again.

जेली अपने कोड को नीचे से ऊपर तक निष्पादित करती है। केवल अंतिम 2 लाइनें प्रासंगिक हैं।

®‘©Çß       main link, keeps track of the current number

®           Get a number from the register (0 on first run)
 ‘          Increment that by 1
  ©         Store in register
   Ç        Call helper (printer) link
    ß       Call this link again

DU;⁷Ṙ€      Printer

            (Say we are at number 21)
D           Break into digits         [2, 1]
 U          Reverse array             [1, 2]
  ;⁷        Append a line break       [1, 2, \n]
    Ṙ€      Print each char in array

— steenbergh
स्रोत

@LuisMendo इस ><>कोड में उपयोग किए गए वर्णों में ASCII कोड-बिंदु हैं जो जेली कोडपेज के साथ मेल खाते हैं। मुझे इस कोडपेज व्यवसाय के बारे में बहुत अधिक जानकारी नहीं है, लेकिन मुझे लगता है कि इससे कोड का प्रतिनिधित्व करने के लिए इस्तेमाल होने वाले बाइट्स समान होंगे। निचली पंक्तियों के पात्रों को नजरअंदाज कर दिया जाता है, ><>इसलिए इससे कोई फर्क नहीं पड़ता कि क्या वे कोडपे के बीच समान हैं। बाइट की गिनती ><>TIO लिंक से ली गई थी ।

— रानीबेरग

>> <> में विभाजक के बिना इनका मुद्रण नहीं किया जा रहा है?

— फलों का

@ चैलेंजर 5 सही; तय की।

— स्टेनबर्घ

मछली का चरित्र प्रकार नहीं होता है; ","बस ,स्टैक के ASCII मूल्य को धक्का देता है , इसलिए आप aइसके बजाय एक नए विभाजक के लिए उपयोग कर सकते हैं ।

— फलन

ऐसा लगता है कि अल्पविराम> <> स्पष्टीकरण की पहली पंक्ति पर अभी भी हैं।

— 22

1

सी (जीसीसी) / पीएचपी , 102 86 80 बाइट्स

#//\
for(;;)echo strrev(++$i).'
int main(i){for(;;i++)printf("%d %d ",i,i);}//';

सी में डबल अनुक्रम और पीएचपी में रिवर्स अनुक्रम आउटपुट करता है।

इसे C में आज़माएं!

इसे PHP में आज़माएं!

स्पष्टीकरण

सी

सी में, #रूपों प्रीप्रोसेसर सामान। मैं वास्तव में सी के बारे में बहुत कुछ नहीं जानता, लेकिन यह शिकायत नहीं करता है जब इस सामान के लिए कोई खाली लाइन है। //रूपों एक लाइन टिप्पणी। ए\ पंक्ति के अंत में अनिवार्य रूप से न्यूलाइन को "बच" और दो पंक्तियों को एक माना जाता है। यह भी लाइन टिप्पणियों के लिए काम करता है, इसलिए दूसरी पंक्ति को सी में एक टिप्पणी के रूप में देखा जाता है। तीसरी पंक्ति लूप के लिए एक सरल के साथ संख्याओं को आउटपुट करने का काम करती है। बाद में, बस एक टिप्पणी है।

पीएचपी

PHP में, #एक लाइन टिप्पणी बनाता है, इसलिए पहली पंक्ति को पूरी तरह से अनदेखा कर दिया जाता है। दूसरी पंक्ति लूप के लिए उलट संख्याओं को प्रिंट करती है, और उन्हें अलग करती है \nint main(i){for(;;i++)printf("%d %d ",i,i);}//(सी कोड एक स्ट्रिंग में लिपटे हुए)।

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

चक नॉरिस की तरह गिनती

चुनौती

नियम

05AB1E / जेली , 14 13 बाइट्स

कैसे?

पायथन 2 / सी (क्लैंग) , 109 107 100 84 95 88 89 88 87 84 बाइट्स

जेली / पायथ, 15 बाइट्स

व्याख्या

पर्ल / जावास्क्रिप्ट, 87 बाइट्स

पर्ल

जावास्क्रिप्ट

NodeJS / PHP, 131 106 बाइट्स

वी / ब्रेन-फ्लैक क्लासिक , 27 , 26 बाइट्स

रेटिना / पायथन 2, 61 बाइट्स

आर / ऑक्टेव , 83 80 78 71 बाइट्स

रूबी / पायथन 2: 68 64 बाइट्स

रूबी परिप्रेक्ष्य

अजगर का दृष्टिकोण

बैश / चेक , 50 28 बाइट्स

जोर से मारना:

जाँच करने के लिए:

CJam /> <>, 27 23 बाइट्स

CJam को:

को> <>:

Röda / C (gcc) , 90 बाइट्स

व्याख्या

QBIC / QBasic 4.5 , 58 बाइट्स

लेजरलैंग / > <> , 163 बाइट्स

Befunge-98 / > <> , 32 बाइट्स

रूबी / स्टैक्ड , 37 बाइट्स

व्याख्या

रूबी में:

स्टैक्ड में:

> <> / जेली , 37 बाइट्स (25 जेली के कोडपेज में)

सी (जीसीसी) / पीएचपी , 102 86 80 बाइट्स

स्पष्टीकरण

सी

पीएचपी