एक प्रोग्राम लिखें जो एक से शुरू होकर हमेशा के लिए मायने रखता है।

नियम:

STDOUTयदि STDOUTउपलब्ध नहीं है , तो आपके कार्यक्रम को या एक स्वीकार्य विकल्प पर लॉग इन करना होगा ।
आपका कार्यक्रम एक पूर्ण, चलने योग्य कार्यक्रम होना चाहिए, और फ़ंक्शन या स्निपेट नहीं होना चाहिए।
आपके प्रोग्राम को प्रत्येक संख्या को बीच में एक अलग चरित्र के साथ आउटपुट करना चाहिए (एक नई पंक्ति, स्थान, टैब या अल्पविराम), लेकिन यह सभी संख्याओं के लिए संगत होना चाहिए।
आप दशमलव में संख्याओं को एकात्मक या आधार 256 में मुद्रित कर सकते हैं जहाँ प्रत्येक अंक को बाइट मान द्वारा दर्शाया जाता है ।
आपके प्रोग्राम को कम से कम 2 ¹²⁸ (समावेशी) समस्याओं के बिना और एक उचित डेस्कटॉप पीसी पर मेमोरी से बाहर चलने के बिना गिनना चाहिए । विशेष रूप से, इसका मतलब है कि यदि आप यूनीरी का उपयोग कर रहे हैं, तो आप मेमोरी में वर्तमान संख्या के एक यूनिरी प्रतिनिधित्व को संग्रहीत नहीं कर सकते हैं।
हमारे सामान्य नियमों के विपरीत, एक भाषा (या भाषा संस्करण) का उपयोग करने के लिए स्वतंत्र महसूस करें, भले ही यह इस चुनौती से नया हो। इस चुनौती का 0-बाइट उत्तर देने के लिए विशेष रूप से लिखी जाने वाली भाषाएं निष्पक्ष खेल हैं, लेकिन विशेष रूप से दिलचस्प नहीं हैं।

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

सूची

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

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

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

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

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 63834; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 39069; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(42), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

स्निपेट का विस्तार करें

code-golf number counting

— vrwim
स्रोत

29

मुझे यकीन नहीं है कि गठबंधन करने के लिए प्रत्येक संख्या को अलग-अलग चरित्र के साथ आउटपुट कैसे करना चाहिए, इसके साथ संख्या 256 [...] को आधार संख्या में प्रिंट कर सकते हैं ।

— डेनिस

6

भविष्य की चुनौतियों के लिए, क्या मैं सैंडबॉक्स की सिफारिश कर सकता हूं ताकि लोगों को जवाब पोस्ट करने से पहले इन सभी विवरणों को हल किया जा सके? :)

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

3

@ इल्मारिकारोन मैं व्याख्या करता हूं कि स्मृति सीमा होने के नाते, समय सीमा नहीं। संभवतः प्रति-वृद्धि पर एक समय सीमा। बस काउंटर को 2 ** 128-10 पर सेट करें और देखें कि उन अंतिम दस चरणों को लेने में कितना समय लगता है।

— स्पर्धा

5

क्या हम आउटपुट में अग्रणी शून्य हो सकते हैं?

— पाओलो एबरमन

4

ओह !!! मेरे पास TI-89 (56b) का उत्तर है, लेकिन मैं साइट पर b / c पोस्ट नहीं कर सकता और मेरे पास प्रतिनिधि 10+ नहीं है!

— ग्रैग्सडेन

63

भूलभुलैया , 5 बाइट्स

):
\!

♫ कोड में आईपी गोल और गोल the हो जाता है

प्रासंगिक निर्देश:

)       Increment top of stack (stack has infinite zeroes at bottom)
:       Duplicate top of stack
!       Output top of stack
\       Output newline

— Sp3000
स्रोत

77

यह कार्यक्रम दुखद है कि इसका

— ऑप्टिमाइज़र

7

@ ऑप्टिमाइज़र ने उदास (वास्तव में) को

— हराया

1

यह 4 बाइट्स क्यों नहीं है?

— aurel Bílý

2

@ Aurel300 पांचवी बाइट बीच की नई लाइन है :और\

— Sp3000

@ Sp3000 आह, हाँ। मुझे मूर्ख। :)

— ऑरेल बेली

46

> <> , 8 बाइट्स

01+:nao!

कदम:

स्टैक पर 0 दबाएं
शीर्ष स्टैक तत्व में 1 जोड़ें
डुप्लिकेट शीर्ष स्टैक तत्व
संख्या के रूप में स्टैक के शीर्ष पर आउटपुट करें
आउटपुट एक नई रेखा
चारों ओर लपेटकर और अगला निर्देश कूदते हुए चरण 2 पर जाएं (चरण 11)

(एक कम मेमोरी कुशल (इसलिए अमान्य है) कार्यक्रम है llnao)

— randomra
स्रोत

66

मूल रूप से "प्लस एक, अब!" पढ़ता है कि कोड की एक पंक्ति में अधीर मांग-मांग निहित के लिए +1।

— Janus Bahs Jacquet

24

हास्केल, 21 बाइट्स

main=mapM_ print[1..]

मनमाना-सटीक पूर्णांक और अनंत सूचियाँ इसे आसान बनाती हैं :-)

सौभाग्य से mapM_प्रस्तावना में है। अगर Data.Traversableऐसा होता, तो हम इसे 19 बाइट्स तक भी सिकोड़ सकते थे:

main=for_[1..]print

— Bergi
स्रोत

