Giới thiệu

Trong nỗ lực gần đây của chúng tôi để thu thập danh mục các giải pháp ngắn nhất cho các bài tập lập trình tiêu chuẩn, đây là thử thách FizzBuzz vanilla đầu tiên của PPCG. Nếu bạn muốn xem các thử thách danh mục khác, có "Hello World!" và "Đây có phải là số nguyên tố không?" .

Thử thách

Viết chương trình in các số thập phân từ 1 đến 100. Nhưng đối với bội số của ba bản in Fizz, thay vì số lượng và cho bội số của năm bản in Buzz Buzz. Đối với các số là bội số của cả ba và năm bản in FizzBuzz '.

Đầu ra

Đầu ra sẽ là một danh sách các số (và Fizzes, Buzzes và FizzBuzzes) được phân tách bằng một dòng mới (hoặc \nhoặc \r\n). Một dòng mới có thể được chấp nhận, nhưng một dòng mới hàng đầu thì không. Ngoài sự lựa chọn của bạn về dòng mới, đầu ra sẽ trông giống như thế này:

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

Ngoại lệ duy nhất cho quy tắc này là đầu ra liên tục của trình thông dịch ngôn ngữ của bạn không thể bị loại bỏ, chẳng hạn như lời chào, mã màu ANSI hoặc thụt lề.

Quy tắc khác

• Đây không phải là tìm ngôn ngữ với cách tiếp cận ngắn nhất để chơi FizzBuzz, đây là về cách tìm cách tiếp cận ngắn nhất trong mọi ngôn ngữ. Do đó, không có câu trả lời sẽ được đánh dấu là chấp nhận.

• Đệ trình được ghi bằng byte trong một mã hóa có sẵn thích hợp, thường (nhưng không nhất thiết) UTF-8. Một số ngôn ngữ, như Thư mục, hơi khó để ghi điểm - nếu nghi ngờ, vui lòng hỏi trên Meta.

• Không có gì có thể được in ra STDERR.

• Không giống như các quy tắc thông thường của chúng tôi, vui lòng sử dụng ngôn ngữ (hoặc phiên bản ngôn ngữ) ngay cả khi nó mới hơn thử thách này. Nếu bất cứ ai muốn lạm dụng điều này bằng cách tạo một ngôn ngữ trong đó chương trình trống tạo đầu ra FizzBuzz, thì xin chúc mừng bạn đã mở đường cho một câu trả lời rất nhàm chán.

  Lưu ý rằng phải có một thông dịch viên để trình có thể được kiểm tra. Được phép (và thậm chí được khuyến khích) tự viết trình thông dịch này cho một ngôn ngữ chưa được thực hiện trước đó.

• Nếu ngôn ngữ bạn chọn là một biến thể tầm thường của ngôn ngữ khác (có khả năng phổ biến hơn) đã có câu trả lời (nghĩ phương ngữ BASIC hoặc SQL, shell Unix hoặc các dẫn xuất Brainfuck tầm thường như Alphuck và ???), hãy xem xét thêm ghi chú vào hiện tại trả lời rằng cùng một hoặc một giải pháp rất giống nhau cũng là ngắn nhất trong ngôn ngữ khác.

• Vì đầu ra là cố định, bạn có thể mã hóa đầu ra (nhưng đây có thể không phải là tùy chọn ngắn nhất).

• Bạn có thể sử dụng các giải pháp từ trước, miễn là bạn tin tưởng tác giả gốc của chương trình.

• Sơ hở tiêu chuẩn là không được phép.

Là một lưu ý phụ, xin vui lòng không downvote câu trả lời nhàm chán (nhưng hợp lệ) trong các ngôn ngữ không có nhiều để chơi golf; những câu hỏi này vẫn hữu ích cho câu hỏi này vì nó cố gắng biên dịch một danh mục đầy đủ nhất có thể. Tuy nhiên, chủ yếu thực hiện các câu trả lời trong các ngôn ngữ mà các tác giả thực sự phải nỗ lực để đánh gôn.

Mục lục

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>

Con trăn 2, 56

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

Lục giác , 91 byte

Cảm ơn vì tiền thưởng :)

