1, 2, फ़िज़, 4, बज़


148

परिचय

मानक प्रोग्रामिंग अभ्यासों के लिए सबसे छोटे समाधानों के कैटलॉग को इकट्ठा करने के हमारे हालिया प्रयास में, यहां पीपीसीजी की पहली वनीला फ़िज़बज़ू चुनौती है। यदि आप अन्य कैटलॉग चुनौतियों को देखना चाहते हैं, तो "हैलो वर्ल्ड!" और "क्या यह संख्या एक प्रमुख है?"

चुनौती

एक प्रोग्राम लिखें जो दशमलव संख्या को 1 से 100 तक सम्मिलित करता है। लेकिन संख्या के बजाय तीन प्रिंट "फ़िज़" के गुणकों के लिए और पाँच प्रिंट "बज़" के गुणकों के लिए। उन संख्याओं के लिए जो तीन और पाँच दोनों के गुणक हैं, "FizzBuzz" प्रिंट करें।

उत्पादन

उत्पादन संख्या (और fizzes, बज़ और FizzBuzzes) एक नई पंक्ति (या तो द्वारा अलग की एक सूची हो जाएगा \nया \r\n)। एक अनुगामी न्यूलाइन स्वीकार्य है, लेकिन एक अग्रणी न्यूलाइन नहीं है। न्यूलाइन की अपनी पसंद के अलावा, आउटपुट बिल्कुल इस तरह दिखना चाहिए:

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
Fizz
22
23
Fizz
Buzz
26
Fizz
28
29
FizzBuzz
31
32
Fizz
34
Buzz
Fizz
37
38
Fizz
Buzz
41
Fizz
43
44
FizzBuzz
46
47
Fizz
49
Buzz
Fizz
52
53
Fizz
Buzz
56
Fizz
58
59
FizzBuzz
61
62
Fizz
64
Buzz
Fizz
67
68
Fizz
Buzz
71
Fizz
73
74
FizzBuzz
76
77
Fizz
79
Buzz
Fizz
82
83
Fizz
Buzz
86
Fizz
88
89
FizzBuzz
91
92
Fizz
94
Buzz
Fizz
97
98
Fizz
Buzz

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

आगे के नियम

  • यह FizzBuzz खेलने के लिए सबसे छोटे दृष्टिकोण के साथ भाषा खोजने के बारे में नहीं है, यह हर भाषा में सबसे छोटा दृष्टिकोण खोजने के बारे में है। इसलिए, कोई जवाब स्वीकार के रूप में चिह्नित नहीं किया जाएगा।

  • सबमिशन को बाइट्स में एक उपयुक्त preexisting एन्कोडिंग में बनाया जाता है, आमतौर पर (लेकिन जरूरी नहीं) UTF-8। कुछ भाषाएं, जैसे कि फ़ोल्डर, स्कोर करने के लिए थोड़ा मुश्किल है - यदि संदेह है, तो कृपया मेटा पर पूछें।

  • STDERR को कुछ भी नहीं छापा जा सकता है।

  • हमारे सामान्य नियमों के विपरीत, एक भाषा (या भाषा संस्करण) का उपयोग करने के लिए स्वतंत्र महसूस करें, भले ही यह इस चुनौती से नया हो। यदि कोई भी ऐसी भाषा बनाकर इसका दुरुपयोग करना चाहता है, जहां खाली कार्यक्रम FizzBuzz आउटपुट उत्पन्न करता है, तो बहुत ही उबाऊ उत्तर के लिए मार्ग प्रशस्त करने के लिए बधाई देता है।

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

  • अगर आपकी पसंद की भाषा दूसरी (संभावित रूप से अधिक लोकप्रिय) भाषा का एक तुच्छ संस्करण है, जिसमें पहले से ही एक उत्तर है (बेसिक या एसक्यूएल बोलियों, यूनिक्स गोले या अल्फाक और ???) की तरह तुच्छ ब्रेनफॉक डेरिवेटिव (विचार करें), मौजूदा नोट पर एक नोट जोड़ने पर विचार करें? उत्तर दें कि समान या बहुत समान समाधान दूसरी भाषा में भी सबसे छोटा है।

  • क्योंकि आउटपुट तय है, आप आउटपुट को हार्डकोड कर सकते हैं (लेकिन यह सबसे छोटा विकल्प नहीं हो सकता है)।

  • जब तक आप कार्यक्रम के मूल लेखक को श्रेय देते हैं, तब तक आप समाधान का उपयोग कर सकते हैं।

  • मानक कमियां अन्यथा अस्वीकृत हैं।

एक साइड नोट के रूप में, कृपया उन भाषाओं में उबाऊ (लेकिन मान्य) उत्तर न दें जहां गोल्फ के लिए बहुत कुछ नहीं है; ये अभी भी इस प्रश्न के लिए उपयोगी हैं क्योंकि यह एक कैटलॉग को यथासंभव पूरा करने का प्रयास करता है। हालांकि, मुख्य रूप से उन भाषाओं में जवाब देते हैं जहां लेखकों को वास्तव में कोडिंग में प्रयास करना पड़ता था।

सूची

var QUESTION_ID=58615;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var OVERRIDE_USER=30525;var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=true,comment_page;function answersUrl(index){return"https://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"https://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(),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)}}
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:700}table td{padding:5px}
<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>


1
Nothing can be printed to STDERR. क्या यह सच है कि केवल दौड़ते समय, या संकलन करते समय भी (यह मानते हुए कि एक अलग कदम है?)
AS47

@ केवल जब चल रहा हो
बीटा डिके

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

6
@Timwi जबकि मैं मानता हूं कि यह इसे (केवल थोड़ा) अधिक दिलचस्प बना देगा, मैंने बहुत बार FizzBuzz को सख्ती से 1 से 100 के रूप में देखा है (उदाहरण के लिए, विकिपीडिया और रोसेटा कोड पर)। यदि लक्ष्य "विहित" एफबी चुनौती है, तो यह समझ में आता है।
जॉयबिट्स

58
एक "वेनिला फ़िज़बज़्ज़" स्वादिष्ट लगता है।
१५:१५

जवाबों:


76

अजगर 2, 56

i=0;exec"print i%3/2*'Fizz'+i%5/4*'Buzz'or-~i;i+=1;"*100

6
डांग, यह खूनी प्रतिभा है। क्या मैं मॉड-रिजल्ट द्वारा स्ट्रिंग को गुणा करने के लिए आपके विचार को चुरा सकता हूं?
AdmBorkBork

@TimmyD आगे बढ़ो।
फ़ेर्सुम

15
56 के लिए एक अलग विधि ( यहाँ से ) i=1;exec"print'FizzBuzz'[i%-3&4:12&8-i%5]or i;i+=1;"*100:। किसी को भी कोसने के लिए प्रयास करने के लिए बल अभिव्यक्ति खोज भंगुर करना चाहते हैं?
xnor

1
बहुत अच्छी तकनीक, मैं इसे द्विआधारी बनाने के लिए मॉडुलो परिणाम के विभाजन से प्यार करता हूं! मेरे पास आपकी विधि को 54 वर्णों तक ले जाने के लिए सुधार है ... निश्चित रूप से मैं इसे आपकी अनुमति के बिना उत्तर के रूप में पोस्ट नहीं करूंगा (क्योंकि यह ~ 95% आपका उत्तर है);)
टेरोसॉरोस

2
@Tersosauros आगे बढ़ें ... मेरी विधि खोजने के लिए बहुत कठिन नहीं है और कई लोगों द्वारा स्वतंत्र रूप से खोज की गई कोई संदेह नहीं है।
फ़ेरसम

76

हेक्सागोनी , 91 बाइट्स

इनाम के लिए धन्यवाद :)

वाह, मैंने कभी सोचा नहीं होगा कि मैं मार्टिन के हेक्सागोनी समाधान को हरा सकता हूं । लेकिन - यह कौन होगा - मैंने इसे पूरा किया। कई दिनों की विफलता के बाद क्योंकि मेरे पास न तो हेक्सागोनी रंगकर्मी था और न ही मेरे समाधान की जांच करने के लिए एसोटेरिकाइड । मुझे विनिर्देशन के कई पहलू गलत लगे, इसलिए मैंने सिर्फ कलम और कागज और एक पाठ संपादक का उपयोग करके कुछ गलत "समाधान" का उत्पादन किया। खैर, आखिरकार मैंने अपने आलस्य पर काबू पा लिया और दोनों रिपॉजिटरी को क्लोन किया, विजुअलस्टडियो डाउनलोड किया और उन्हें संकलित किया। वाह, वे कौन से उपयोगी उपकरण हैं! जैसा कि आप देख सकते हैं, मैं किसी ऐसे व्यक्ति के होने से बहुत दूर हूं जिसे आप प्रोग्रामर कहेंगे (मेरा मतलब है, चलो! मैंने विजुअलस्टडियो भी स्थापित नहीं किया है, और प्रोग्राम को संकलित करने के तरीके के बारे में बहुत कुछ पता नहीं है);)