क्या ऐसा कोई प्रतीक नहीं है जो मैप / मैपएम आदि को सामान्य करता है?

— JDługosz

@ JDługosz: कि मैं नहीं जानता कि

— Bergi

आह, 'यह अभी भी sequenceपरिणाम वास्तव में होने के लिए परिणाम प्राप्त करने के लिए होता है।

— JDługosz

isnt बस [1..]की अनुमति दी, क्योंकि यह beoney में अल्पविराम के साथ सभी नंबरों को प्रिंट करता है? या पहले [पेंच यह सब?

— बैकोनारो

@ बाकोनारो: यह एक सूची है, यह कुछ भी प्रिंट नहीं करता है। यदि आप उत्तर में शब्द दर्ज करते हैं, तो जीएचसीआई परिणाम प्रिंट करता है, लेकिन यह एक चलने योग्य कार्यक्रम नहीं है। और हाँ, अग्रणी [की अनुमति नहीं है।

— बरगी

23

गोल> <> , 3 बाइट्स

P:N

कदम:

शीर्ष स्टैक तत्व में 1 जोड़ें (शुरुआत में यह एक अंतर्निहित 0 है)
डुप्लिकेट शीर्ष स्टैक तत्व
पॉप और स्टैक के शीर्ष पर संख्या और एक नई रेखा के रूप में आउटपुट
जैसे ही हम लाइन के अंत तक पहुँचते हैं, चरण 1 के चारों ओर लपेटें

— randomra
स्रोत

21

मारबेलस , 11450 4632 बाइट्स

मुद्रण दशमलव एक दर्द है !!

निश्चित रूप से इस जीत के साथ नहीं, लेकिन मैंने सोचा कि मैं इसे एक शॉट दूंगा। मुझे आशा है कि यह ठीक है कि यह आउटपुट को 40 शून्य (2 ^ 128 फिट करने के लिए) को पैड करता है।

00@0..@1..@2..@3..@4..@5..@6..@7..@8..@9..@A..@B..@C..@D..@E..@F..@G..@H..@I..@J
\\++..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00
..EhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhun
....AddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddt
..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7\/
../\&8..........................................................................
....@0..........................................................................
....../\&8......................................................................
....//..@1......................................................................
........../\&8..................................................................
......////..@2..................................................................
............../\&8..............................................................
........//////..@3..............................................................
................../\&8..........................................................
..........////////..@4..........................................................
....................../\&8......................................................
............//////////..@5......................................................
........................../\&8..................................................
..............////////////..@6..................................................
............................../\&8..............................................
................//////////////..@7..............................................
................................../\&8..........................................
..................////////////////..@8..........................................
....................................../\&8......................................
....................//////////////////..@9......................................
........................................../\&8..................................
......................////////////////////..@A..................................
............................................../\&8..............................
........................//////////////////////..@B..............................
................................................../\&8..........................
..........................////////////////////////..@C..........................
....................................................../\&8......................
............................//////////////////////////..@D......................
........................................................../\&8..................
..............................////////////////////////////..@E..................
............................................................../\&8..............
................................//////////////////////////////..@F..............
................................................................../\&8..........
..................................////////////////////////////////..@G..........
....................................................................../\&8......
....................................//////////////////////////////////..@H......
........................................................................../\&8..
......................................////////////////////////////////////..@I..
............................................................................../\&8
........................................//////////////////////////////////////..@J
&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9
Sixteenbytedecimalprintermodulewitharegi

:Sixteenbytedecimalprintermodulewitharegi
}J}J}I}I}H}H}G}G}F}F}E}E}D}D}C}C}B}B}A}A}9}9}8}8}7}7}6}6}5}5}4}4}3}3}2}2}1}1}0}00A
/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A
%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..