Ồ, tôi sẽ không bao giờ tưởng tượng được mình có thể đánh bại giải pháp Hexagony của Martin . Nhưng người mà đã đánh cắp nó thì tôi đã hoàn thành nó. Sau nhiều ngày thất bại vì tôi không có công cụ tô màu Hexagony cũng như EsotericIDE để kiểm tra giải pháp của mình. Tôi đã hiểu sai một số khía cạnh của đặc tả kỹ thuật, vì vậy tôi đã tạo ra một vài giải pháp về vấn đề khác, chỉ sử dụng bút và giấy và trình soạn thảo văn bản. Chà, cuối cùng tôi đã vượt qua sự lười biếng của mình và nhân bản cả hai kho lưu trữ, tải xuống VisualStudio và biên dịch chúng. Wow, chúng là những công cụ hữu ích! Như bạn có thể thấy, tôi không phải là người mà bạn gọi là lập trình viên (ý tôi là, thôi nào! Tôi thậm chí còn chưa cài đặt VisualStudio và không có nhiều manh mối về cách biên dịch chương trình);)

Tôi vẫn phải mất một thời gian để tìm ra giải pháp hiệu quả, và nó khá chật chội và hỗn loạn, nhưng ở đây là trong tất cả vinh quang của nó:

Fizzbuzz trong một hình lục giác kích thước 6:

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

Bố cục hình lục giác:

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

Và bản phối tuyệt đẹp, nhờ vào Hexagony Colorer của Timwi's :

Vì vậy, đây là hình ảnh động GIF dài 110 giây với tốc độ 2 khung hình / giây, hiển thị luồng chương trình trong 6 số 1, 2, Fizz, 4, Buzz, Fizzđầu tiên, 220 tích tắc đầu tiên của chương trình (nhấp vào hình ảnh để xem kích thước đầy đủ):

Chúa ơi, nhờ phần mềm tổng hợp Natron, hoạt hình của con trỏ vẫn tẻ nhạt để tạo, nhưng có thể quản lý được. Lưu 260 hình ảnh của bộ nhớ là ít thú vị. Thật không may, EsotericIDE không thể làm điều đó tự động. Dù sao, hãy thưởng thức hoạt hình!

Rốt cuộc, một khi bạn quấn đầu quanh mô hình bộ nhớ và gói các đường dẫn khá phản trực giác đi qua biên giới của hình lục giác, Hexagony không khó để làm việc. Nhưng chơi golf nó có thể là một cơn đau ở mông. ;)

Thật là vui

Mê cung , 94 byte

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

Tiểu 100! Đây là một niềm vui.

Giải trình

Hãy bắt đầu với một đoạn mồi ngắn trên Labyrinth - hãy bỏ qua phần này nếu bạn đã quen thuộc với những điều cơ bản:

• Labyrinth có hai ngăn xếp - ngăn xếp chính và ngăn xếp phụ. Cả hai ngăn xếp đều có vô số số 0 ở dưới cùng, ví dụ +trên một ngăn xếp trống có thêm hai số không, do đó đẩy số không.

• Luồng điều khiển trong Labyrinth được quyết định bởi các nút giao, nhìn vào đỉnh của ngăn xếp để xác định nơi tiếp theo. Tiêu cực có nghĩa là rẽ trái, không có nghĩa là đi thẳng về phía trước và tích cực có nghĩa là rẽ phải ... nhưng nếu chúng ta va vào tường thì chúng ta sẽ đổi hướng. Ví dụ: nếu chỉ đi thẳng về phía trước và rẽ trái là có thể nhưng đỉnh của ngăn xếp là dương, thì vì chúng ta không thể rẽ phải, thay vào đó chúng ta rẽ trái.

• Các chữ số trong Labyrinth pop xvà đẩy 10*x + <digit>, giúp dễ dàng xây dựng số lượng lớn. Tuy nhiên, điều này có nghĩa là chúng ta cần một hướng dẫn để đẩy 0 để bắt đầu một số mới, đó là _trong Mê cung.

Bây giờ chúng ta hãy đi đến mã thực tế!

Màu đỏ

Thực thi bắt đầu từ "góc trên bên trái, đó là một NOP. Tiếp theo là ), tăng đỉnh của ngăn xếp, đẩy 1 trên đường chuyền đầu tiên và tăng ntrên mỗi đường chuyền tiếp theo.