काम करने का हल ढूंढने में मुझे अभी भी कुछ समय लगा है, और यह काफी चरमराया हुआ और अव्यवस्थित है, लेकिन यहाँ यह अपनी महिमा में है:

Fizzbuzz एक आकार 6 षट्भुज में:

3}1"$.!$>)}g4_.{$'))\<$\.\.@\}F\$/;z;u;<%<_>_..$>B/<>}))'%<>{>;e"-</_%;\/{}/>.\;.z;i;..>(('

हेक्सागोनल लेआउट:

      3 } 1 " $ .
     ! $ > ) } g 4
    _ . { $ ' ) ) \
   < $ \ . \ . @ \ }
  F \ $ / ; z ; u ; <
 % < _ > _ . . $ > B /
  < > } ) ) ' % < > {
   > ; e " - < / _ %
    ; \ / { } / > .
     \ ; . z ; i ;
      . . > ( ( '

और सुंदर गायन, टिमवी के हेक्सागोनी कलरर के लिए धन्यवाद :

रंगीन हेक्सागोनी FizzBuzz समाधान

तो, यहाँ 2 एफपीएस पर 110 सेकंड लंबा जीआईएफ एनीमेशन है, पहले 6 नंबरों के दौरान कार्यक्रम का प्रवाह दिखाते हुए, कार्यक्रम 1, 2, Fizz, 4, Buzz, Fizzके पहले 220 टिक (पूर्ण आकार के लिए छवि पर क्लिक करें):

यहां छवि विवरण दर्ज करें

मेरी अच्छाई, नैट्रॉन कंपोज़िटिंग सॉफ़्टवेयर के लिए धन्यवाद सूचक का एनीमेशन अभी भी बनाने के लिए थकाऊ था, लेकिन प्रबंधनीय था। मेमोरी की 260 छवियों को सहेजना कम मनोरंजक था। दुर्भाग्य से EsotericIDE स्वचालित रूप से ऐसा नहीं कर सकता है। वैसे भी, एनीमेशन का आनंद लें!

आखिरकार, एक बार जब आप मेमोरी मॉडल के चारों ओर अपना सिर लपेटते हैं और हेक्सागोन की सीमाओं को पार करने वाले रास्तों के काउंटरपिन्युएटिव रैपिंग, हेक्सागोनी के साथ काम करना उतना मुश्किल नहीं है। लेकिन इसे गोल्फ में लगाने से बट में दर्द हो सकता है। ;)

वह मज़ेदार था!


1
बहुत अच्छा! :) यही तो है कि मैं अपने आप को साइड-लेंथ 6 ट्राई करना भूल जाता हूँ। ;) (यह देखने के लिए दिलचस्प होगा कि क्या मेरा समाधान पक्ष-लंबाई 6 में अधिक आसानी से फिट बैठता है।)
मार्टिन एंडर

@ मार्टिनबटनर मैं इसे देखना पसंद करूंगा :)
ML

2
मैं आपसे एक प्रोग्रामर से कम हूं, क्योंकि विजुअल स्टूडियो क्या है? : P
R

5
दुर्भाग्य से EsotericIDE स्वचालित रूप से ऐसा नहीं कर सकता है। - कृपया सही से आगे बढ़ें और एक फीचर सुझाव दें , मैं किसी दिन ऐसा करने के लिए तैयार हो सकता हूं :)
तिमवी

1
(उफ़ यह अंतिम उत्तर के 6 महीने बाद आता है) आप 1 बाइट से ग्रे पथ को शिफ्ट करके और ऑरेंज पथ में "कैंसलिंग ऑप" रख कर कार्यक्रम के अंत से 1 बाइट को गोल्फ कर सकते हैं। 3}1"$.!$>)}g4_'{$))}\<$\.\.@\;F\$/;z;u;<%<_>_..$>B/<>}))'%<>{>;e"-</_%;\/{}/>.\)(z;i;..>('अब एक अतिरिक्त है। (z के बाद, जिसे "रद्द" किया जा सकता है) या z डालकर। अब यह एक) है जो नारंगी मार्ग 1 पर सभी आदेशों को बाद में धकेलता है, और पंक्ति 3 पर नो-ऑप के साथ वापस आ गया है। Btw मैंने भी हेक्सागोनी कलरर और एसोटेरिक आईडीई के कारण विजुअल स्टूडियो स्थापित किया है: पी
सनी पुन

44

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

"):_1
\ } 01/3%70.105
" :   @ "     .
"  =";_""..:221
+  _
"! 5%66.117
_:= "     .
="*{"..:221

उप-100! यह एक मजेदार था।

व्याख्या

चलो भूलभुलैया पर एक संक्षिप्त प्राइमर के साथ शुरू करते हैं - यदि आप पहले से ही मूल बातों से परिचित हैं, तो इसे छोड़ने के लिए स्वतंत्र महसूस करें:

  • भूलभुलैया के दो ढेर हैं - एक मुख्य ढेर और एक सहायक ढेर। दोनों स्टैक में नीचे की ओर अनंत संख्या में शून्य होते हैं, जैसे +कि एक खाली स्टैक पर दो शून्य होते हैं, इस प्रकार शून्य को धक्का लगता है।

  • लेबिरिंथ में नियंत्रण प्रवाह का निर्णय जंक्शनों द्वारा किया जाता है, जो आगे जाने के लिए निर्धारित करने के लिए स्टैक के शीर्ष पर देखते हैं। नकारात्मक का अर्थ है बाएं मुड़ना, शून्य का मतलब सीधे आगे बढ़ना और सकारात्मक का मतलब दाएं मुड़ना ... लेकिन अगर हम एक दीवार से टकराते हैं तो हम दिशा को उलट देते हैं। उदाहरण के लिए, यदि केवल सीधे आगे और बाएं मुड़ना संभव है, लेकिन ढेर का शीर्ष सकारात्मक है, तो चूंकि हम दाएं मुड़ नहीं सकते हैं इसलिए हम इसके बजाय बाएं मुड़ते हैं।

  • लेबिरिंथ पॉप xऔर पुश में अंक 10*x + <digit>, जो बड़ी संख्या का निर्माण करना आसान बनाता है। हालांकि, इसका मतलब है कि हमें एक नया नंबर शुरू करने के लिए 0 को पुश करने के लिए एक निर्देश की आवश्यकता है, जो कि _भूलभुलैया में है।

अब वास्तविक कोड पर आते हैं!

यहां छवि विवरण दर्ज करें

लाल

निष्पादन "शीर्ष-बाएं कोने से शुरू होता है , जो एक एनओपी है। अगला है ), जो स्टैक के शीर्ष को बढ़ाता है , पहले पास पर 1 धक्का देता है और nप्रत्येक निम्नलिखित पास पर वेतन वृद्धि करता है।

अगला हम nसाथ नकल करते हैं :। चूंकि nसकारात्मक है, हम सही मोड़ लेते हैं, निष्पादन }(मुख्य स्टैक के शीर्ष को सहायक) और :। हमने एक मृत अंत मारा, इसलिए हम चारों ओर मुड़ते हैं और निष्पादित करते हैं }और :एक बार फिर, जैसे स्टैक को छोड़ते हैं

Main [ n n | n n ] Aux

एक बार फिर, nसकारात्मक है और हम दाएं मुड़ते हैं, _101/जिसे निष्पादित nकरके 101 से विभाजित किया जाता है। यदि n101 है तो n/101 = 1हम उस में बदल जाते हैं @, जो कार्यक्रम को समाप्त कर देता है। अन्यथा, हमारी वर्तमान स्थिति है

Main [ n 0 | n n ] Aux

नारंगी 1 (आधुनिक 3)

3शीर्ष शून्य को 3 में बदल देता है ( 10*0 + 3 = 3) और %मोडुलो प्रदर्शन करता है। यदि n%3सकारात्मक है, तो हम सही पीले रंग में बदल जाते हैं "। अन्यथा हम प्रदर्शन करते हैं 70.105.122:.., जो आउटपुट देता है Fizz। ध्यान दें कि हम साथ नए शून्यों पुश करने के लिए की जरूरत नहीं है _के बाद से n%3शून्य इस मामले में था, इसलिए हम ढेर के नीचे अनंत शून्य दोहन कर सकते हैं। दोनों रास्ते हल्के नीले रंग में फिर से मिलते हैं।

हल्का नीला

स्टैक का शीर्ष वर्तमान में है n%3, जो सकारात्मक हो सकता है, इसलिए _;बस एक शून्य को धक्का देता है और तुरंत यह सुनिश्चित करने के लिए पॉप करता है कि हम सीधे अंदर जाने के बजाय सीधे आगे बढ़ते हैं @। फिर हम =मुख्य और सहायक ढेर के शीर्ष को स्वैप करने के लिए उपयोग करते हैं :

Main [ n | n%3 n ] Aux

ऑरेंज 2 (मॉड 5)

यह सिवाय इसके कि, इससे पहले कि करने के लिए इसी तरह की स्थिति है 66.117.122:..आउटपुट Buzzयदि n%5शून्य है।