:/A
..}0..}0..
..>>}0....
..>>>>\\..
....//..//
../\>>\\..
....>>..//
....>>\\..
....>>....
\\>>//....
..>>......
..>>......
../\......
..../\<<..
......<<..
..\\<<//..
....~~....
....++....
....\\..//
\\....>9\/
..\\..?0..
......++..
....\\....
......{0..

:%A
@0..
}0..
<A-A
{0@0

:Eg
}0}0}0}0}0}0}0}0
^7^6^5^4^3^2^1^0
~~....~~~~..~~~~
^0^0^0^0^0^0^0^0
{0{0{0{0{0{0{0{0

:Ehun
}0..}0
Eg..&0
=8&0{0
&1\/00
0100&0
&1&1{1
{1{0

:Addt
}0}1
{1{1

— चिकित्सक
स्रोत

क्या मुद्रण बाइनरी किसी भी छोटी होगी?

— SuperJedi224

3

(या किस बारे में एकल?)

— दरवाज़े

@Doorknob आउटपुट प्रदर्शित करना समस्या नहीं है। यह Ehunबोर्ड पर कुछ ऐसा है जो अगले अंक में वृद्धि करने के लिए माना जाता है, लेकिन ठीक से काम नहीं करता है

— TheDoctor

1

क्या आप जानते हैं कि आप बोर्ड के बीच हर लाइन और रिक्त लाइनों के अंत में पीरियड्स को छोड़ सकते हैं और बोर्ड के नामों के लिए एकल वर्णों का उपयोग कर सकते हैं? आपको बस उस एकल वर्ण को उस पर कॉल करने के लिए उपयुक्त मात्रा में दोहराना होगा। यह आपके उत्तर को लगभग 3000 बाइट्स तक पहुंचा सकता है।

— ओवरएक्टर 10

आखिरकार मैं marbelous.py के लिए एक कमिट करने जा रहा हूं जिसमें include/डिफ़ॉल्ट रूप से सभी शामिल हैं

— Sparr

18

सी (64-बिट आर्किटेक्चर केवल), 53 बाइट्स

कम से कम 64 बिट्स होने के संकेत पर निर्भर करता है और उन्हें विशेषांक का उपयोग करके हेक्स में प्रिंट %pकरता है। जब यह 2 ^ 128 से टकराता है, तो प्रोग्राम सही तरीके से वापस आ जाएगा।

char*a,*b;main(){for(;++b||++a;)printf("%p%p ",a,b);}

— feersum
स्रोत

1

इसलिए यदि वे संकेत प्रत्येक 64 बिट पर हैं, तो आप केवल 2 ^ 128-1, सही तक गिन सकते हैं?

— दोष

6

अमान्य के रूप में इसे 2 ^ 128 तक नहीं गिन सकते

— edc65

14

मुझे कोडगॉल्फ पसंद है जब यह रचनात्मकता को व्यक्त करने और पुरस्कृत करने के बारे में है। feersum स्पष्ट रूप से यहाँ जीत के लिए प्रतिस्पर्धा नहीं कर रहा है। एक तकनीकीता पर कई डाउनवोट्स देखने के लिए और यह सुनिश्चित करने के लिए प्रश्न के शब्दों को संशोधित करना कि उसका उत्तर उल्लंघन है, मुझे दुखी करता है।

— फ्लोडेल

3

मुझे लगा कि "कम से कम 2 ^ 128" शब्द पर्याप्त स्पष्ट थे ...

— vrwim

5

@vrwim आपने ऐसा नहीं लिखा। आपने "2 ^ 128 तक" लिखा। सुपरजेडी ने कुछ मिनट पहले इसे संपादित किया।

— 18

17

हेक्सागोनी , 12 11 10 7 बाइट्स

कोड को साइड-लेंथ 2 में फिट करने के लिए alephalpha का धन्यवाद।

10})!';

सामने आया:

 1 0
} ) !
 ' ;

यह एक काफी सरल है। 10एक 10, यानी प्रारंभिक मेमोरी एज के लिए एक पंक्ति में लिखता है। फिर })!';एक लूप में बार-बार निष्पादित किया जाता है:

} अगली मेमोरी एज पर जाएं।
) इसे बढ़ाएँ।
! इसे पूर्णांक के रूप में प्रिंट करें।
' 10 पर वापस जाएं।
; इसे एक पात्र के रूप में छापें।

मेरा मानना है कि यह इष्टतम है (हालांकि अब तक अद्वितीय नहीं है)। मैं जानवर बल स्क्रिप्ट मैंने लिखा जाने गए इस उत्तर के लिए यह कम से कम एक में से प्रत्येक को शामिल करने के लिए होता है कि इस धारणा के तहत 6-बाइट समाधान के लिए खोज ;और !और या तो (या ), और शामिल नहीं हैं ?, ,या @, और उसने ऐसा नहीं किया कोई समाधान ढूंढे।

— मार्टिन एंडर
स्रोत

13

अजगर, 4 बाइट्स

.V1b

स्पष्टीकरण:

.V1    for b in range(1 to infinity):
   b      print b

— Jakube
स्रोत

f!\n( TIO लिंक ) 3 बाइट्स के लिए काम करेगा, सुनिश्चित करें कि यदि आपके जवाब के बाद जोड़े गए किसी भी सुविधाओं का उपयोग कर रहा है, तो निश्चित नहीं।

— सोक

@ शोख चतुर। हालाँकि, मैं इस उत्तर को नहीं fबदलूंगा क्योंकि मुझे लगता है कि यह 4 साल पहले टोट पायथ की एक विशेषता थी।

— जकूबे

मैंने भी ऐसा सोचा, यही कारण है कि मैंने इसे एक टिप्पणी के रूप में छोड़ दिया - एक पुरानी उत्तर को हरा करने के लिए नई भाषा की विशेषताएं हमेशा सस्ते आईएमओ महसूस करती हैं

— सोक

13

ई.पू., १०

for(;;)++i

असामान्य जो इससे bcछोटा है dc।

से man bc:

विवरण

bc एक भाषा है जो मनमाने ढंग से सटीक संख्याओं का समर्थन करती है

— डिजिटल आघात
स्रोत

यह कहां से छपता है?

— बैलिंट

@ बैलिंट ++iएक अभिव्यक्ति है, लेकिन असाइनमेंट नहीं है, और स्पष्ट रूप से आउटपुट है। क्या आपने इसे चलाने की कोशिश की? echo 'for(;;)++i' | bcअपने निकटतम लिनक्स टर्मिनल में।

— डिजिटल ट्रामा

मेरे घर में एक भी लिनक्स टर्मिनल नहीं है। मैं बिलकुल उत्सुक था।

— बैलिंट

6

@ बैलिंट हर घर में एक लिनक्स टर्मिनल होना चाहिए।

— डिजिटल ट्रामा

1

@ इस कार्यक्रम को चलाने वाला आपका नाम है;)

— पागल

12

जावा, 139 138 127 123 बाइट्स

class K{public static void main(String[]a){java.math.BigInteger b=null;for(b=b.ZERO;;)System.out.println(b=b.add(b.ONE));}}

— SuperJedi224
स्रोत

2

जावा में एक छोटा अनंत लूप for(;;)एक आसान 3 बाइट्स के लिए है।

— आख-मोपर्क

आप एक और 2 के साथ भी बचा सकते हैं BigInteger b=null;b=b.ZERO;, दुख की =nullजरूरत है, यहां तक कि यह एक स्थिर पहुंच है।

— ट्वीस्ट्रीमोब

और फिर एक और 9, क्योंकि आप BigIntegerFQCN द्वारा केवल एक बार संदर्भित करके आयात से छुटकारा पा सकते हैं ।

— ट्वीस्ट्रीमोब

@TWiStErRob किसी तरह, मुझे एहसास नहीं था कि कम होगा।

— SuperJedi224 20

2

जावा 8 या नए के लिए, आप क्लास को बदल सकते हैं interfaceऔर publicफ़ंक्शन से हटा सकते हैं । अपने कोड को कॉपी न करें और इसे एक नए उत्तर के रूप में पोस्ट करें।

— लुका एच

10

गणितज्ञ, 22 बाइट्स

i=0;While[Echo[++i]>0]

Echo Mathematica 10.3 में एक नया कार्य है।

— alephalpha
स्रोत

Echoन्यू लाइन प्लस: चार अलग वर्ण देता है ">> "। यकीन नहीं है कि यह मान्य है - शायद Printइसके बजाय उपयोग करें ? इसके अलावा, एक बाइट के साथ सहेजें i=0;While[Echo@++i>0]।

— रोमन

7

रूबी, 15 12 बाइट्स

loop{p$.+=1}

p, जब एक पूर्णांक दिया जाता है, तो पूर्णांक को (जैसे @philomory के सौजन्य से ) प्रिंट करता है
$.स्टड से पढ़ी गई लाइनों की संख्या को पकड़े हुए एक जादुई चर है। यह स्पष्ट रूप से 0 पर आरंभीकृत है, और यह भी असाइन करने योग्य है :)