Tiếp theo chúng tôi nhân đôi nvới :. Vì nlà tích cực, chúng tôi rẽ phải, thực hiện }(chuyển đỉnh của ngăn xếp chính sang phụ) và :. Chúng tôi rơi vào ngõ cụt, vì vậy chúng tôi quay lại và thực hiện }và :một lần nữa, để lại các ngăn xếp như

Main [ n n | n n ] Aux

Một lần nữa, nlà tích cực và chúng tôi rẽ phải, thực hiện _101/chia ncho 101. Nếu nlà 101 thì n/101 = 1chúng tôi chuyển sang @, kết thúc chương trình. Nếu không, tình hình hiện tại của chúng tôi là

Main [ n 0 | n n ] Aux

Cam 1 (mod 3)

3biến số 0 trên cùng thành 3 ( 10*0 + 3 = 3) và %thực hiện modulo. Nếu n%3là dương, chúng ta chuyển sang màu vàng ". Nếu không, chúng tôi thực hiện 70.105.122:.., mà đầu ra Fizz. Lưu ý rằng chúng tôi không cần phải đẩy zero mới với _từ n%3là zero trong trường hợp này, vì vậy chúng tôi có thể khai thác zero vô hạn ở dưới cùng của ngăn xếp. Cả hai con đường gặp lại nhau ở màu xanh nhạt.

Màu xanh nhạt

Đỉnh của ngăn xếp hiện tại n%3, có thể là dương, vì vậy _;chỉ cần đẩy số 0 và ngay lập tức bật lên để đảm bảo chúng ta đi thẳng về phía trước, thay vì chuyển sang @. Sau đó, chúng tôi sử dụng =để trao đổi đỉnh của ngăn xếp chính và phụ, đưa ra:

Main [ n | n%3 n ] Aux

Cam 2 (mod 5)

Đây là một tình huống tương tự như trước đây, ngoại trừ 66.117.122:..đầu ra Buzznếu n%5bằng không.

Xanh đậm

Phần trước để lại các ngăn xếp như

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

{chuyển n%3trở lại ngăn xếp chính và *nhân hai modul.

Nếu một trong hai modulo bằng 0, sản phẩm bằng 0 nên chúng ta chuyển thẳng sang màu vàng. =hoán đổi đỉnh của các ngăn xếp và _đẩy số 0 để đảm bảo chúng ta đi thẳng về phía trước, đưa ra

Main [ n 0 | 0 ] Aux

Mặt khác, nếu cả hai modul là nonzero, thì sản phẩm là nonzero và chúng ta chuyển sang màu xanh lá cây. =hoán đổi ngọn của ngăn xếp, cho

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

sau đó chúng ta sử dụng :để nhân đôi n, rẽ phải, sau đó sử dụng !để xuất ra n.

Màu tím

Tại thời điểm này, ngăn xếp chính có một hoặc hai mục, tùy thuộc vào đường dẫn nào được thực hiện. Chúng ta cần loại bỏ số 0 khỏi đường dẫn màu vàng và để thực hiện điều đó chúng ta sử dụng +, thực hiện n + 0theo một số thứ tự cho cả hai trường hợp. Cuối cùng, \xuất ra một dòng mới và chúng tôi trở lại từ đầu.

Mỗi lần lặp lại đẩy thêm (n%5)*(n%3)vào ngăn phụ, nhưng nếu không, chúng ta lại làm điều tương tự.

Perl 5, 49 byte

Tập lệnh 46 byte + 3 byte -E"..."

Việc sử dụng say(yêu cầu -E"...") có thể giảm hơn 46 byte do saytự động bao gồm một dòng mới (Cảm ơn @Dennis !):

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

Perl 5, 50 byte

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

Ruby, 50 byte

Yêu cầu phiên bản 1.8, dường như rất phổ biến đối với người chơi golf:

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

Trong Ruby hiện đại, bạn thay thế ?dbằng 100một giải pháp 51 byte.

Đây dường như là kỷ lục thế giới.

Java, 130 byte

Đây là phiên bản Java gần đây (7+). Ở những người lớn tuổi hơn, bạn có thể cạo thêm một chút bằng cách sử dụng enummánh khóe, nhưng tôi không nghĩ logic này ngắn hơn thế này (86 bên trong 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));}}

Bình thường, 30

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

Hãy thử nó ở đây

Giải trình:

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

Võng mạc , 317 139 134 132 70 63 60 55 byte

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