गहरा नीला

पिछला खंड ढेर की तरह छोड़ देता है

Main [ n%5 | n%3 n ] Aux

{बदलाव n%3मुख्य ढेर करने के लिए वापस और *दो modulos गुणा।

यदि या तो मोडुलो शून्य है, तो उत्पाद शून्य है इसलिए हम सीधे पीले में जाते हैं। =ढेर के ऊपर स्वैप करता है और _यह सुनिश्चित करने के लिए एक शून्य को धक्का देता है कि हम सीधे दे रहे हैं, दे रहे हैं

Main [ n 0 | 0 ] Aux

अन्यथा, यदि दोनों मोड्यूलर नॉनज़ेरो हैं, तो उत्पाद नॉनज़रो है और हम सही हरे रंग में बदल जाते हैं। =ढेर के शीर्ष स्वैप, दे रही है

Main [ n | (n%5)*(n%3) ] Aux

जिसके बाद हम :डुप्लिकेट करने के लिए उपयोग करते हैं n, दाएं मुड़ते हैं, फिर !आउटपुट का उपयोग करते हैं n

बैंगनी

इस बिंदु पर, मुख्य स्टैक में या तो एक या दो आइटम हैं, जिसके आधार पर पथ लिया गया था। हमें पीले रास्ते से शून्य से छुटकारा पाने की जरूरत है, और ऐसा करने के लिए हम उपयोग करते हैं +, जो n + 0दोनों मामलों के लिए कुछ क्रम में करता है। अंत में, \एक नई रूपरेखा तैयार करता है और हम शुरुआत में वापस आ जाते हैं।

प्रत्येक पुनरावृत्ति (n%5)*(n%3)सहायक स्टैक के लिए एक अतिरिक्त धक्का देती है , लेकिन अन्यथा हम फिर से वही काम करते हैं।


7
स्पष्टीकरण से प्यार करना।
The_Basset_Hound

29

पर्ल 5, 49 बाइट्स

46 बाइट्स स्क्रिप्ट + 3 बाइट्स -E"..."

उपयोग करना say(जिसकी आवश्यकता है -E"...") इसे और 46 बाइट्स तक कम कर सकता है क्योंकि sayस्वचालित रूप से एक नई पंक्ति शामिल है (धन्यवाद @ डेनिस !)।

say'Fizz'x!($_%3).Buzz x!($_%5)||$_ for 1..100

पर्ल 5, 50 बाइट्स

print'Fizz'x!($_%3).Buzz x!($_%5)||$_,$/for 1..100

आप उपयोग करके कुछ बाइट्स बचा सकते हैं say
डेनिस

आपने स्कोरबोर्ड को तोड़ दिया ...
लेगियनममाल 978

@ LegionMammal978 हाँ। हां मैंने किया ... मैं कोशिश करूंगा और शीर्षक को फिर से बताऊंगा! अरे!
डोम हेस्टिंग्स

-E"..."8 बाइट्स नहीं है ? अंतरिक्ष + डैश + विकल्प + तर्क (+ उद्धरण)।
11

1
@EriktheGolfer इसलिए जब से मैंने यह पोस्ट किया है, सर्वसम्मति यह है कि -E0 बाइट्स हैं, लेकिन चूंकि प्राइमो का जवाब उद्धरणों को छोड़कर बनाया गया था, इसलिए मैंने इसे उचित बनाने के लिए चुना और उद्धरणों को मेरा और +1 के लिए शामिल किया -E। इसका कारण यह है कि यह मुफ़्त है के रूप में स्वीकार किया जाता है पर्ल आमतौर पर के माध्यम से चलाया जाता है perl -eऔर perl -Eकोई और बाइट नहीं है (मुझे लगा कि -M5.010या use 5.010साथ ही मुक्त हो सकता है, लेकिन शायद मेटा पोस्ट को फिर से नहीं पढ़ रहा है)। जोड़ते समय -pया -nइसे +1 के रूप में गिना जाता है जैसा कि आप के साथ चलता है perl -pe। उम्मीद है की वो मदद करदे! मेटा संदर्भ: meta.codegolf.stackexchange.com/a/7539
डोम हेस्टिंग्स

27

रूबी, 50 बाइट्स

संस्करण 1.8 की आवश्यकता है, जो गोल्फरों के बीच लोकप्रिय लगता है:

1.upto(?d){|n|puts'FizzBuzz
'[i=n**4%-15,i+13]||n}

आधुनिक रूबी में, आप 51-बाइट समाधान के ?dसाथ प्रतिस्थापित करते 100हैं।

यह विश्व रिकॉर्ड लगता है।


1
यह शैतानी है, इसे प्यार करो।
कैमडेन नार्कट सेप

?dबस है 100FizzBuzzस्ट्रिंग उस में एक नई पंक्ति है, इस रूबी में मान्य है। string[i, s]एक टुकड़ा है, जो चरित्र पर शुरू होता है i(0-अनुक्रमित), sपात्रों के लिए जा रहा है , स्ट्रिंग के बाहर इंगित सूचक की अनदेखी कर रहा है। यदि तर्क में putsपहले से ही एक नई रेखा है , तो यह काट दिया जाता है। सूत्र को पढ़ने में सरल होना चाहिए? यह यहां सभी काम करता है। मैं कुछ वास्तव में समर्थक रूबी golfers की मदद के बिना यह नहीं मिला है।
लिन

साइड नोट: यदि आपको इनपुट की शुरुआत में 0 जोड़ने की अनुमति थी (आप नहीं हैं), ?e.timesइसके बजाय 2 बाइट्स का उपयोग करके बचाया जा सकता है ।
शेल्वैकु

क्या आप [i=n**4%-15,i+13]कृपया भाग की व्याख्या कर सकते हैं ? मेरे सिर को इसके चारों ओर लपेटने के लिए प्रतीत नहीं हो सकता है
पिकाको

2
@Piccolo क्या यह स्निपेट मदद करता है ? यदि i==-14स्लाइस सीमा से बाहर है तो हम प्राप्त करते हैं nil। यदि i==-9हम i+13==4अंत से 9 वें चरित्र से शुरू होने वाले पात्रों को स्लाइस करते हैं, तो 'Fizz'। यदि i==-5हम अंत से 5 वें चरित्र से शुरू होने वाले 8 वर्णों को काटते हैं, तो 'Buzz\n'। (हम 8 स्लाइस करने की कोशिश करते हैं, लेकिन केवल 5 हैं, इसलिए हमें 5 मिलता है।) वगैरह।
लिन

26

जावा, 130 बाइट्स

यह हाल के जावा संस्करणों (7+) के लिए है। पुराने में आप enumट्रिक का इस्तेमाल करके कुछ और शेव कर सकते हैं , लेकिन मुझे नहीं लगता कि लॉजिक इससे छोटा है (86 इनसाइड main)।

class F{public static void main(String[]a){for(int i=0;i++<100;)System.out.println((i%3<1?"Fizz":"")+(i%5<1?"Buzz":i%3<1?"":i));}}

मुझे नहीं लगता कि इनिशियलाइज़र ब्लॉक ट्रिक यहाँ मदद करता है, क्योंकि प्रश्न खाली स्टैडर को निर्दिष्ट करता है।
feersum

हम्म। मुझे पता है कि स्टिरर को स्टैटिक ट्रिक प्रिंट्स हैं, लेकिन मुझे लगा कि एनम सफाई से भागता है। जानकर अच्छा लगा :)
Geobits

4
मुझे 14 बाइट से हराया! == 0 के बजाय <1 का उपयोग करना सहेजने का एक शानदार तरीका है!
ईएसपी

2
class F{public static-> interface F{staticजावा 8 में
TheNumberOne

1
यह काफी काम नहीं करता है। आपको करना होगा enum F{;public..., इसलिए आप वास्तव में किसी भी बाइट को नहीं बचा पाएंगे।
हाइपरएन्यूट्रीनो

23

अजगर, ३०

VS100|+*!%N3"Fizz"*!%N5"Buzz"N

इसे यहाँ आज़माएँ

स्पष्टीकरण:

VS100|+*!%N3"Fizz"*!%N5"Buzz"N
VS100                            : for N in range(1,101)
     |                           : logical short-circuiting or
      +*!%N3"Fizz"               : add "Fizz" * not(N % 3)
                                 : Since not gives True/False this is either "" or "Fizz"
                  *!%N5"Buzz"    : Same but with 5 and Buzz
                             N   : Otherwise N
                                 : The output of the | is implicitly printed with a newline

23

रेटिना , 317 139 134 132 70 63 60 55 बाइट्स

.100{`^
_
*\(a`(___)+
Fi;$&
\b(_{5})+$
Bu;
;_*
zz
'_&`.

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

व्याख्या

.100{`^
_

.वैश्विक चुप ध्वज जो कार्यक्रम के अंत में निहित उत्पादन बंद हो जाती है है। 100{कार्यक्रम के बाकी हिस्सों को एक लूप में लपेटता है जिसे 100 पुनरावृत्तियों के लिए निष्पादित किया जाता है। अंत में, मंच ही एक सम्मिलित करता है_ स्ट्रिंग की शुरुआत में , जो प्रभावी रूप से एक अपरिपक्व लूप काउंटर को बढ़ाता है।

*\(a`(___)+
Fi;$&

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

परमाणु अवस्था स्वयं ही ध्यान रखती है Fizz। द्वारा विभाजन 3को आसानी से एकात्मकता में जांचा जा सकता है: यदि परीक्षण किया जा सकता है तो संख्या दोहराई जा सकती है ___। यदि यह मामला है, तो हम Fi;स्ट्रिंग को प्रस्तुत करते हैं। अर्धविराम इतना है कि अगले चरण के लिए संख्या के सामने एक शब्द सीमा अभी भी है। यदि हम रेखा को Fizz___...बीच की स्थिति में बदल देते हैं zऔर _इसे एक सीमा नहीं माना जाता है, क्योंकि रेगेक्स अक्षर और अंडरस्कोर दोनों को शब्द अक्षर मानता है। हालाँकि, अर्धविराम हमें और zzसे दोहराव को हटाने की अनुमति देता हैFizzBuzz

\b(_{5})+$
Bu;

हम विभाज्यता के लिए ठीक वैसा ही करते हैं 5और Bu;, हालांकि हमें इसे बनाए रखने की आवश्यकता नहीं है_ इस समय के आसपास । तो हमें एक परिणाम मिलता है

_
__
Fi;___
____
Bu;
Fi;______
...
Fi;Bu;
...

यह केवल उन पंक्तियों में अंडरस्कोर से छुटकारा पाना बहुत आसान बनाता है जिनमें सम्‍मिलित हैं Fizz, जबकि zzएस में भरना भी :

;_*
zz

यही है, हम प्रत्येक अर्धविराम को चालू करते हैं, zzलेकिन हम इसके _बाद सभी s का उपभोग करते हैं । इस बिंदु पर हम FizzBuzz के साथ मिलकर काम कर रहे हैं। लेकिन चुनौती दशमलव उत्पादन चाहता है।

'_&`.

&एक सशर्त इंगित करता है: यह चरण केवल तभी निष्पादित होता है जब स्ट्रिंग में अंडरस्कोर होता है। इसलिए, Fizz, Buzzऔर FizzBuzzपुनरावृत्तियों अछूता छोड़ दिया जाता है। अन्य सभी पुनरावृत्तियों में (अर्थात जो न तो 3 या 5 से विभाज्य हैं), हम केवल वर्णों की संख्या को गिनते हैं, परिणाम को दशमलव में परिवर्तित करते हैं।


20

gs2 , 1

f

मॉरिस के एक उद्धरण , जीएस 2 के निर्माता:

मैं 1-बाइट गोरूबी करना चाहता था Hello, world!, इसलिए ... यह प्रिंट "1\n2\nFizz\n4\nBuzz\n..."। :)

अद्यतन : जोड़ा गया 27-बाइट उत्तर जो उपयोग नहीं करता है f


20

पर्ल 5, 45 बाइट्स

say((Fizz)[$_%3].(Buzz)[$_%5]or$_)for+1..100

-Eविकल्प की आवश्यकता है , एक के रूप में गिना जाता है। इसे कमांड लाइन से चलाया जाना चाहिए, अर्थात:

perl -Esay((Fizz)[$_%3].(Buzz)[$_%5]or$_)for+1..100

आदेश के आसपास उद्धरण, अनावश्यक हैं अगर एक रिक्त स्थान का उपयोग कर से बचा जाता है, या किसी भी अन्य पात्रों जो कमांड लाइन विभाजकों के रूप में कार्य कर सकते हैं ( |, <,> , &, आदि)।


पर्ल 5, 48 बाइट्स

print+(Fizz)[$_%3].(Buzz)[$_%5]||$_,$/for 1..100

यदि कमांड लाइन विकल्प को प्रत्येक के रूप में गिना जाता है, -lतो एक बाइट (प्रतिस्थापित करके $/) को बचाएगा । द्वारा क्लासिक Perlgolf नियम के लिए एक:, हालांकि, इस 3 में गिना जाएगा -, के लिए एक l, और आवश्यक स्थान के लिए एक।


आप स्विच के sayसाथ उपयोग कर सकते हैं , -Eजिसमें दूरी 1 से संपादित है -e, इसलिए इसे 1 बाइट के रूप में गिना जाना चाहिए।
डेनिस

हे प्रिमो, मुझे ऐसा लग रहा है कि मैं उपयोग करने के लिए अपने उत्तर में धोखा दे रहा हूं say, मैंने मान लिया है कि -Eइसका उपयोग किया जा सकता है -eजिसके स्थान पर आप 46 के बजाय 44 पर लाएंगे। मुझे नहीं लगता कि यह उचित है कि मैं स्कोर कर रहा हूं। आपके लिए अलग है, पसंदीदा स्कोरिंग तंत्र क्या है? मैं आमतौर printपर इससे बचने के लिए उपयोग करता हूं ! एक आम सहमति के सबसे करीब यह होगा ?
डोम हेस्टिंग्स

मेरा व्यक्तिगत लेना यह है कि कमांड लाइन पर प्रत्येक अतिरिक्त बाइट को स्कोर करना चाहिए 1. विशेष रूप से say, यदि आपका कोड किसी भी ओएस विभाजक से बचने के लिए एक लाइन पर लिखा जा सकता है, तो स्कोर 1 के लिए -E। यदि आपको उद्धरण का उपयोग करने की आवश्यकता है, उदाहरण के लिए -E"$a||$b", स्कोर 3. यदि आप इसे एक पंक्ति में प्राप्त नहीं कर सकते हैं, तो 5 स्कोर करें -M5.01। लेकिन उस समय आप का उपयोग करना बेहतर होगा -l। मैं इस बात से सहमत नहीं हूं कि यह दो कारणों से डिफ़ॉल्ट रूप से मुक्त होना चाहिए: 1) सुधार तुच्छ और निर्बाध है, और 2) दुभाषिया का कोई संस्करण नहीं है जिसके लिए यह डिफ़ॉल्ट रूप से सक्षम है।
प्रिमो

20

मोम ,104 89 81 बाइट्स

8 से अधिक बाइट्स काटने के लिए सघन पैकिंग की अनुमति है।

सबसे छोटा समाधान (81 बाइट्स), एक ही कार्यक्रम प्रवाह, विभिन्न पैकिंग।

p?@<
p?{@b'gA<
p@`zzuB`d'%~5F@<f`z`<
 >~P"#"_"1F3~%'d`Fiz`b
 d;"-~@~.<
>?N@9P~0+d

अवधारणा को बदलने से मुझे 15 बाइट्स द्वारा कोड में कटौती करने में सक्षम बनाया गया। मैं समाधान में दोहरे मॉड 5 परीक्षण से छुटकारा पाना चाहता था, इसलिए मैंने एक झंडा लगाया।

संक्षिप्त विवरण:

यदि n%3=0फ़िज़ मुद्रित हो जाता है, और झंडा सेट हो जाता है। झंडे को बस नीचे की ओर ऊपर की ओर ले जाने का एहसास होता है f

यदि n%5=0, तो या तो n%3=0(FizzBuzz केस) या n%3>0(Buzz केस)। दोनों मामलों में, बज़ मुद्रित हो जाता है, और स्टैक को खाली करने से झंडा रीसेट हो जाता है जब तक कि यह खाली न हो (निर्देश ?)।

अब दिलचस्प मामले:

यदि n%5>0, तब या तो हमारे पास था n%3=0(मुद्रण फ़िज़ मामले, एन मुद्रित नहीं होना चाहिए) या n%3>0(फ़िज़ मुद्रित नहीं था, इसलिए एन को मुद्रित करना होगा)। झंडे की जांच करने का समय। यह गस्टैक (निर्देश A) के शीर्ष पर gstack की लंबाई को धक्का देकर महसूस किया जाता है । यदि n%3 was 0तब gstack की लंबाई> 0 है। अगर n%3 was >0, gstack की लंबाई 0. है, तो एक साधारण सशर्त कूद सुनिश्चित करता है कि n केवल मुद्रित होता है यदि gstack की लंबाई 0 थी।

फिर से, n, Fizz और / या Buzz और newline में से किसी को भी प्रिंट करने के बाद, यह सुनिश्चित करने के लिए कि यह खाली है, gstack दो बार पॉप हो जाता है। gstack या तो खाली []होता है, जो [0]निर्देश के बाद होता है A(gstack पर gstack की पुश लंबाई), या इसमें एक शून्य ( [0], n% 3 का परिणाम) होता है, जो आगे बढ़ता है [0 1], क्योंकि [0] की लंबाई होती है 1. Popping a से खाली स्टैक से स्टैक नहीं बदलता है, इसलिए दो बार पॉप करना सुरक्षित है।

यदि आप करीब देखते हैं तो आप देख सकते हैं कि, सिद्धांत रूप में, मैं मुड़ा हुआ हूं

>      q
d`Fizz`f>

में

<f`z`<
d`Fiz`b

जो नीचे दिए गए पुराने समाधान में निम्नलिखित पंक्ति के अंत में Aऔर उसके बीच के सभी बर्बाद स्थान से छुटकारा पाने में मदद करता है <:

q?{@b'gA<       p      <

नई व्याख्या समाधान (89 बाइट्स) जिसमें एनिमेटेड व्याख्या भी शामिल है:

q?@ <
 q?{@b'gA<       p      <
p?<@`zzuB`b'%~5F@<f`zziF`b'<
>N@9P~0+.~@~-";~P"#"_"1F3~%d

हेक्सागोनल लेआउट:

   q ? @   <
    q ? { @ b ' g A <               p             <
 p ? < @ ` z z u B ` b ' % ~ 5 F @ < f ` z z i F ` b ' <
> N @ 9 P ~ 0 + . ~ @ ~ - " ; ~ P " # " _ " 1 F 3 ~ % d

2 एफपीएस पर पहले 326 टिक्स का एनीमेशन, स्थानीय और वैश्विक ढेर के साथ, और एसटीडीयूएसटी के लिए आउटपुट।

मोम FizzBuzz एनीमेशन


तुलना के लिए, नीचे पुराने, अधिक जटिल समाधान के पथ ओवरले हैं। शायद यह भी एक दृश्य दृष्टिकोण से;

पथ ओवरले के साथ कार्यक्रम


2
यह Hexagony की तरह ही पागल और खूबसूरत है। एक +1 है!
ETHproductions

@ETHproductions मुझे अभी भी हेक्सागोनी को एक कोशिश देने की आवश्यकता है, लेकिन मैं जो भाषा के चश्मे से बता सकता हूं, उससे मेरा मोम भी हेक्सागोनी के पागलपन के करीब नहीं आता है।
ML


आप उन एनिमेशनों को कैसे बना रहे हैं?
बॉरडॉग

18

> <> , 68 66 65 64 बाइट्स

1\2+2foooo "Buzz"<
o>:::3%:?!\$5%:?!/*?n1+:aa*)?;a
o.!o"Fizz"/oo

एक ही चाल संख्या मुद्रण के लिए एक शर्त के रूप में अवशेषों को गुणा करना है। इस तरह, अगर उनमें से एक 0 है तो हम संख्या को प्रिंट नहीं करेंगे।

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

Sp3000 के लिए एक बाइट धन्यवाद और यादृच्छिक के लिए एक और धन्यवाद। बहुत धन्यवाद!


1
बहुत अच्छी तरह से गढ़ा हुआ, मुझे पहली पंक्ति में "और" दूसरी पंक्ति में पुन: उपयोग करना पसंद है।
कोल

1
-1 बाइट यदि आप oदूसरी लाइन के अंत में लाइन के शुरू में खाली जगह पर जाते हैं, तो मुझे विश्वास है।
Sp3000

@ Sp3000 वास्तव में, मैंने इतना समय गोल्फिंग में बिताया है, मुझे नहीं पता कि यह कैसे समझ में नहीं आया
हारून

1
जब आपके पास हो सकता है तो फ़िज़ के बुलबुल की ज़रूरत कौन है foooo Buzz?
caird coinheringaahing

17

gs2 , 28 27 (बिना f)

हेक्स:

1b 2f fe cc 04 46 69 7a 7a 09 07 42 75 7a 7a 19 06 27 2d d8 62 32 ec 99 dc 61 0a

स्पष्टीकरण:

1b    100
2f    range1 (1..n)
fe    m: (map rest of program)

cc    put0 (pop and store in register 0)
04    string-begin
Fizz
09    9
07    string-separator
Buzz
19    25
06    string-end-array (result: ["Fizz"+chr(9) "Buzz"+chr(25)])

27    right-uncons
2d    sqrt
d8    tuck0 (insert value of register 0 under top of stack)
62    divides
32    times (string multiplication)
ec    m5 (create block from previous 5 tokens, then call map)

99    flatten
dc    show0 (convert register 0 to string and push it)
61    logical-or
0a    newline

स्ट्रिंग स्थिरांक में 3 और 5 को एम्बेड करना निरंतर काम नहीं करता है क्योंकि \x05स्ट्रिंग शाब्दिक समाप्त होता है।

नोट: यह समस्या 1 बाइट में जीएस 2 के साथ बिल्ट-इन का उपयोग करके हल की जा सकती है f


16

सी, 85 बाइट्स

i;main(){for(;i++<=99;printf("%s%s%.d\n",i%3?"":"Fizz",i%5?"":"Buzz",(i%3&&i%5)*i));}

-2 स्क्वीश के लिए धन्यवाद।


यहाँ संकलित करने की कोशिश की जा रही है, लेकिन gcc\ n के रूप में स्ट्रिंग के अंदर नई रेखा को नहीं पहचाना है। यह मुझे एक संकलन त्रुटि देता है। क्या मुझे कंपाइलर को किसी भी पैरामीटर को पास करने की आवश्यकता है? BTW, आप <=अपनी पोस्ट में चूक गए (मैंने <= ... के साथ 88 बाइट्स गिना तो यह मानकर कि यह गायब है)।
वेंडेलबसेल्वा

उफ़। चेतावनियों में त्रुटि चूक गई। 2 वर्ण जोड़ता है।
एएसपीली

वैश्विक चर शून्य से आरंभिक होते हैं, इसलिए इसके बजाय main(i)प्रयास करें i;main()। फिर आप लूप i--की शुरुआत में छुटकारा पा सकते हैं for()। आपको लाइन ब्रेक की भी आवश्यकता नहीं है। कि बाइट की संख्या 85 तक नीचे आनी चाहिए।
स्क्वैश ऑसफ्रीज

2
यूबी आप कैसे प्राप्त करना चाहते हैं, इसके आधार पर, आप 73, 74, या 75 बाइट्स कर सकते हैं। यहाँ मेरा 74 बाइट उत्तर है
लिन

1
OMG मैंने इस चीज़ को प्राप्त करने में 3 घंटे बिताए शायद यह एक बाइट छोटा हो। हेयर यू गो। बदलें (i%3&&i%5)*iके साथ i%3*i%5?i:0मैं सोने जा रहा हूँ
अल्बर्ट रेंशाव

16

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

100{)_[Z5]f%:!"FizzBuzz"4/.*s\e|N}/

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

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

100{)_[Z5]f%:!"FizzBuzz"4/.*s\e|N}/
100{                             }/  For each integer I between 0 and 99:
    )_                                 Increment I and push a copy.
      [Z5]                             Push [3 5].
          f%                           Map % to push [(I+1)%3 (I+1)%5].
            :!                         Apply logical NOT to each remainder.
              "FizzBuzz"4/             Push ["Fizz" "Buzz"].
                          .*           Vectorized string repetition.
                            s\         Flatten the result and swap it with I+1.
                              e|       Logical OR; if `s' pushed an empty string,
                                       replace it with I+1.
                                N      Push a linefeed.

3
अधिक सीधा समाधान:100{):I3%!"Fizz"*I5%!"Buzz"*+Ie|N}/
ad

16

MUMPS, 56 54 बाइट्स

f i=1:1:100 w:i#5=0 "Fizz" w:i#3=0 "Buzz" w:$X<3 i w !

यह क्या w:$X<3 iबात है, आप पूछें? $Xएक जादू चर ("आंतरिक") है जो आउटपुट कर्सर की क्षैतिज स्थिति (टर्मिनल के बाएं किनारे से कई वर्णों के रूप में) को संग्रहीत करता है। कमांड wका संक्षिप्त रूप है WRITE। वाक्यविन्यास command:condition argsएक उत्तर आधुनिक है - "यदि condition, तो करें command args"।

इसलिए हम जाँच रहे हैं कि आउटपुट कर्सर दो वर्णों से अधिक उन्नत है (जिसका अर्थ यह होगा कि कम से कम एक "Fizz"या "Buzz"टर्मिनल को लिखा गया है), और यदि नहीं, iतो टर्मिनल को लिख रहा है। $Xचर - और इसलिए, टर्मिनल से गहरी अवियोज्यता इस तरह की - MUMPS की एक प्रथम श्रेणी की सुविधा है। ओह।


15

जेली , 24 20 बाइट्स

³µ3,5ḍTị“¡Ṭ4“Ụp»ȯµ€G

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

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

³µ3,5ḍTị“¡Ṭ4“Ụp»ȯµ€G  Main link. No input.

³                     Yield 100.
 µ                    Begin a new, monadic chain.
                 µ€   Apply the preceding chain to all integers n in [1, ..., 100].
  3,5ḍ                Test n for divisibility by 3 and 5.
      T               Get all truthy indices.
                      This yields [1] (mult. of 3, not 5), [2] (mult. of 5, not 3),
                      [1, 2] (mult. of 15) or [].
        “¡Ṭ4“Ụp»      Yield ['Fizz', 'Buzz'] by indexing in a dictionary.
       ị              Retrieve the strings at the corr. indices.
                ȯ     Logical OR hook; replace an empty list with n.
                   G  Grid; join the list, separating by linefeeds.

फिर से कोई भी डेनिस को बाहर नहीं निकालता (HQ9 + स्टाइल उत्तर को छोड़कर)
noɐɹƆz

15

ब्रेनफक, 206 बाइट्स

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

प्रारूपित:

++>+++++>>>>>
++++++++++[>+>>+>>+>+<<<[++++<-<]<,<,-<-<++<++++[<++>++++++>]++>>]
>
[
  +
  [
    [<<]
    <[>>]
    +++<
    [
      Fizz
      <.<.<..
      [>]
    ]
    <<-
    [
      >>>
      [
        ,>>[<]
        >[--.++<<]
        >
      ]
    ]
    +++++<
    [
      Buzz
      +[-----.++++<<]
      >>+..
      <-
      [>]
    ]
    <[->>,>+>>>->->.>]
    <<
  ]
  <[>+< <<,<->>>+]
  <
]

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

मेमोरी लेआउट है

0 a 122 105 70 b f 0 t d1 s d2 c d 10 0

जहां f3 से bचक्र , 5 से चक्र, d1लोगों का अंक है, d2दसियों का अंक है, दसियों अंक sको मुद्रित करने के लिए एक ध्वज है, d10 से चक्र है, के cलिए प्रतिलिपि स्थान है d, t0 या कबाड़ डेटा या नहीं के लिए एक ध्वज रखने वाली जगह काम कर रहा है। -डिजाइन-बाई -३, और aबज़ को 20 बार प्रिंट करने के बाद पॉइंटर को ऑफसेट करके प्रोग्राम समाप्ति को निर्धारित करता है।


14

सी #, 128 126 125 124 बाइट्स

class A{static void Main(){for(var i=0;i++<100;)System.Console.Write("{0:#}{1:;;Fizz}{2:;;Buzz}\n",i%3*i%5>0?i:0,i%3,i%5);}}

चारों ओर बॉयलरप्लेट कोड के बिना 89 बाइट्स।

C # के सशर्त स्वरूपण के उपयोग के साथ किया गया ।

दो खंड विभाजकों के साथ ;, यदि उनकी स्थिति से मूल्य शून्य है, तो फ़िज़ या बज़ मुद्रित किए जाते हैं।


@RubberDuck, @Timwi और @Riokmij की बदौलत कुल 4 बाइट्स बचाए।


यह कॉल करने के लिए नया होगा Writeऔर सीधे स्ट्रिंग को नईलाइन संलग्न करेगा, है ना?
रबरडक

इसके i%3*i%5>0?i:0बजाय लिखने के लिए यह एक बाइट से भी छोटा है i%3*i%5==0?0:i
तिमवी

आप forउपयोग करके बयान पर एक और बाइट बचा सकते हैंfor(var i=0;i++<100;)
नाज़किन

1
आप स्ट्रिंग # 3 से स्ट्रिंग इंटरपोल का लाभ उठाकर तीन और बाइट्स को बचा सकते हैं और प्रारूप तर्क को स्ट्रिंग में ही एम्बेड कर सकते हैं (जैसे $"{(i%3*i%5>0?i:0):#}...\n")
LAMK

1
आज 121 बाइट्स के साथ कर सकते हैं -class A{static void Main(){for(var i=0;i<100;)System.Console.Write($"{(++i%3*i%5<1?0:i):#}{i%3:;;Fizz}{i%5:;;Buzz}\n");}}
जेर्री कंगसनेमी

14

क्लोजर, 113 106 101 100 91 बाइट्स

मेरा पहला गोल्फ!

(dotimes[i 100](println(str({2'Fizz}(mod i 3))({4'Buzz}(mod i 5)({2""}(mod i 3)(inc i))))))

Ungolfed:

(dotimes [i 100] ; account for off-by-one later
  (println (str ({2 'Fizz} ; str converts symbols to strings
                 (mod i 3))
                ({4 'Buzz} ; 4 instead of 0 because of off-by-one
                 (mod i 5)
                 ({2 ""} ; shortest way to write when-not
                  (mod i 3)
                  (inc i))))))

1
आप जावा वर्ण printlnमें उसी तरह से हैंडल करके 5 अक्षर निकाल सकते हैं , जैसे। (doall(map #(let[t(=(mod % 3)0)](println(str(if t"Fizz""")(if(=(mod % 5)0)"Buzz"(if t""%)))))(range 1 101)))
रिसुमैन

1
@resueman धन्यवाद! यह वास्तव में 7 होने के कारण समाप्त हो गया, क्योंकि (if t"Fizz""")इसे सरल बनाया जा सकता है (if t"Fizz")। :)
सैम एस्टेप

+1 अच्छा मॉडुलो ट्रिक, पहली बार में हालांकि आपके पास एक-एक त्रुटियां थीं।
coredump

14

ब्रेनफक , 411 350 277 258 बाइट्स

संपादन:

  • -61 बाइट्स को "फ़िज़ी बज़" के मानों को "बूज़ीफ़" "बुज़ीग" के रूप में संग्रहीत करके और संख्या मुद्रण अनुभाग को फिर से करना।

  • -71 बाइट्स मोडुलो नंबर प्रिंटिंग सेक्शन को रिड्यूस करके, लूप काउंटर और नंबर काउंटर को विभाजित करना, और न्यूलाइन सेल को मॉड वैल्यू के रूप में अन्य चीजों के साथ पुन: उपयोग करना।

  • -19 बाइट्स यह महसूस करते हुए कि किसी भी FizzBuzz संख्या में 0s नहीं हैं। स्पष्टीकरण भी जोड़ा

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

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

यह जाँचने के बजाय कि क्या संख्या स्वयं 5 या 3 से विभाज्य थी, मेरे पास संख्या के मोडुलो पर नज़र रखने के लिए दो काउंटर थे, प्रत्येक संख्या के लिए उन्हें घटाकर और 0 तक पहुंचने पर संबंधित शब्द को प्रिंट करना।

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

+[-[>+<<]>-]>--  Generate the number 61
[>+>++>++>++++++>+>>>++++++[<<<]>-] Set the tape to multiples of 61
TAPE: 0 0' 61  122 122 110 61  0 0 110
           "=" "z" "z" "n" "="
<+++++[>+>+>->>->++>>>-->>>++[<<<]>>>-]>[>]+++>> Modify values by multiples of 5
TAPE: 0' 5 66  117 122 105 71  3 0 100' 0 0 10
           "B" "u" "z" "i" "G"
Some info:
  5     - Buzz counter
  "Buz" - Buzz printing
  "ziG" - Fizz printing. Modifying the G in the loop is shorter than modifying it outside
  3     - Fizz counter
  0     - This is where the Fizz|Buzz check will be located
  100   - Loop counter
  0     - Number counter. It's not worth it to reuse the loop counter as this.
  0     - Sometimes a zero is just a zero
  10    - Value as a newline and to mod the number by

[ Loop 100 times
  >+<<<  Increment number counter
  -[<]<  Decrement Fizz counter
  [ If Fizz counter is 0
    >+++ Reset the Fizz counter to 3
    >+<< Set the Fizz|Buzz check to true
    -.+<.<.. Print "Fizz"
  [<]<] Sync pointers
  >>-[<<]> Decrement Buzz counter
  [ If Buzz counter is 0
    .>.>.. Print "Buzz"
    >>>>+  Set the Fizz|Buzz check to true
    [<]+++++< Reset the Buzz counter to 5
  ]
  >[>]>> Go to Fizz|Buzz check
  [ If there was no Fizz or Buzz for this number
    TAPE: 3% BuziG 5% 0 Loop Num' 0 10
    [->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]  Mod the number counter by 10
    TAPE: 3% BuziG 5% 0 Loop 0' Num 10-Num%10 Num%10 Num/10
    >[-<+>] Move Num back in place
    >,>[>]< Reset 10-Num%10
    [ For both Num/10 (if it exists) and Num%10
      >-[<+>-----]<--- Add 48 to the number to turn it into the ASCII equivilent
      .,< Print and remove
    ]
    ++++++++++> Add the 10 back
  ]
  <. Print the newline
  <<<<, Remove Fizz|Buzz check
  >- Decrement Loop counter
]

अच्छा किया जो! मैं किसी दिन उस को हराने की कोशिश कर सकता हूं :)
फॉरेंस विंटियर

13

पॉवरशेल, 78 68 61 54 बाइट्स

1..100|%{(($t="Fizz"*!($_%3)+"Buzz"*!($_%5)),$_)[!$t]}

संपादित करें: झटके के लिए धन्यवाद 10 बाइट्स सहेजे गए

Edit2: एहसास हुआ कि feersum की चाल के साथ, मुझे अब $ t को एक स्ट्रिंग-ऑफ-कोड ब्लॉक के रूप में तैयार करने की आवश्यकता नहीं है

Edit3: Danko Durbić की बदौलत एक और 7 बाइट्स बचाए

स्टॉक रोसेटा कोड के जवाब में आत्मा के समान-ईश , लेकिन काफी नीचे गोल्फ हुआ।

व्याख्या

1..100|%{...} 100 के माध्यम से 1 का एक संग्रह बनाएं, फिर उस संग्रह में प्रत्येक वस्तु के लिए, करें

(...,$_)दो तत्वों का एक नया संग्रह बनाएं: 0) एक स्ट्रिंग के बराबर $t=...चर सेट करें $t; 1) $_लूप की हमारी-वर्तमान-संख्या

"Fizz"*!($_%3)हमारे वर्तमान-संख्या को लें, इसे 3 से मापें, फिर परिणाम नहीं। उस द्वारा "फ़िज़" को गुणा करें, और इसे स्ट्रिंग में जोड़ें (और 5 के लिए समान)। PowerShell किसी भी गैर-शून्य संख्या के रूप में व्यवहार करता है $TRUE, और इस प्रकार गैर-शून्य संख्या की संख्या 0 नहीं है, जिसका अर्थ है कि केवल अगर हमारी-वर्तमान संख्या 3 की एक बहु है "Fizz" स्ट्रिंग में जोड़ा जाएगा।

[!$t]स्ट्रिंग के मूल्य के आधार पर हमने अभी-अभी बनाए गए संग्रह में अनुक्रमित किया है $t- गैर-रिक्त, इसे प्रिंट करें, अन्यथा हमारी वर्तमान संख्या प्रिंट करें


वैकल्पिक रूप से, 54 बाइट्स भी

1..100|%{'Fizz'*!($_%3)+'Buzz'*!($_%5)-replace'^$',$_}

TesselatingHeckler के लिए धन्यवाद

अवधारणा में समान, यह इनलाइन -replaceऑपरेटर और एक नियमित अभिव्यक्ति का उपयोग करता है जो ^$हमारे वर्तमान-संख्या के साथ एक खाली स्ट्रिंग को स्वैप करता है । यदि स्ट्रिंग गैर-रिक्त है, तो इसे स्वैप नहीं किया जाता है।


वैकल्पिक रूप से, 54 बाइट्स भी

1..100|%{($_,('Fizz'*!($_%3)+'Buzz'*!($_%5))|sort)[1]}

यह ऊपर की तरह एक ही लूप संरचना है, लेकिन इसके अंदर जोड़ी (एन, स्ट्रिंग) को सॉर्ट करता है, और इस तथ्य पर निर्भर करता है कि एक संख्या से पहले एक खाली स्ट्रिंग प्रकार, लेकिन एक संख्या के बाद एक फ़िज़बज़ स्ट्रिंग प्रकार। फिर यह दूसरे प्रकार के परिणाम को अनुक्रमित करता है।


एक तरफ के रूप में, यदि PowerShell ने कभी भी ||ऑपरेटर को C # की तरह लागू किया , तो हम संभवतः 43 बाइट्स के साथ कुछ ऐसे ही 1..100|%{"Fizz"*!($_%3)+"Buzz"*!($_%5)||$_}... संदिग्ध हो सकते हैं, क्योंकि |PowerShell में यह एक महत्वपूर्ण विशेष ऑपरेटर है, लेकिन मैं सपना देख सकता हूं ...
AdmBorkBork

1
1..100|%{'Fizz'*!($_%3)+'Buzz'*!($_%5)-replace'^$',$_}54 के लिए कैसे ?
TessellatingHeckler

आप if($t){$t}else{$_}कुछ इस तरह से बदल सकते हैं($t,$_)[!$t]
Danko Durbić

1
... तो आप 1..100|%{(($t="Fizz"*!($_%3)+"Buzz"*!($_%5)),$_)[!$t]}भी पाएं 54 जो @ TessellatingHeckler के सुझाव की तरह है
Danko Durbić

@TessellatingHeckler पॉवरशेल लचीला नहीं तो कुछ भी नहीं है।
AdmBorkBork

13

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

for(i=0;++i<101;console.log(i%5?f||i:f+'Buzz'))f=i%3?'':'Fizz'

मुझे लगता है कि यह अब तक का सबसे छोटा जावास्क्रिप्ट समाधान है।


वाह सिर्फ वाह! लेकिन अन्य सभी जेएस उत्तर का उपयोग करते हैं console.log; एक पंक्ति में 100 पॉप-अप बॉक्स पर "ओके" दबाने की तुलना में यह बहुत कम कष्टप्रद है। क्या आप इसे बदल सकते हैं? यह केवल 62 बाइट्स होगा, अभी भी मेरा से तीन बेहतर है।
3

मुझे कल ऐसा करना होगा, क्योंकि मैं पहले ही अपने 5 पोस्ट संपादित कर चुका हूं और अब और संपादित नहीं कर सकता ...
मामा फन रोल

2
ओह, मुझे महसूस नहीं हुआ कि संपादन की कोई सीमा थी ...
ETHproductions

12

सी, 74 बाइट्स

main(i){for(;i<101;puts(i++%5?"":"Buzz"))printf(i%3?i%5?"%d":0:"Fizz",i);}

को 0तर्क दियाprintf बजाय"" गड़बड़ है, लेकिन लगता है कि मैं इसे पर कोशिश सबसे प्लेटफार्मों पर काम करने के लिए। putssegfaults जब आप एक ही चीज़ की कोशिश करते हैं, हालांकि। इसके बिना, आपको 75 बाइट्स मिलते हैं।

73-बाइट समाधान हैं जो अराजकता के गोल्फ पर काम करते हैं , और मुझे इंटरनेट पर सही स्थानों पर चारों ओर खुदाई करने का पता चला, लेकिन वे प्लेटफॉर्म-विशिष्ट व्यवहार पर भरोसा करते हैं। (जैसा कि आप अनुमान लगा सकते हैं, यह कुछ रूप है puts("Buzz"±...)।)


बिना किसी आर्ग के मामले के लिए i = 1 प्राप्त करने की अच्छी चाल (argc = 1)। यह एक विशेषता है: आप किसी भी बिंदु से अनुक्रम को चालू कर सकते हैं ./fizzbuzz $(seq 40): पी
पीटर कॉर्डेस

12

स्क्रैच, 203 185 बाइट्स

इस मेटा पोस्ट के अनुसार, बाइट्स को ग्राउंडेड टेक्स्टुअल प्रतिनिधित्व से गिना जाता है । स्क्रैच बहुत जगह-कुशल नहीं है।

sayएक स्टडआउट स्क्रैच में सबसे निकटतम चीज है: स्प्राइट एक भाषण बुलबुले को प्रदर्शित करता है जिसमें वह जो भी कह रहा है। व्यवहार में, wait n secsइस आउटपुट को वास्तव में पढ़ने के लिए एक ब्लॉक की आवश्यकता होगी, लेकिन इस चुनौती के प्रयोजनों के लिए यह कोड आवश्यकताओं को पूरा करता है।


y =(दोनों घटनाओं में) के बाद आप नंबरों को याद कर रहे हैं
बीटा डिके

@BetaDecay क्षमा करें? मैं अनुसरण नहीं करता।
तैमोथीम

रिपीट लूप के अंदर, set y to ...एक मान गायब है
बीटा डिके

1
@BetaDecay यह खाली स्ट्रिंग है। :) यदि आप छवि पर क्लिक करते हैं, तो आप इसे कार्रवाई में देख सकते हैं!
तैमोथीम

ओह्ह हाहा सॉरी टू डूइंग यू;)
बीटा डेके

12

आर, 88 83 77 71 70 बाइट्स

मुझे यकीन है कि इसमें सुधार किया जा सकता है ... और इसका श्रेय @flodel को था। बाइट्स के एक और जोड़े ने @njnnja के एक सुझाव और @ J.Doe से एक और धन्यवाद बचाया

x=y=1:100;y[3*x]='Fizz';y[5*x]='Buzz';y[15*x]='FizzBuzz';write(y[x],1)

एक बिल्ली का जवाब। माउस ऊपर है :)
सिल्वु बर्किया

1
मुझे थोड़ा बेहतर लगा:x=1:100;i=!x%%3;j=!x%%5;x[i]="Fizz";x[j]="Buzz";x[i&j]="FizzBuzz";cat(x,sep="\n")
फ्लोडेल

@njnnja सुझाव के लिए धन्यवाद। मैं एक साथ इसे लागू writeकरने के बजाय cat, हालांकि
MickyT

2
यहाँ नेक्रोमेंसी! writeकॉल ले जा सकते हैं एक में रिक्त स्ट्रिंग के बजाय एक 1 तो x=y=1:100;y[3*x]='Fizz';y[5*x]='Buzz';y[15*x]='FizzBuzz';write(y[x],1)70 बाइट्स के लिए एक छोटी सी 1 बाइट गोल्फ है।
जे। डी। ओ।

68 बाइट्स । बाइटकाउंट में तीन अनपेक्षित बैकस्पेस शामिल हैं, और यह TIO में सही ढंग से काम नहीं करता है।
जे। डी। ओ।

12

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

main=mapM f[1..100]
f n|d<-drop.(*4).mod n=putStrLn$max(show n)$d 3"Fizz"++d 5"Buzz"

मेंहदी के 81 बाइट्स के करीब होना , लेकिन अभी तक वहाँ नहीं है।

d = drop.(*4).mod nयहाँ कुंजी है: d 3 "Fizz"है drop (n`mod`3 * 4) "Fizz"। यह "Fizz"कब हैn `mod` 3 0 और ""अन्यथा है।


पुनर्वसन गोल्फ इसे 82 तक नीचे ले जाता है, मुझे लगता है (%)=drop.(*4).mod n;main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100]]:।
CR Drost

प्रतीक्षा करें, फिर nगुंजाइश नहीं है। हम्म।
CR Drost

हाँ, यह काम नहीं करता है, लेकिन मैंने एक वैकल्पिक 85-बाइट समाधान मारा है जो इसे बहुत पसंद करता है:main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100],(%)<-[drop.(*4).mod n]]
लिन

लाइन ब्रेक का उपयोग क्यों नहीं करते? यह अर्धविराम जितना छोटा है लेकिन कम अपठनीय है।
dfeuer

1
मेरा सुझाव है कि आप एक कोड गोल्फ वेबसाइट पर पठनीय कोड के लिए अपनी खोज पर पुनर्विचार करें :)
लिन

11

PHP, 54 बाइट्स

<?for(;$i++<100;)echo[Fizz][$i%3].[Buzz][$i%5]?:$i,~õ;

V5.5 के लिए मान्य बाद में। õचरित्र 245 है, थोड़ा उलटा \n

मैं डिफ़ॉल्ट दुभाषिया सेटिंग्स को मान लेता हूं, क्योंकि वे बिना किसी आईएनआई के हैं। यदि आप अनिश्चित हैं, तो आप अपने स्थानीय आईएनआई को निष्क्रिय कर सकते हैं-n के रूप मेंphp -n fizzbuzz.php

एक संस्करण जो किसी भी कॉन्फ़िगरेशन फ़ाइल के साथ त्रुटि मुक्त चलेगा 62 बाइट्स है :

<?php
for(;$i++<100;)echo@([Fizz][$i%3].[Buzz][$i%5]?:$i),"
";

STFU ऑपरेटर @ का मतलब जरूरी नहीं है कि कोड त्रुटि मुक्त हो।
सिटिलाज


@Kzqai ideone.com/0zRA9e short_open_tag बंद है, E_NOTICEचालू है। इनमें से कोई भी डिफ़ॉल्ट सेटिंग नहीं है।
प्राइमो

मैं 3v4l.org पर त्रुटियों का एक गुच्छा प्राप्त कर रहा हूं
एक कोडर

@acoder प्रासंगिक मेटा पोस्ट । 3v4l.org उपयोगी लगता है।
प्रिमो

11

80386 मशीन कोड + डॉस, 75 बाइट्स

कोड के Hexdump:

0D 0A 24 B1 64 33 C0 BA-03 05 BB 00 01 40 50 FE
CE 75 0C 83 EB 04 66 C7-07 42 75 7A 7A B6 05 FE
CA 75 0C 83 EB 04 66 C7-07 46 69 7A 7A B2 03 84
FF 74 0C D4 0A 04 30 4B-88 07 C1 E8 08 75 F4 52
8B D3 B4 09 CD 21 5A 58-E2 C0 C3

स्रोत कोड (TASM सिंटैक्स):

    .MODEL TINY

    .CODE
    .386
    org 100h

MAIN PROC
    db 13, 10, '$'
    mov cl, 100
    xor ax, ax
    mov dx, 503h

main_loop:
    mov bx, 100h
    inc ax
    push ax

    dec dh
    jnz short buzz_done
    sub bx, 4
    mov dword ptr [bx], 'zzuB'
    mov dh, 5
buzz_done:

    dec dl
    jnz short fizz_done
    sub bx, 4
    mov dword ptr [bx], 'zziF'
    mov dl, 3
fizz_done:

    test bh, bh
    jz short num_done

decimal_loop:
    aam;
    add al, '0'
    dec bx
    mov [bx], al
    shr ax, 8
    jnz decimal_loop

num_done:
    push dx
    mov dx, bx;
    mov ah, 9
    int 21h
    pop dx
    pop ax

    loop main_loop
    ret

MAIN ENDP
    END MAIN

यह कोड 1 से 100 तक गिना जाता है ax, जो शुरुआत से अंत तक आउटपुट संदेश का निर्माण करता है। संदेश की समाप्ति (newline और $चरित्र जो अंत संदेश के ध्वज के लिए DOS का उपयोग करता है) कोड की शुरुआत में दिखाई देता है:

db 10, 10, '$'

इसे हानिरहित निर्देश ( or ax, 240ah) के रूप में निष्पादित किया जाता है । मैं इसे अधिक पारंपरिक स्थान पर रख सकता था, जैसे कोड के अंत के बाद, लेकिन पते पर 0x100 होने से लाभ होता है।

कोड 2 अतिरिक्त काउंटर का भी उपयोग करता है:

  • 3 से 0 तक की गिनती में dl
  • 5 से 0 तक की गिनती में dh

जब एक काउंटर 0 तक पहुंचता है, तो यह स्ट्रिंग Fizzया Buzzआउटपुट संदेश के अंत तक धकेलता है । यदि ऐसा होता है, bxतो कम हो जाएगा, और bhशून्य हो जाएगा। इसका उपयोग दशमलव रूप में संख्या के आउटपुट के लिए एक शर्त के रूप में किया जाता है।

नोट: मैं यहाँ 32-बिट डेटा का उपयोग कर रहा हूँ। यह पूर्व 386 कंप्यूटर पर काम नहीं करेगा।


क्या टीएएसएम वास्तव में एनएएसएम से विपरीत क्रम में मल्टी-बाइट वर्ण स्थिरांक को संभालता है ? NASM में, आप मेमोरी, मिलान निर्देश में उस क्रम में mov [mem], 'Fizz'स्टोर करने के लिए लिखते हैं । उदाहरण के लिए मेरी अतिविशिष्ट "कुशल" YASM FizzBuzz देखें । Fizzdb
पीटर कॉर्डेस

1
क्या यह उपयोग करने के लिए किसी भी बाइट्स को बचाता है std, फिर stosb/ stosd? आपको कुछ के test bh,bhसाथ बदलना cmp di, 100hहोगा। एएल में काउंटर को बचाने / बहाल करने के बजाय, आप जब चाहें तब इसे बीएल और सिर्फ क्लोबर ईएक्स में रख सकते हैं। जैसे sub bx, 4/ mov dword ptr [bx], 'zzuB'3 + 7 बाइट्स है, है ना? mov eax, 'zzuB' / stosd6 + 2 बाइट्स (दोनों पर ऑपरेंड-आकार उपसर्ग) है। यह अच्छा होगा यदि उत्तर में डिस्सैड शामिल हो ताकि निर्देश आकार दिखाई दे।
पीटर कॉर्डेस

1
यह एक महान जवाब है - डेटा के लिए सौम्य निर्देशों का दुरुपयोग करना और कभी भी उपयोग नहीं किए जाने वाले PSP मेमोरी स्पेस का उपयोग करना। @PeterCordes मैंने आपके सुझावों का उपयोग करते हुए खेला stosdलेकिन किसी भी स्कोर को कम करने में सक्षम नहीं था। बाद में stosdगिरावट के DIबाद आपको हारने की जरूरत नहीं है sub di, 4और फिर आपके पास DIअंत में 4 बाइट्स हैं। मैं -6 bytesकुछ अन्य मामूली ट्विक्स का उपयोग करने में सक्षम था जिसे मैंने एक अलग उत्तर के रूप में पोस्ट किया (केवल इसलिए कि मैं संभवतः सभी टिप्पणी में फिट नहीं हो सका)। कुडोस!
640KB

11

डीसी, 64 62 बाइट्स

[[Fizz]P]sI[[Buzz]P]sU[dn]sNz[zdd3%d0=Ir5%d0=U*0<NAPz9B>L]dsLx

Ungolfed:

[[Fizz]P]sI  # macro I: print "Fizz"
[[Buzz]P]sU  # macro U: print "Buzz"
[dn]sN       # macro N: print current stack depth

z            # increase stack depth

[            # Begin macro
  zdd           # Get current stack depth and ducplicate it twice
  3%d0=I        # Check modulo 3 and leave a duplicate. If it's 0, run macro I
  r             # Rotate top two elements, bringing up the stack depth again
  5%d0=U        # Check modulo 5 and leave a duplicate. It it's 0, run macro U
  *             # Multiply the duplicates of modulos of 3 and 5 ...
  0<N           # ... if it's not 0, run macro N
  AP            # Print a newline (`A` is 10)
                # The macro leaves the stack with one more element each time
  z9B>L      # Run macro L if stack depth is less than "ninety eleven" (101)
]         # End macro

dsLx  # store the macro in register L and execute it
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.