— daniero
स्रोत

@philomory आमतौर पर उपयोगकर्ताओं को अपने बाइट-सेविंग समाधान का सुझाव देते हुए एक टिप्पणी छोड़ने का सुझाव दिया जाता है। इसके अलावा, मैं इस एक के लिए एक स्पष्टीकरण देखना चाहूंगा। c:

— एडिसन क्रम्प

7

पायथन 3, 33 25 बाइट्स

जहां तक मैं समझता हूं, पायथन पूर्णांक मनमाने ढंग से सटीक होते हैं, और print()स्वचालित रूप से नई सूची बनाते हैं।

@Jakub और @ Sp3000 और @wnnmaw के लिए धन्यवाद! मैं वास्तव में बहुत अजगर नहीं जानता, केवल मुझे लगता है कि मुझे पता था कि यह मनमाने आकार पूर्णांक =) का समर्थन करता है

k=1
while 1:print(k);k+=1

— flawr
स्रोत

1पायथन (और अधिकांश अन्य भाषाओं) में एक सत्य मूल्य है। इतना while 1:काफी है।

— जकुबे

इसके अलावा, आप पूरे whileको एक लाइन पर रख सकते हैं

— Sp3000

आप repr(k)इसके बजाय का उपयोग करके एक बाइट बचा सकते हैं print(k)। इसके अलावा, मैं आपके बाइट का आकार 25 के रूप में गिनता हूं (मेरे सुझाए गए बदलाव के बिना)

— wnnmaw

1

आप reprइसके बजाय उपयोग नहीं कर सकते print। reprकुछ भी आउटपुट नहीं करता है। @wnnmaw

— गेट्स

reprफिर क्या करता है?

— 19

6

प्रसंस्करण , 95 85 71 बाइट्स

java.math.BigInteger i;{i=i.ZERO;}void draw(){println(i=i.add(i.ONE));}

मैं थोड़ी देर के पाश के साथ कुछ करने की कोशिश की, लेकिन यह सभी प्रसंस्करण के दुर्घटना का कारण बनता है, तो मैं अब के लिए इस के साथ रहना होगा।

(सुझावों के लिए @ SuperJedi224 और @TWiStErRob को धन्यवाद।)

— geokavel
स्रोत

रिक्त स्थान के साथ क्या है? मुझे पूरा यकीन है कि import java.math.*;BigInteger i=BigInteger.ZERO;void draw(){println(i=i.add(BigInteger.ONE));}काम करेगा।

— SuperJedi224

हाँ, बस यह तय है।

— जियोकॉवेल

क्या प्रसंस्करण BigInteger.ONEको बदलने की अनुमति देता है i.ONE?

— SuperJedi224

@ SuperJedi224 हाँ, यह करता है। धन्यवाद!

— १६:१५ पर जियोकॉवेल

ठीक है, एक उत्थान है।

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

6

सामौ , 2 बाइट्स

N)

स्पष्टीकरण:

N     push the infinite list [0 1 2 ...] onto the stack
 )    increase by 1

जब किसी प्रोग्राम का आउटपुट एक सूची होता है, तो सबसे बाहरी कोष्ठक छोड़ दिए जाते हैं।

— alephalpha
स्रोत

क्या कोई सूची एक बार में अपनी सभी सामग्री नहीं छापती है? यदि यह सूची अनंत है , तो यह संभवतः मेमोरी में या आपकी स्क्रीन पर फिट नहीं हो सकता है , और यह कभी भी उत्पन्न होना बंद नहीं करेगा, इसलिए यह कभी भी प्रिंट नहीं होगा।

— बिल्ली 15

1

@cat सामाउ हास्केल में लिखा गया है, और यह आलसी है । इसे छापने से पहले पूरी सूची तैयार नहीं की जाएगी।