Hãy thử trực tuyến!

Giải trình

.100{`^
_

Các .là cờ im lặng toàn cầu mà tắt sản lượng tiềm ẩn ở phần cuối của chương trình. 100{kết thúc phần còn lại của chương trình trong một vòng lặp được thực hiện trong 100 lần lặp. Cuối cùng, bản thân sân khấu chỉ cần chèn một_ ở đầu chuỗi, làm tăng hiệu quả bộ đếm vòng đơn.

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

Cấu hình nhiều hơn. *\(kết thúc phần còn lại của chương trình trong một nhóm, in kết quả của nó bằng một dòng cấp dữ liệu, nhưng cũng khiến toàn bộ nhóm bị khô, điều đó có nghĩa là kết quả của nó sẽ bị loại bỏ sau khi in, do đó bộ đếm vòng lặp của chúng tôi không thực sự được sửa đổi .alà một công cụ sửa đổi regex tùy chỉnh neo neo regex vào toàn bộ chuỗi (giúp tiết kiệm một byte khi sử dụng ^và $rõ ràng).

Các giai đoạn nguyên tử tự chăm sóc Fizz. Tính phân chia 3có thể dễ dàng được kiểm tra một cách đơn nhất: chỉ cần kiểm tra nếu số có thể được viết dưới dạng lặp lại ___. Nếu đây là trường hợp, chúng tôi Fi;chuẩn bị cho chuỗi. Dấu chấm phẩy là sao cho vẫn còn một ranh giới từ phía trước số cho giai đoạn tiếp theo. Nếu chúng ta biến dòng thành Fizz___...vị trí giữa zvà _sẽ không được coi là một ranh giới, bởi vì regex coi cả chữ cái và dấu gạch dưới là ký tự từ. Tuy nhiên, dấu chấm phẩy cũng cho phép chúng ta loại bỏ zztrùng lặp từ FizzvàBuzz .

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

Chúng tôi làm tương tự chính xác cho việc chia hết 5và Bu;, mặc dù chúng tôi không cần phải giữ_ khoảng thời gian này. Vì vậy, chúng tôi sẽ nhận được một kết quả như

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

Điều này làm cho nó rất dễ dàng để loại bỏ các dấu gạch dưới chỉ trong các dòng có chứa Fizz, trong khi cũng điền vào zzs:

;_*
zz

Đó là, chúng tôi biến mỗi dấu chấm phẩy thành zznhưng chúng tôi cũng tiêu thụ tất cả các _s ngay sau nó. Tại thời điểm này, chúng tôi đã hoàn thành với FizzBuzz. Nhưng thách thức muốn đầu ra thập phân.

'_&`.

&chỉ ra một điều kiện: giai đoạn này chỉ được thực hiện nếu chuỗi chứa dấu gạch dưới. Do đó, Fizz, Buzzvà FizzBuzzlặp đi lặp lại được đụng đến nó. Trong tất cả các lần lặp khác (tức là những lần không chia hết cho 3 hoặc 5), chúng tôi chỉ đếm số lượng ký tự, chuyển đổi kết quả thành số thập phân.

gs2 , 1

f

Một trích dẫn từ Mauris, người tạo ra gs2:

Tôi muốn 1 byte của gorubyHello, world! , vì vậy ... Bản in này "1\n2\nFizz\n4\nBuzz\n...". :)

Cập nhật : Đã thêm câu trả lời 27 byte không sử dụng f.

Perl 5, 45 byte

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

Yêu cầu -Etùy chọn, được tính là một. Điều này phải được chạy từ dòng lệnh, tức là:

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

Dấu ngoặc kép quanh lệnh là không cần thiết, nếu một người tránh sử dụng không gian, hoặc bất kỳ ký tự khác mà có thể đóng vai trò như tách dòng lệnh ( |, <,> , &, vv).

Perl 5, 48 byte

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

Nếu các tùy chọn dòng lệnh được tính là một, -lthì sẽ tiết kiệm được một byte (bằng cách thay thế $/). Bằng cách cổ điển Perlgolf Quy định , tuy nhiên, điều này sẽ đếm 3: một cho -, một cho l, và một cho không gian cần thiết.

sáp ong ,104 89 81 byte

Đóng gói dày hơn cho phép cắt thêm 8 byte.