— एलेफाल्फा

बिलकुल चौकन्ना। समाउ के लिए गीथहब पृष्ठ पर @, "पुश" गलत है।

— कैरिजनेट

@Carcigenicate धन्यवाद।

— alephalpha

6

जावास्क्रिप्ट (ईएस 6), 99 94 67 बाइट्स

for(n=[i=0];;)(n[i]=-~n[i++]%10)&&alert([...n].reverse(i=0).join``)

alertआमतौर पर STDOUTजावास्क्रिप्ट के लिए समान रूप से स्वीकार किया जाता है लेकिन इसका उपयोग करने का मतलब है कि लगातार संख्याएं स्वचालित रूप से अलग हो जाती हैं। मैंने यह मान लिया है कि संख्या के बाद किसी वर्ण को आउटपुट करना आवश्यक नहीं है क्योंकि यह है।

— user81655
स्रोत

12

यही कारण है कि मेरे पास एक पॉप-अप अवरोधक है।

— कॉमिन्टेन

1

बस कह रही: (i = 0 ;;) चेतावनी (i ++) मुझे नहीं लगता कि आप उन नियंत्रणों के सभी की आवश्यकता क्यों है

— towc

3

@towc जो काम नहीं करेगा। सभी संख्याएँ जावास्क्रिप्ट में 64 बिट फ़्लोट हैं जिनका अधिकतम सुरक्षित पूर्णांक मान है, 2^53लेकिन प्रश्न के लिए इसे ऊपर जाने की आवश्यकता है 2^128।

— user81655

1

ओह, उचित बिंदु ...

— 14

5

मतलाब, 132 बाइट्स

a=0;while 1;b=a==9;n=find(cumsum(b)-(1:numel(b)),1);a(n)=a(n)+1;a(1:n-1)=0;if ~numel(n);a=[0*a,1];end;disp([a(end:-1:1)+'0','']);end

ठीक है, मुझे लगता है कि यह पहला गंभीर जवाब है जो बिना किसी तुच्छ निर्मित किए हुए आकार के पूर्णांक के बिना इस कार्य को पूरा करता है। यह कार्यक्रम पूर्णांक के एक सरणी के रूप में एक मनमाना आकार पूर्णांक लागू करता है। प्रत्येक पूर्णांक हमेशा 0 और 9 के बीच होता है, इसलिए प्रत्येक सरणी तत्व एक दशमलव अंक का प्रतिनिधित्व करता है। जैसे ही हम जैसे हैं, सरणी आकार wil को एक-एक करके बढ़ाया जाना चाहिए 999। स्मृति का आकार यहाँ कोई समस्या नहीं है, क्योंकि 2^128केवल लंबाई 39 की एक सरणी की आवश्यकता है।

a=0;
while 1
    b=a==9;
    %first number that is not maxed out
    n=find(cumsum(b)-(1:numel(b)),1);
    %increase that number, and sett all maxed out numbers to zero
    a(n)=a(n)+1; 
    a(1:n-1)=0;
    if ~numel(n) %if we maxed out all entries, add another digit
        a=[0*a,1];
    end    
    disp([a(end:-1:1)+'0',''])%print all digits
end

— flawr
स्रोत

5

सी ++, 146 141 138 बाइट्स

एक मानक बिगिंट लाइब्रेरी का उपयोग करना शायद इस सवाल का जवाब देने का सबसे उबाऊ तरीका है, लेकिन किसी को यह करना था।

#include<stdio.h>
#include<boost/multiprecision/cpp_int.hpp>
int main(){for(boost::multiprecision::uint512_t i=1;;){printf("%u\n",i++);}}

Ungolfed:

#include<cstdio>
#include<boost/multiprecision/cpp_int.hpp>

int main()
{
    for(boost::multiprecision::uint512_t i=1;;)
    {
        std::printf("%u\n", i++);
    }
}

कारण गोल्फ संस्करण का उपयोग करता है stdio.hऔर नाम स्थान cstdioका उपयोग करने से बचने के लिए नहीं है std::।

यह C ++ में मेरा पहली बार गोल्फिंग है, मुझे बताएं कि क्या आगे इसे छोटा करने के लिए कोई चाल है।

— felixphew
स्रोत

शायद आप '\n'इसके बजाय उपयोग कर सकते हैं std::endl, आपको 8 बाइट्स बचाएगा। कुछ पुनरावृत्ति को संपीड़ित करने के लिए CPP #define का उपयोग करने का एक तरीका भी हो सकता है,

— केनी

@Kenney इसके लिए धन्यवाद! (यह केवल 5 बाइट्स बचाता है, 8. नहीं।) मुझे लगता है कि मैं उस अनुभाग को छोटा करने का एक तरीका भी ले सकता हूं, हालांकि।

— felixphew 3:15

मैं बूस्ट को नहीं जानता (और मैं यह नहीं कहूंगा कि यह मानक भी है) लेकिन iडिफ़ॉल्ट रूप से 0 के मूल्य के साथ निर्मित नहीं है ? फिर आप परिभाषा को अलग कर सकते हैं और प्रीसिनेरेमेंट के लिए पोस्टिंक्रेमेंट को स्विच कर सकते हैं जो 2 बी को बचाएगा

— ज़ेरेगेस

वंचितों के बारे में कैसे #import?

— संयोजक जूल

5

C # .NET 4.0, 111 103 102 97 बाइट्स

class C{static void Main(){System.Numerics.BigInteger b=1;for(;;)System.Console.WriteLine(b++);}}

मुझे यहाँ कोई C # उत्तर नहीं मिला, इसलिए मुझे सिर्फ एक लिखना था।

.NET 4.0 की आवश्यकता है, क्योंकि यह पहला संस्करण है जिसमें BigInteger शामिल है । आपको हालांकि System.Numerics.dll का संदर्भ देना होगा ।

इंडेंटेशन के साथ:

class C
{
    static void Main()
    {   
        System.Numerics.BigInteger b = 1;
        for (;;)
            System.Console.WriteLine(b++);
    }
}

कुछ बाइट्स को बचाने के लिए स्वारपोतो, क्वाम, बेरेन्ड का धन्यवाद

— Kazarp
स्रोत

आप के साथ 8 बाइट्स बचा सकते हैं class C{static void Main(){var b=System.Numerics.BigInteger.One;for(;;)System.Console.WriteLine(b++);}}: ~)!

— स्वेरापॉटो

1

ख और Console.WriteLineलूप संरचना में घोषणा को आगे class C{static void Main(){for(var b=System.Numerics.BigInteger.One;;Console.WriteLine(b++));}}

— बढ़ाएं

तुम अब भी जरूरत है System। हालांकि एक बाइट बचाता है!

— स्वेरापॉटो

हां आप ठीक हैं।

— क्वांम

यदि आप using System;(13 बाइट्स) जोड़ते हैं तो आप System.1 बाइट बचाकर दो बार (7 बाइट्स) कर सकते हैं ।

— केनी

5

क्लोजर, 17 बाइट्स

(map prn (range))

आलसी क्रम और मनमाने ढंग से सटीक पूर्णांक यह आसान बनाते हैं (जैसे हास्केल और सीएल के लिए)। prnमुझे कुछ बाइट्स बचाता है क्योंकि मुझे एक प्रारूप स्ट्रिंग को प्रिंट करने की आवश्यकता नहीं है। doseqशायद अधिक मुहावरेदार होगा क्योंकि यहाँ हम केवल साइड इफेक्ट्स के साथ काम कर रहे हैं; mapइसका उपयोग करने के लिए बहुत अधिक समझदारी नहीं है क्योंकि यह nil(जो प्रत्येक prnकॉल का रिटर्न मान है) का एक अनुक्रम बनाएगा ।

मान लें कि मैं हमेशा के लिए गिनता हूं, तो इस ऑपरेशन के परिणामस्वरूप होने वाला अशक्त सूचक अनुक्रम कभी वापस नहीं आता है।

— MONODA43
स्रोत

4

मारियोलेन , 11 बाइट्स

+<
:"
>!
=#

एक अन्य प्रश्न में मार्टिन बंटनर के जवाब से प्रेरित ।

— alephalpha
स्रोत

क्या आप सुनिश्चित हैं कि यह समस्याओं के बिना 2 ^ 128 पर काम करता है?

— दोष

1

यह परिचित लग रहा है। :)

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

@flawr MarioLANG में एक रूबी दुभाषिया है, और रूबी के पूर्णांक प्रकार में मनमाना परिशुद्धता है।

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

@flawr यह दुभाषिया पर निर्भर करता है। मैं जिस दुभाषिया का उपयोग कर रहा हूं वह रूबी में लिखा गया है, और यह मनमाना परिशुद्धता का समर्थन करता है।

— एलेफाल्फा

4

सीजेएम, 7 बाइट्स

0{)_p}h

स्पष्टीकरण:

0         e# Push a zero to the stack
 {        e# Start a block
  )         e# Increment top of stack
   _        e# Duplicate top of stack
    p       e# Print top of stack
     }    e# End block
      h   e# Do-while loop that leaves the condition on the stack

नोट: जावा दुभाषिया का उपयोग करना चाहिए।

— GamrCorps
स्रोत

4

सी, 89 बाइट्स

C में एक नया दृष्टिकोण (एक बिटवाइस इन्क्रीमेंट लागू करने वाला):