Giải pháp ngắn nhất (81 byte), cùng một luồng chương trình, cách đóng gói khác nhau.

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

Thay đổi khái niệm cho phép tôi cắt giảm mã 15 byte. Tôi muốn thoát khỏi thử nghiệm mod đôi 5 trong giải pháp, vì vậy tôi đã thực hiện một cờ.

Giải thích ngắn gọn:

nếu n%3=0Fizz được in và cờ được đặt. Cờ được thực hiện đơn giản bằng cách đẩy giá trị lstack hàng đầu lên gstack (hướng dẫn f).

Nếu n%5=0, thì n%3=0(trường hợp FizzBuzz) hoặc n%3>0(trường hợp Buzz). Trong cả hai trường hợp, Buzz được in và đặt lại cờ bằng cách bật ngăn xếp cho đến khi hết trống (hướng dẫn ?).

Bây giờ các trường hợp thú vị:

Nếu n%5>0, thì chúng ta đã có n%3=0(in trường hợp Fizz, n không được in) hoặc n%3>0(Fizz không được in, vì vậy n phải được in). Thời gian kiểm tra cờ. Điều này được nhận ra bằng cách đẩy chiều dài của gstack lên trên gstack (hướng dẫn A). Nếu n%3 was 0sau đó độ dài của gstack là> 0. Nếu n%3 was >0, độ dài của gstack là 0. Một bước nhảy có điều kiện đơn giản đảm bảo n chỉ được in nếu độ dài của gstack là 0.

Một lần nữa, sau khi in bất kỳ n, Fizz, và / hoặc Buzz và dòng mới, gstack sẽ được bật hai lần để đảm bảo nó trống. gstack trống hoặc []dẫn đến [0]sau lệnh A(độ dài đẩy của gstack trên gstack) hoặc nó chứa một số không ( [0], kết quả của n% 3), dẫn đến [0 1], vì [0] có độ dài 1. Popping từ một ngăn xếp trống không thay đổi ngăn xếp, vì vậy nó an toàn để bật hai lần.

Nếu bạn nhìn gần hơn, bạn có thể thấy rằng, về nguyên tắc, tôi đã gấp lại

>      q
d`Fizz`f>

vào

<f`z`<
d`Fiz`b

giúp loại bỏ tất cả không gian bị lãng phí giữa Avà <ở cuối hàng sau trong giải pháp cũ hơn dưới đây:

q?{@b'gA<       p      <

Giải pháp khái niệm mới (89 byte) bao gồm giải thích hoạt hình:

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

Bố cục hình lục giác:

   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

Hoạt hình của 326 tick đầu tiên ở 2 khung hình / giây, với các ngăn xếp cục bộ và toàn cầu, và xuất ra STDOUT.

Để so sánh, dưới đây là lớp phủ đường dẫn của giải pháp cũ hơn, phức tạp hơn. Có lẽ đó cũng là giải pháp đẹp hơn, từ quan điểm trực quan;)

> <> , 68 66 65 64 byte

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

Bí quyết duy nhất là nhân số dư như một điều kiện để in số. Theo cách đó, nếu một trong số đó là 0, chúng tôi sẽ không in số.

Bạn có thể thử nó ở đây .

Đã lưu một byte nhờ Sp3000 và một byte khác nhờ Randomra. Cảm ơn nhiều!

gs2 , 28 27 (không có f)

Lục bình:

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

Giải trình:

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

Việc nhúng 3 và 5 vào hằng chuỗi không hoạt động vì \x05kết thúc chuỗi ký tự.

Lưu ý: Vấn đề này có thể được giải quyết trong 1 byte với gs2 bằng cách sử dụng tích hợp f.

C, 85 byte

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

-2 nhờ vuông vắn.

CJam, 35 byte

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

Hãy thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

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.

MUMPS, 56 54 byte

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

Bạn w:$X<3 ihỏi cái gì thế này? $Xlà một biến ma thuật (một "nội tại") lưu trữ vị trí nằm ngang của con trỏ đầu ra (dưới dạng một số ký tự từ cạnh trái của thiết bị đầu cuối). wlà dạng viết tắt của WRITElệnh. Cú pháp command:condition argslà một hậu điều kiện - "nếu condition, thì làm command args".