b[999],c,i;main(){for(;;)for(i=c=0,puts(b);i++<998;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}

कम गोल्फ वाला

int b[999], c, i;
main() {
  for(;;)
    for(i=c=0, puts(b); i++ < 998;)
      putchar(48 + (c ? b[i] : (b[i] = c = !b[i])));
}

बर्खास्त

इस संस्करण में मामूली दोष है, कि यह समाप्त नहीं होता है (जो इस समय आवश्यकता नहीं है)। ऐसा करने के लिए आपको 3 वर्ण जोड़ने होंगे:

b[129],c=1,i;main(){for(;c;)for(i=c=0,puts(b);i++<128;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}

— Helco
स्रोत

4

वास्तव में इसे समाप्त नहीं करना चाहिए। इसका अर्थ हैforever

— edc65

4

फू , 6 बाइट्स

(+1$i)

व्याख्या

(    )    Loop
 +1       Add one to current element
   $i     Output current element as a decimal integer

— Zach गेट्स
स्रोत

4

मिंकोलंग , 4 बाइट्स

1+dN

इसे यहाँ आज़माएँ। (ठीक है, वास्तव में, सावधान रहें। रन समय के 3 सेकंड ~ 40,000 तक पहुंचने के लिए पर्याप्त थे।)

1+स्टैक के शीर्ष पर 1 जोड़ता है, dइसे डुप्लिकेट करता है, और Nएक अनुगामी स्थान के साथ पूर्णांक के रूप में स्टैक के शीर्ष को आउटपुट करता है। यह लूप्स है क्योंकि मिंकोलंग टॉरॉयडल है, इसलिए जब प्रोग्राम काउंटर दाएं किनारे से चला जाता है, तो यह बाईं ओर फिर से दिखाई देता है।

— एलेंडिया स्ट्राटन
स्रोत

4

इंटेल 8086+ असेंबली, 19 बाइट्स

68 00 b8 1f b9 08 00 31 ff f9 83 15 00 47 47 e2 f9 eb f1

यहाँ एक ब्रेकडाउन है:

68 00 b8                push   0xb800             # CGA video memory
1f                      pop    ds                 # data segment
b9 08 00           L1:  mov    cx, 8              # loop count
31 ff                   xor    di, di             # ds:di = address of number
f9                      stc                       # set carry
83 15 00           L2:  adc    word ptr [di], 0   # add with carry
47                      inc    di
47                      inc    di
e2 f9                   loop   L2
eb f1                   jmp    L1

यह टॉप-लेफ्ट 8 स्क्रीन पोजिशन पर 128 बिट नंबर आउटपुट करता है। प्रत्येक स्क्रीन स्थिति 8-बिट ASCII वर्ण और दो 4 बिट रंग रखती है।

नोट: यह लगभग ¹²⁸ पर लपेटता है ; बस बदलने 8में mov cx, 8करने के लिए 9एक 144 बिट संख्या दिखाने के लिए, या भी 80*252 अप करने के लिए संख्या दिखाने के लिए ³²⁰⁰⁰ ।

चल रहा है

1.44Mb bzip2 संकुचित, base64 एन्कोडेड बूट करने योग्य फ़्लॉपी छवि

निम्नलिखित को कॉपी-पेस्ट करके फ्लॉपी छवि बनाएं

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

इस कमांडलाइन में:

base64 -d | bunzip2 > floppy.img

और, उदाहरण के लिए, qemu -fda floppy.img -boot a

1.8 एमबी बूट करने योग्य आईएसओ

यह एक बेस 64 एनकोडेड bzip2 कंप्रेस्ड ISO इमेज है। आइसो पेस्ट करके उत्पन्न करें

QlpoOTFBWSZTWZxLYpUAAMN/2//fp/3WY/+oP//f4LvnjARo5AAQAGkAEBBKoijAApcDbNgWGgqa
mmyQPU0HqGCZDQB6mQ0wTQ0ZADQaAMmTaQBqekyEEwQaFA0AA0AxBoAAA9Q0GgNAGg40NDQ0A0Bi
BoDIAANNAA0AyAAABhFJNIJiPSmnpMQDJpp6nqeo0ZDQaAANB6IA0NAGj1EfIBbtMewRV0acjr8u
b8yz7cCM6gUUEbDKcCdYh4IIu9C6EIBehb8FVUgEtMIAuvACCiO7l2C0KFaFVABcpglEDCLmQqCA
LTCAQ5EgnwJLyfntUzNzcooggr6EnTje1SsFYLFNW/k+2BFABdH4c4vMy1et4ZjYii1FbDgpCcGl
mhZtl6zX+ky2GDOu3anJB0YtOv04YISUQ0JshGzAZ/3kORdb6BkTDZiYdBAoztZA1N3W0LJhITAI
2kSalUBQh60i3flrmBh7xv4TCMEHTIOM8lIurifMNJ2aXr0QUuLDvv6b9HkTQbKYVSohRPsTOGHi
isDdB+cODOsdh31Vy4bZL6mnTAVvQyMO08VoYYcRDC4nUaGGT7rpZy+J6ZxRb1b4lfdhtDmNwuzl
E3bZGU3JTdLNz1uEiRjud6oZ5kAwqwhYDok9xaVgf0m5jV4mmGcEagviVntDZOKGJeLjyY4ounyN
CWXXWpBPcwSfNOKm8yid4CuocONE1mNqbd1NtFQ9z9YLg2cSsGQV5G3EhhMXKLVC2c9qlqwLRlw4
8pp2QkMAMIhSZaSMS4hGb8Bgyrf4LMM5Su9ZnKoqELyQTaMAlqyQ3lzY7i6kjaGsHyAndc4iKVym
SEMxZGG8xOOOBmtNNiLOFECKHzEU2hJF7GERK8QuCekBUBdCCVx4SDO0x/vxSNk8gKrZg/o7UQ33
Fg0ad37mh/buZAbhiCIAeeDwUYjrZGV0GECBAr4QVYaP0PxP1TQZJjwT/EynlkfyKI6MWK/Gxf3H
V2MdlUQAWgx9z/i7kinChITiWxSo

में

base64 -d bunzip2 > cdrom.iso

और इससे बूट करने के लिए एक वर्चुअल मशीन को कॉन्फ़िगर करें।

डॉस .COM

यह एक बेस 64 एनकोडेड DOS .COM निष्पादन योग्य है:

aAC4H7kIADH/+YMVAEdH4vnr8Q==

एक .COM फ़ाइल का उपयोग करके उत्पन्न करें

/bin/echo -n aAC4H7kIADH/+YMVAEdH4vnr8Q== | base64 -d > COUNTUP.COM

और इसे (फ्री) डॉस में चलाएं।

— केनी
स्रोत

4

पर्ल , 34 32 30 28 26 23 बाइट्स

-Mbigint -E '{say$_+=1;redo}'

के साथ टेस्ट करें

perl -Mbigint -E '{say$_+=1;redo}'

— केनी
स्रोत

आप बदल सकते हैं for(,,){...}के साथ {...;redo}दो लोगों के लिए।

— प्रिमो

हां मैंने देखा (पर्ल 5.18+), लेकिन मुझे लगा कि यह धोखा हो सकता है; तब उत्तर समान होंगे। मैं यहाँ नया हूँ, ;-)

— केनी

1

स्केलर संदर्भों को स्वतः-विभक्त किया जाएगा SV UNDEF, जो कि जब बढ़े हुए BigIntअधिभार को ट्रिगर नहीं करेगा - क्योंकि यह ए नहीं है BigInt। हालांकि, इंटीग्रल शाब्दिक, BigIntएस के रूप में बनाए जाते हैं । वास्तव में इतना अजीब नहीं;)