Vì vậy, chúng tôi đang kiểm tra xem con trỏ đầu ra đã được nâng cao hơn hai ký tự chưa (có nghĩa là ít nhất một "Fizz"hoặc "Buzz"đã được ghi vào thiết bị đầu cuối) và nếu không, hãy ghi ivào thiết bị đầu cuối. Các $Xbiến - và do đó, loại này không thể chia sâu từ nhà ga - là một tính năng hạng nhất của quai bị. Rất tiếc.

Thạch , 24 20 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

³µ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.

Brainfuck, 206 byte

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

Định dạng:

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

Dùng thử trực tuyến

Bố cục bộ nhớ là

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

trong đó fchu kỳ bằng 3, bchu kỳ bằng 5, d1là một chữ số, d2là hàng chục chữ số, slà cờ cho việc in hàng chục chữ số, dchu kỳ bằng 10, clà không gian sao chép cho d, tlà không gian làm việc chứa 0 hoặc dữ liệu rác hoặc cờ không -divisible-by-3 và axác định chấm dứt chương trình bằng cách bù con trỏ sau khi Buzz được in 20 lần.

C #, 128 126 125 124 byte

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 byte mà không có mã soạn sẵn xung quanh.

Thực hiện với việc sử dụng định dạng có điều kiện của C # .

Với hai phần phân cách ;, Fizz hoặc Buzz được in nếu giá trị từ điều kiện của chúng bằng không.

Đã lưu tổng cộng 4 byte nhờ @RubberDuck, @Timwi và @Riokmij.

Clojure, 113 106 101 100 91 byte

Golf đầu tiên của tôi!

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

Ung dung:

(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))))))

brainfuck , 411 350 277 258 byte

Chỉnh sửa:

• -61 byte bằng cách lưu trữ các giá trị của "Fizz Buzz" dưới dạng "BuziF" "BuziG" và làm lại phần in số.

• -71 byte bằng cách làm lại phần in số modulo, tách bộ đếm vòng lặp và bộ đếm số và sử dụng lại ô dòng mới làm giá trị mod, trong số những thứ khác

• -19 byte bằng cách nhận ra rằng không có bất kỳ 0 nào trong bất kỳ số FizzBuzz nào. Cũng thêm lời giải thích

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

Hãy thử trực tuyến!

Thay vì kiểm tra xem số đó có chia hết cho 5 hay 3 không, tôi có hai bộ đếm theo dõi modulo của số, giảm chúng cho mỗi số và in ra từ tương ứng khi chúng về 0.

Làm thế nào nó hoạt động:

+[-[>+<<]>-]>--  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
]

PowerShell, 78 68 61 54 byte

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

_{Chỉnh sửa: Đã lưu 10 byte nhờ frageum}

_{Edit2: Nhận ra rằng với mánh khóe của frageum, tôi không còn cần phải xây dựng $ t dưới dạng một chuỗi khối mã}

_{Edit3: Đã lưu thêm 7 byte nhờ Danko Durbić}

Tương tự như tinh thần đối với cổ phiếu Rosetta Code trả lời , nhưng đã giảm xuống khá nhiều.

Giải trình

1..100|%{...} Tạo một bộ sưu tập từ 1 đến 100, sau đó cho từng đối tượng trong bộ sưu tập đó, làm

(...,$_)tạo một bộ sưu tập mới gồm hai phần tử: 0) $t=...đặt biến $tbằng một chuỗi; 1)$_ số hiện tại của vòng lặp

"Fizz"*!($_%3)lấy số hiện tại của chúng tôi, sửa đổi nó bằng 3, sau đó KHÔNG kết quả. Nhân "Fizz" với điều đó và thêm nó vào chuỗi (và tương tự cho 5). PowerShell coi bất kỳ số nào khác không $TRUE, và do đó, KHÔNG của số khác không là 0, nghĩa là chỉ khi số hiện tại của chúng tôi là bội số của 3 thì "Fizz" mới được thêm vào chuỗi.

[!$t] lập chỉ mục vào bộ sưu tập chúng ta vừa tạo, dựa trên giá trị của chuỗi $t - không trống, in nó, khác in số hiện tại của chúng tôi

Ngoài ra, cũng 54 byte

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

_{Cảm ơn T shipatingHeckler}

Tương tự trong khái niệm, điều này sử dụng -replacetoán tử nội tuyến và một biểu thức chính quy để hoán đổi một chuỗi rỗng ^$với số hiện tại của chúng tôi. Nếu chuỗi không trống, nó sẽ không bị tráo đổi.

Ngoài ra, cũng 54 byte

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

Đây là cấu trúc vòng lặp giống như trên, nhưng bên trong nó sắp xếp cặp (n, chuỗi) và dựa vào thực tế là một chuỗi rỗng sắp xếp trước một số, nhưng một chuỗi FizzBuzz sắp xếp theo một số. Sau đó, nó lập chỉ mục kết quả thứ hai.

JavaScript, 62 byte

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

Tôi nghĩ rằng đây là giải pháp Javascript ngắn nhất hiện nay.

C, 74 byte

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

Đối 0số printfthay vì ""là cá, nhưng dường như hoạt động trên hầu hết các nền tảng tôi thử nó. putssegfaults khi bạn thử điều tương tự, mặc dù. Không có nó, bạn nhận được 75 byte.

Có 73 giải pháp hoạt động trên sân golf vô chính phủ và tôi đã tìm thấy một giải pháp được đào bới ở đúng nơi trên internet, nhưng chúng dựa trên hành vi cụ thể của nền tảng. (Như bạn có thể đoán, đó là một cái gì đó có dạng puts("Buzz"±...).)

Cào, 203 185 byte

Số byte được tính từ biểu diễn văn bản được đánh gôn , trên mỗi bài đăng meta này . Scratch không phải là rất hiệu quả không gian.

saylà thứ gần nhất với stdout Scratch có: sprite hiển thị một bong bóng lời nói chứa bất cứ điều gì nó đang nói. Trong thực tế, một wait n secskhối sẽ cần thiết để thực sự đọc đầu ra này, nhưng với mục đích của thử thách này, mã này đáp ứng các yêu cầu.

R, 88 83 77 71 70 byte

Tôi chắc chắn rằng điều này có thể được cải thiện ... và nó đã được ghi có vào @flodel. Một vài byte nữa được lưu nhờ vào một đề xuất từ ​​@njnnja và một byte khác từ @ J.Doe

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

Haskell, 84 byte

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

Đến gần 81 byte của henkma , nhưng chưa hoàn toàn ở đó.

d = drop.(*4).mod nlà chìa khóa ở đây: d 3 "Fizz"là drop (n`mod`3 * 4) "Fizz". Đây là "Fizz"khin `mod` 3 0 và ""nếu không.

PHP, 54 byte

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

Có giá trị cho v5.5 trở đi. Đây õlà nhân vật 245, một chút đảo ngược \n.

Tôi giả sử các thiết lập trình thông dịch mặc định, vì chúng không có bất kỳ ini nào. Nếu bạn không chắc chắn, bạn có thể vô hiệu hóa ini cục bộ của mình -nnhư trong php -n fizzbuzz.php.

Một phiên bản sẽ chạy không có lỗi với hoàn toàn bất kỳ tệp cấu hình nào là 62 byte :

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

Mã máy 80386 + DOS, 75 byte

Mã thập phân của mã:

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

Mã nguồn (cú pháp 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

Mã này đếm từ 1 đến 100 in ax, xây dựng thông điệp đầu ra từ đầu đến cuối. Kết thúc tin nhắn (dòng mới và$ ký tự mà DOS sử dụng cho cờ kết thúc tin nhắn) xuất hiện ở đầu mã:

db 10, 10, '$'

Nó được thực hiện như một hướng dẫn vô hại (or ax, 240ah ). Tôi có thể đặt nó ở một nơi thông thường hơn, như sau khi kết thúc mã, nhưng có nó ở địa chỉ 0x100 có lợi ích.

Mã này cũng sử dụng 2 bộ đếm bổ sung:

• Đếm từ 3 đến 0 trong dl
• Đếm từ 5 đến 0 trong dh

Khi bộ đếm đạt 0, nó sẽ đẩy chuỗi Fizzhoặc Buzzđến cuối thông báo đầu ra. Nếu điều này xảy ra, bxsẽ được giảm, vàbh sẽ bằng không. Điều này được sử dụng như một điều kiện để xuất số ở dạng thập phân.

Lưu ý: Tôi đang sử dụng dữ liệu 32 bit ở đây. Điều này sẽ không hoạt động trên một máy tính trước 386.

đc 64 62 byte

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

Ung dung:

[[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