— प्रिमो

1

क्या आप $-इसे पूर्णांक के रूप में रखने और उपयोग करने के लिए वापस आ सकते हैं ++$-?

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

1

@DomHastings के साथ मैंने परीक्षण किया perl -Mbigint -E '{say++$-;$-+=$-;redo}' | moreऔर यह लगभग 1 को लपेटता है। यह एक इंट रहता है लेकिन बिगिन में कदम नहीं होता है, दुर्भाग्य से।

— केनेई

4

मारबेलस, 358 बाइट्स

..@F..@E..@D..@C..@B..@A..@9..@8..@7..@6..@5..@4..@3..@2..@1..@001@Z01
..AddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddo/\&I
00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I....@Z
@FHd@EHd@DHd@CHd@BHd@AHd@9Hd@8Hd@7Hd@6Hd@5Hd@4Hd@3Hd@2Hd@1Hd@0Hd
0A@N
..&I
@N/\..
:Hd
}0
Hp
}0
..
{<
#include hex_out.mbl
#include arithmetic.mbl

16 आधे योजक एक साथ जंजीर से बंधे हुए हैं, जो प्रत्येक चक्र में N ++ और प्रत्येक योजक अपने अतिप्रवाह (00 या 01) को खिलाते हैं। आउटपुट हेक्स में है।

अजगर दुभाषिया में एक बग होता है जहां ज्ञापन कार्यों से आउटपुट खो जाता है, इसलिए आपको इसे सही काम करने के लिए "-m 0" के साथ चलाना होगा। उस पैरामीटर के बिना आप देख सकते हैं कि बग के बिना यह कितनी तेजी से चलेगा, लेकिन आउटपुट सही काम नहीं करेगा।

~~स्वयं पर ध्यान दें: उस बग को marbelous.py में ठीक करें। यह बग marbelous.py~~ के नवीनतम संस्करण में तय किया गया है

— Sparr
स्रोत

4

आर, 52 बाइट्स

a=gmp::as.bigz(1);repeat{cat(paste(a,""));a=a+1}

(नोट: gmpएक बाहरी पुस्तकालय है, इसलिए आपको इस समाधान के लिए इसे डाउनलोड करना पड़ सकता है)

— SnoringFrog
स्रोत

1

+1 ... सभी एक्स्ट्रा के बारे में क्षमा करें। आपको वापस पाने के लिए आप कोशिश कर सकते हैं a=gmp::as.bigz(0);repeat{cat(paste(a<-a+1,''))}। आप एक नोट बनाना चाहते हैं जो gmpएक बाहरी पुस्तकालय है जिसे डाउनलोड करने की आवश्यकता हो सकती है।

— मिक्यट

44 बाइट्स :)

— ग्यूसेप

4

बॉटजीन, 128 120 112 8x13 = 104

v2 2 01
>e>S SS
   e1e1
   e2 e0 12
   > > S SS P
  ^   <e0e1 R
     ^ < <lC^
^         <

आउटपुट बाइनरी में है।

— SuperJedi224
स्रोत

हमेशा के लिए गिनती

सूची

भूलभुलैया , 5 बाइट्स

> <> , 8 बाइट्स

हास्केल, 21 बाइट्स

गोल> <> , 3 बाइट्स

मारबेलस , 11450 4632 बाइट्स

सी (64-बिट आर्किटेक्चर केवल), 53 बाइट्स

हेक्सागोनी , 12 11 10 7 बाइट्स

अजगर, 4 बाइट्स

स्पष्टीकरण:

ई.पू., १०

जावा, 139 138 127 123 बाइट्स

गणितज्ञ, 22 बाइट्स

रूबी, 15 12 बाइट्स

पायथन 3, 33 25 बाइट्स

प्रसंस्करण , 95 85 71 बाइट्स

सामौ , 2 बाइट्स

जावास्क्रिप्ट (ईएस 6), 99 94 67 बाइट्स

मतलाब, 132 बाइट्स

सी ++, 146 141 138 बाइट्स

C # .NET 4.0, 111 103 102 97 बाइट्स

क्लोजर, 17 बाइट्स

मारियोलेन , 11 बाइट्स

सीजेएम, 7 बाइट्स

सी, 89 बाइट्स

फू , 6 बाइट्स

व्याख्या

मिंकोलंग , 4 बाइट्स

इंटेल 8086+ असेंबली, 19 बाइट्स

चल रहा है

1.44Mb bzip2 संकुचित, base64 एन्कोडेड बूट करने योग्य फ़्लॉपी छवि

1.8 एमबी बूट करने योग्य आईएसओ

डॉस .COM

पर्ल , 34 32 30 28 26 23 बाइट्स

मारबेलस, 358 बाइट्स

आर, 52 बाइट्स

बॉटजीन, 128 120 112 8x13 = 104