1,2,嘶嘶声4,4,嗡嗡声


148

介绍

在我们最近为标准编程练习收集最短解决方案目录的努力中,这是PPCG有史以来第一个香草FizzBu​​zz挑战。如果您希望看到其他目录方面的挑战,请访问“ Hello World!”。“这个数字是素数吗?”

挑战

编写一个程序,打印从1到100(含1和100)之间的十进制数字。但是,对于三倍打印“ Fizz”而不是数字,对于五倍打印“ Buzz”。对于三和五的倍数的数字,请打印“ FizzBu​​zz”。

输出量

输出将是由换行符(\n\r\n)分隔的数字(以及Fizzes,Buzzes和FizzBu​​zzes)列表。尾随换行符是可接受的,但前导换行符是不可接受的。除了您选择的换行符之外,输出应类似于以下内容:

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

该规则的唯一例外是您的语言解释器不断输出的内容,例如问候语,ANSI颜色代码或缩进​​,这些输出不能被禁止。

进一步规则

  • 这并不是要找到玩FizzBu​​zz的方法最短的语言,而是要找到每种语言的最短方法。因此,没有答案将被标记为已接受。

  • 用适当的预先存在的编码(通常(但不一定是)UTF-8)以字节为单位对提交进行评分。某些语言(例如文件夹)在评分上有些棘手-如果有疑问,请在Meta上提问。

  • 无法将任何内容打印到STDERR。

  • 与我们通常的规则不同,即使使用的语言(或语言版本)比此挑战新,也可以使用。如果有人想通过创建一种空程序会生成FizzBu​​zz输出的语言来滥用此功能,那么祝贺您为一个非常无聊的答案铺平了道路。

    请注意,必须有一个解释器,以便可以测试提交。允许(甚至鼓励)自己为以前未实现的语言编写此解释器。

  • 如果您选择的语言是已经有答案的另一种(可能更受欢迎的)语言的琐碎变体(请考虑使用BASIC或SQL方言,Unix shell或琐碎的Brainfuck派生词(例如Alphuck和???),请考虑在现有注释上添加注释回答说,相同或非常相似的解决方案也是另一种语言中最短的解决方案。

  • 由于输出是固定的,因此您可以对输出进行硬编码(但这可能不是最短的选择)。

  • 您可以使用现有的解决方案,只要您相信程序的原始作者即可。

  • 否则不允许出现标准漏洞。

附带说明一下,请不要在没有太多高尔夫乐趣的语言中对无聊(但有效)的答案投反对票;这些对于这个问题仍然很有用,因为它试图编译尽可能完整的目录。但是,主要是用作者实际上不得不努力打通代码的语言来提高答案的准确性。

目录

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. 这是仅在运行时还是在编译时(假设是一个单独的步骤?)
AShelly 2015年

@AShelly仅在运行时
Beta Decay

我不确定我是否喜欢您将100硬编码到挑战中这一事实。这样,仅生成预期输出的程序是有效条目,但对于此挑战而言并不有趣。我认为挑战应该在于程序要输入要输出的项目数。
Timwi

6
@Timwi虽然我同意这样做(只会稍微有趣),但我经常看到FizzBu​​zz严格按1到100的比例进行显示(例如,在Wikipedia和Rosetta Code上)。如果目标是进行“规范的” FB挑战,那是有道理的。
Geobits 2015年

58
“香草嘶嘶声”听起来很美味。
iamnotmaynard 2015年

Answers:


76

Python 2,56

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

6
ang,那真是个天才。我可以窃取您的想法,将字符串乘以mod结果吗?
AdmBorkBork

@TimmyD继续。
feersum

15
为56(从A不同的方法在这里): i=1;exec"print'FizzBuzz'[i%-3&4:12&8-i%5]or i;i+=1;"*100。任何人都想要蛮力搜索表达式来尝试优化位扑吗?
xnor 2015年

1
非常好的技术,我喜欢模运算结果的除法使其成为二进制!我有一项改进,可以将您的方法减少到54个字符...当然,未经您的允许,我不会将其发布为答案(因为它是您答案的95%);)
Tersosauros

2
@Tersosauros继续...我的方法并不是很难找到,而且无疑被很多人独立发现了。
feersum

76

六边形,91字节

谢谢你的赏金:)

哇,我从来没有想到过我能击败马丁的Hexagony解决方案。但是-谁会打它-我完成了。失败几天后,因为我既没有六角着色剂也没有EsotericIDE来检查我的解决方案。我弄错了规范的几个方面,因此仅使用笔和纸以及文本编辑器就产生了一些错误的“解决方案”。好吧,最后我克服了懒惰,克隆了两个存储库,下载了VisualStudio并对其进行了编译。哇,它们是什么有用的工具!正如您所看到的,我远非要当程序员的人(我的意思是,来吧!我什至没有安装Visual Studio,并且对如何编译程序一无所知);)

我仍然花了一些时间来找到一个可行的解决方案,这确实充满了混乱和混乱,但在这里却充满了荣耀:

大小为6的六角形的Fizzbuzz:

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

六角形布局:

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

以及美丽的演绎,这要归功于Timwi的Hexagony Colorer

彩色六角FizzBu​​zz解决方案

因此,这是一个110秒长的GIF动画,速度为2 fps,显示了程序的前6个数字1, 2, Fizz, 4, Buzz, Fizz,程序的前220个滴答声期间的程序流程(单击图像获得完整大小):

在此处输入图片说明

我的天哪,由于使用了Natron合成软件,指针的动画仍然难以创建,但易于管理。保存260张内存图像的乐趣较小。不幸的是,EsotericIDE无法自动执行此操作。无论如何,享受动画吧!

毕竟,一旦您将脑袋缠绕在内存模型上,并且将与六角形边界交叉的路径进行了相当违反直觉的缠绕,那么六角形就不那么难使用了。但是打高尔夫球可能会使人痛苦不堪。;)

好玩!


1
非常好!:)这就是我忘了亲自尝试侧长6的经验。;)(很有趣,看看我的解决方案是否更容易适合边长6。)
Martin Ender

@MartinBüttner我希望看到它:)
ML

2
与您相比,我不是程序员,因为Visual Studio是什么?:P
Rɪᴋᴇʀ

5
不幸的是,EsotericIDE无法自动执行此操作。—请继续并提出功能建议,有一天我可能会去做:)
Timwi

1
(糟糕的是,在最后一次回复后的6个月内出现了这个问题),您可以通过将灰色路径移动1个字节,然后在橙色路径中放置一个“取消操作”,像这样从程序末尾退出1个字节3}1"$.!$>)}g4_'{$))}\<$\.\.@\;F\$/;z;u;<%<_>_..$>B/<>}))'%<>{>;e"-</_%;\/{}/>.\)(z;i;..>('。现在有一个额外的功能(在z之后,可以用a“取消”)或将z放在此处。现在它是一个),它将橙色路径上的所有命令推后1个滴答,然后返回第3行的无操作。顺便说一句,由于Hexagony Colorer和Esoteric IDE,我还安装了Visual Studio:P
Sunny Pun

44

迷宫,94字节

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

低于100!这很有趣。

说明

让我们从关于迷宫的简短入门入手-如果您已经熟悉基本知识,请随时跳过:

  • 迷宫有两个堆栈-主堆栈和辅助堆栈。两个堆栈的底部都具有无限数量的零,例如+,在空堆栈上将两个零相加,从而推入零。

  • 迷宫中的控制流由结点决定,这些结点位于堆栈的顶部,以确定下一步要去哪里。负数表示左转,零数表示直行,正数表示右转...但是,如果碰到墙,我们将反转方向。例如,如果仅可能向前直行并向左转,但堆栈的顶部为正,则由于我们无法向右转,因此我们向左转。

  • 迷宫中的数字会弹出x并推动10*x + <digit>,这很容易建立大量数字。但是,这意味着我们需要输入0才能开始一个新的数字(_位于迷宫)的指令。

现在让我们看一下实际的代码!

在此处输入图片说明

红色

执行从"左上角的NOP开始。下一个是),它递增堆栈的顶部,在第一遍中按1,在n随后的每一遍中递增。

接下来我们重复n使用:。由于n为正数,因此我们向右转,执行}(将主堆栈的顶部移至辅助堆栈)和:。我们走到了尽头,所以我们转身执行}:再一次,使栈像

Main [ n n | n n ] Aux

再次n为正,我们右转,执行_101/除以n101的运算。如果n为101,然后n/101 = 1我们变为@,则终止程序。否则,我们目前的情况是

Main [ n 0 | n n ] Aux

橙色1(mod 3)

3将最上面的零变成3(10*0 + 3 = 3)并%执行模。如果n%3为正,我们右转到黄色"。否则,我们执行70.105.122:..输出Fizz。请注意,我们并不需要推新与零_,因为n%3在这种情况下为零,所以我们可以在堆栈底部开拓无限零。两条路径再次以浅蓝色相交。

浅蓝

当前堆栈的顶部是正数n%3,可以为正数,因此_;Just推零并立即弹出它以确保我们一直前进,而不是转入@。然后=,我们用于交换主堆栈和辅助堆栈的顶部,得到:

Main [ n | n%3 n ] Aux

橙色2(mod 5)

除了66.117.122:..输出Buzzif n%5为零之外,这与之前类似。

深蓝

上一节将堆栈像

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

{n%3后移到主堆栈并*乘以两个模数。

如果任一模为零,则乘积为零,因此我们直接变成黄色。=交换栈顶并_推零以确保我们一直前进,给出

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

Perl 5,49个字节

46字节脚本+ 3字节 -E"..."

使用say(需要-E"...")可以将其进一步减少到46个字节,因为它会say自动包含换行符(感谢@Dennis!):

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

Perl 5,50个字节

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

您可以使用来节省一些字节say
丹尼斯2015年

您打破了计分板...
LegionMammal978

@ LegionMammal978是的。是的,我做到了...我会尝试重新命名标题!啊!
Dom Hastings 2015年

-E"..."8个字节吗?空格+短划线+选项+参数(+引号)。
暴民埃里克(Erik the Outgolfer)'16

1
@EriktheGolfer,所以自从我发布此内容以来,共识是-E0字节,但是由于primo的答案是在不包括引号的情况下得到的,因此我选择了使其公平,并将引号包括在mine和+1中-E。它被接受为免费的原因是Perl通常是通过Perl运行的perl -eperl -E不再有字节(我认为-M5.010use 5.010可以是免费的,但也许不会重新读取meta post)。与一起运行时,添加-p或时将-n其计为+1 perl -pe。希望有帮助!中继参考:meta.codegolf.stackexchange.com/a/7539
Dom Hastings

27

Ruby,50个字节

需要版本1.8,这似乎在高尔夫球手中很流行:

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

在现代的红宝石,替换?d100一个51字节的解决方案。

这似乎是世界纪录。


1
那是恶魔般的,喜欢它。
卡姆登·纳尔兹特

?d就是100。该FizzBuzz字符串中包含换行符,这在Ruby中有效。string[i, s]是一个切片,从字符i(0索引)开始,一直到s字符,忽略指向字符串外部的索引。如果to的参数puts已经有换行符,则将其切掉。该公式应该简单易读?它在这里完成所有工作。没有一些真正的红宝石高尔夫球手的帮助,我不会找到它的。
林恩

旁注:如果允许在输入的开头添加0(不是),则可以使用?e.times代替保存2个字节。
Shelvacu 2015年

你能解释一下这个[i=n**4%-15,i+13]部分吗?似乎无法绕过我的头
Piccolo

2
@Piccolo 这个摘要有帮助吗?如果i==-14切片超出范围,那么我们得到nil。如果i==-9我们i+13==4从末尾的第9个字符开始对字符进行切片,则'Fizz'。如果i==-5我们从末尾的第5个字符开始切片8个字符,则'Buzz\n'。(我们尝试对8进行切片,但只有5,因此得到5。)等等
林恩

26

Java,130字节

这适用于最新的Java版本(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));}}

我不认为初始化程序块技巧在这里有帮助,因为问题指定了空的stderr。
feersum

嗯 我知道将静态技巧打印到stderr,但是我认为enum运行得很干净。众所周知:)
Geobits 2015年

4
用14个字节击败我!用<1代替== 0是节省的好方法!
ESP 2015年

2
class F{public static-> interface F{static在Java 8中
TheNumberOne

1
这不是枚举是如何工作的。您将必须这样做enum F{;public...,因此实际上不会保存任何字节。
HyperNeutrino

23

珀斯,30岁

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 ,从而有效地增加了一元循环计数器。

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

更多配置。*\(将程序的其余部分包装在一个组中,以换行符打印其结果,但也将整个组空运行,这意味着其结果将在打印后被丢弃,因此实际上我们的循环计数器没有被修改。a是一个自定义正则表达式修饰符,它将正则表达式锚定到整个字符串(在使用^$显式保存一个字节)。

原子级本身负责Fizz3一元除法可以很容易地在一元中检查:只需测试数字是否可以重复写入即可___。如果是这种情况,我们Fi;将在字符串之前。用分号表示,以便下一阶段在数字前仍然有单词边界。如果我们把行成Fizz___...之间的位置z,并_不会被视为一个边界,因为正则表达式把字母和下划线的文字字符。但是,分号还允许我们zzFizz和中删除重复项Buzz

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

我们通过5和进行除数的操作完全相同Bu;,尽管此时不需要保持_s。所以我们会得到类似的结果

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

这使得仅在包含的行中除去下划线非常容易Fizz,同时还填充了zzs:

;_*
zz

就是说,我们将每个分号都变成了,zz但是_在它之后我们也消耗了所有s。至此,一元代码中的FizzBu​​zz已经完成。但是挑战是要十进制输出。

'_&`.

&表示有条件:仅当字符串包含下划线时才执行此阶段。因此,FizzBuzzFizzBuzz迭代保持不变。在所有其他迭代中(即那些不能被3或5整除的迭代),我们只计算字符数,将结果转换为十进制。


20

GS2,1

f

一个报价从Mauris,GS2的创建者:

我想要一个goruby的1字节Hello, world!,所以...打印"1\n2\nFizz\n4\nBuzz\n..."。:)

更新:添加了不使用的27字节答案f


20

Perl 5,45个字节

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

需要-E选项,计为一个。这必须从命令行运行,即:

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

周围的命令行情是不必要的,如果一个避免使用空间,或者它可以作为命令行分离器起作用(任何其他字符|<>&,等等)。


Perl 5,48个字节

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

如果命令行选项每个都计为一个,-l则将节省一个字节(通过替换$/)。但是,按照经典Perlgolf规则,这将算为3:一个用于-,一个用于l,以及一个用于必要的空间。


您可以将say,与-E开关一起使用,该开关的编辑距离为1到-e,因此应计为1个字节。
丹尼斯

嘿primo,我觉得我在使用中作弊say,我假设-E可以代替-e它使用,这样您可以降低到44,而不是46。我认为我得分并不公平与您不同的是,首选的评分机制是什么?我通常print用以避免这种情况!最近的一个共识是这个
Dom Hastings 2015年

我个人认为命令行上的每个附加字节都应得分1。特别是say,如果您的代码可以在避免任何OS分隔符的情况下写在一行上,则得分1 -E。如果您需要使用引号,例如-E"$a||$b",得分3。如果您不能在一行上使用它,请为得分5 -M5.01。但是到那时,使用可能会更好-l。我不同意默认情况下它应该是免费的,原因有两个:1)改进是微不足道的,没有意义,并且2)没有默认启用的解释器版本。
primo

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个字节的代码。我想摆脱解决方案中的double mod 5测试,所以我实现了一个标志。

简短说明:

如果n%3=0Fizz被打印,并且标志被设置。只需将顶部的lstack值压入gstack(指令f)即可实现该标志。

如果为n%5=0,则n%3=0(FizzBu​​zz大小写)或n%3>0(Buzz大小写)。在这两种情况下,Buzz都会被打印,并且通过弹出堆栈直到其为空(指令?)来重置标志。

现在有趣的情况:

如果为n%5>0,则要么是我们n%3=0(打印Fizz情况,不得打印n),要么是n%3>0(没有打印Fizz,因此必须打印n)。是时候检查标志了。这是通过将gstack的长度推到gstack(指令A)之上来实现的。如果是,n%3 was 0则gstack长度> 0。如果为n%3 was >0,则gstack的长度为0。简单的条件跳转确保仅当gstack的长度为0时才打印n。

同样,在打印n,Fizz和/或Buzz和换行符中的任何一个后,gstack弹出两次以确保其为空。gstack为空[],导致[0]后指令A(将gstack推入gstack的长度),或者它包含一个零([0]n%3的结果),导致为[0 1],因为[0]的长度为1。空堆栈不会更改堆栈,因此可以安全弹出两次。

如果您仔细观察,您会发现原则上我折叠了

>      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

前326个节拍的动画以2 fps速度播放,并带有本地和全局堆栈,并输出到STDOUT。

蜂蜡FizzBu​​zz动画


为了进行比较,下面是较旧的更复杂解决方案的路径覆盖。从视觉的角度来看,也许它也是更漂亮的解决方案;)

带路径叠加的程序


2
这和六角形一样疯狂和美丽。+1!
ETHproductions 2016年

@ETHproductions我仍然需要尝试一下Hexagony,但是从语言规范可以看出,我的蜂蜡甚至还不能接近Hexagony的疯狂程度。
ML


您如何制作这些动画?
baordog '18

18

> <>68 66 65 64字节

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

唯一的技巧是将余数相乘作为数字打印的条件。这样,如果其中之一为0,我们将不会打印该数字。

您可以在这里尝试。

Sp3000节省了一个字节,而randomera节省了另一个字节。非常感谢!


1
打高尔夫球非常好,我喜欢第一行中的“ \”和第二行中的“ \”的重用。
2015年

1
o我相信,如果您将第二行的结尾处的-1字节移动到该行的开头处的空白处,则为-1字节。
Sp3000

@ Sp3000的确,我花了很多时间打高尔夫球,我不知道这是怎么回事
Aaron

1
谁有能力,谁需要嘶嘶声foooo Buzz
caird coinheringaahing

17

GS228 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终止字符串文字。

注意:可以使用内置的gs2 在1个字节中解决此问题f


16

C,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。它给了我一个编译错误。我需要将任何参数传递给编译器吗?顺便说一句,您错过了<=您的帖子(我用<= ...算出88个字节,所以即时通讯假定它丢失了)。
wendelbsilva

哎呀 错过了警告中的错误。加2个字符。
AShelly

全局变量被初始化为零,因此请main(i)尝试使用i;main()。然后,您可以i--for()循环开始时摆脱。您也不需要换行。这应该带来的字节数下降到85
娇气ossifrage

2
根据要获取的UB的方式,可以执行73、74或75个字节。这是我74字节的答案
林恩

1
我的天哪,我花了3个小时试图把这个东西缩小一个字节。干得好。更换(i%3&&i%5)*ii%3*i%5?i:0我要去睡觉了
阿尔伯特·伦肖

16

CJam,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}/
aditsu

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是一个魔术变量(“本征”),用于存储输出光标的水平位置(从终端的左边缘开始的多个字符)。wWRITE命令的缩写形式。语法command:condition args是一个后置条件-“ if condition,then do command args”。

因此,我们正在检查输出游标是否已前进了两个以上的字符(这意味着至少一个"Fizz""Buzz"已经写入到终端),如果不是,则写入i终端。该$X可变-因此,这种从终端深不可分的-是腮腺炎一流特征。kes


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.

再没有人出来golfed丹尼斯(除HQ9 +风格的答案)
noɥʇʎԀʎzɐɹƆ

15

疯子,206字节

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

格式:

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

在线尝试

内存布局是

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

其中f以3为b周期,以5 d1为周期,是一个数字,d2是十位,s是用于打印是否以十进制为标志的标志,d以10 c为周期,是用于复制的空间dt是用于保存0或垃圾数据的工作空间,或者用于不用于打印的标志-divisible-by-3,并a在Buzz打印20次后通过偏移指针来确定程序终止。


14

C#,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#的条件格式完成

如果使用两个部分分隔符;,则如果条件值为零,则会打印Fizz或Buzz。


感谢@ RubberDuck,@ Timwi和@Riokmij,总共节省了4个字节。


Write直接调用新行并将其附加到字符串上会更短,对吗?
RubberDuck

i%3*i%5>0?i:0代替还要短一个字节i%3*i%5==0?0:i
Timwi

您可以for使用for(var i=0;i++<100;)
Najkin 2015年

1
您可以通过利用C#6.0的字符串插值并将格式参数嵌入字符串本身来节省三个字节(例如$"{(i%3*i%5>0?i:0):#}...\n"
LiamK 2015年

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");}}
Jerri Kangasniemi

14

Clojure中,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))))))

取消高尔夫:

(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
您可以通过printlnJava解决方案中相同的方法来删除5个字符,例如。(doall(map #(let[t(=(mod % 3)0)](println(str(if t"Fizz""")(if(=(mod % 5)0)"Buzz"(if t""%)))))(range 1 101)))
resueman 2015年

1
@resueman谢谢!它实际上最终为7,因为(if t"Fizz""")可以简化为(if t"Fizz")。:)
Sam Estep

+1不错的模数技巧,起初我虽然有一个失误的错误。
coredump

14

brainfuck411个350 277 258字节

编辑:

  • 通过将“ Fizz Buzz”的值存储为“ BuziF”“ BuziG ”并重做数字打印部分,可以得到-61字节。

  • 通过重做模数打印部分,拆分循环计数器和数字计数器,以及将换行单元重用为mod值,从而获得-71字节

  • 通过意识到FizzBu​​zz数字中没有0来获得-19个字节。还添加了解释

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

在线尝试!

我没有检查数字本身是否可以被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
]

干得好乔!我可能有一天会尝试击败它:)
Forcent Vintier

13

PowerShell,78 68 61 54字节

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

编辑:由于feersum保存了10个字节

Edit2:意识到用feersum的把戏,我不再需要将$ t表示为一个代码字符串块

EDIT3:保存的另外7个字节感谢丹科Durbić

精神上与股票的《罗塞塔密码》(Rosetta Code)回答相似,但打得很多。

说明

1..100|%{...} 创建1到100的集合,然后对该集合中的每个对象进行

(...,$_)创建两个元素的新集合:0)$t=...将变量设置为$t等于字符串;1)$_循环的我们当前数

"Fizz"*!($_%3)取我们的当前数字,将其修改为3,而不是结果。乘以“ Fizz”,然后将其添加到字符串中(与5类似)。PowerShell将任何非零数字视为$TRUE,因此非零数字的NOT为0,这意味着仅当our-current-number为3的倍数时,才会将“ Fizz”添加到字符串中。

[!$t]根据字符串的值索引刚刚创建的集合的索引$t-非空,打印它,否则打​​印出我们当前的数字


另外,也是54个字节

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

感谢TesselatingHeckler

在概念上类似,它使用内联运-replace算符和正则表达式将空字符串^$替换为我们的当前编号。如果字符串为非空,则不会被交换。


另外,也是54个字节

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

这是与上述相同的循环结构,但是在其内部对(n,字符串)进行排序,并依赖于以下事实:空字符串在数字之前排序,而FizzBu​​zz字符串在数字之后排序。然后,它索引第二个排序结果。


顺便说一句,如果PowerShell曾经||像C#中那样实现了运算符,我们可能会减少到43个字节,类似于1..100|%{"Fizz"*!($_%3)+"Buzz"*!($_%5)||$_}...令人怀疑,因为|PowerShell是PowerShell中如此重要的特殊运算符,但我可以梦想...
AdmBorkBork

1
如何1..100|%{'Fizz'*!($_%3)+'Buzz'*!($_%5)-replace'^$',$_}为54?
TessellatingHeckler,2015年

您可以替换if($t){$t}else{$_}($t,$_)[!$t]
DankoDurbić15年

1
...所以您得到1..100|%{(($t="Fizz"*!($_%3)+"Buzz"*!($_%5)),$_)[!$t]}的也是54,例如
@TessellatingHeckler

@TessellatingHeckler如果不灵活,PowerShell将一无所获。
AdmBorkBork 2015年

13

JavaScript,62个字节

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

我认为这是目前最短的Javascript解决方案。


哇,哇!但是所有其他JS答案都使用console.log; 它比必须连续在100个弹出框上按“确定”要麻烦得多。你能改变这个吗?它只有62个字节,比我的还好三个字节。
ETHproductions 2015年

我明天必须这样做,因为我已经编辑了5个我自己的帖子,现在无法再编辑了……
Mama Fun Roll

2
哦,我没有意识到编辑的限制...
ETHproductions 2015年

12

C,74个字节

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

代替的0说法有些可疑,但似乎可以在我尝试过的大多数平台上使用。但是,当您尝试相同的操作时会出现段错误。没有它,您将获得75个字节。printf""puts

有73字节的解决方案可用于无政府状态高尔夫,我发现一个解决方案可以在Internet的正确位置进行挖掘,但是它们依赖于特定于平台的行为。(您可能已经猜到了,它是某种形式的puts("Buzz"±...)。)


对于无参数情况(argc = 1),获得i = 1的好技巧。它的功能是:您可以通过运行./fizzbuzz $(seq 40):P
Peter Cordes

12

从无到有,203个 185字节

根据此meta帖子,从打高尔夫球的文本表示形式算起的字节数。划痕不是很节省空间。

say是最接近Scratch的标准配置:精灵显示一个语音泡沫,其中包含所说的内容。实际上,wait n secs将需要一个块来实际读取此输出,但是出于此挑战的目的,此代码满足了要求。


y =(两次出现)之后,您都缺少数字
Beta Decay

@BetaDecay对不起?我不懂
timothymh 2015年

在重复循环内,set y to ...缺少一个值
Beta Decay 2015年

1
@BetaDecay这是空字符串。:)如果您单击该图像,则可以对其进行查看!
timothymh 2015年

噢哈哈,对您的怀疑深表歉意;)
Beta Decay 2015年

12

R,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)

猫的答案。鼠标在上面:)
Silviu Burcea 2015年

1
我发现好一点了:x=1:100;i=!x%%3;j=!x%%5;x[i]="Fizz";x[j]="Buzz";x[i&j]="FizzBuzz";cat(x,sep="\n")
flodel

@njnnja感谢您的建议。我用一个write而不是cat虽然实现了它
MickyT 2015年

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字节高尔夫。
J.Doe '18 -10-10

68个字节。字节计数包含三个不可打印的退格键,并且在TIO中无法正常工作。
J.Doe

12

Haskell,84个字节

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

接近henkma的81个字节,但还不够。

d = drop.(*4).mod n在这里很关键:d 3 "Fizz"drop (n`mod`3 * 4) "Fizz"。这是"Fizz"when n `mod` 3为0,""否则为。


我认为重排会将其降低到82 (%)=drop.(*4).mod n;main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100]]
CR Drost 2015年

等待,然后n不在范围内。嗯
CR Drost

是的,那是行不通的,但是我找到了一个看起来很像的替代85字节解决方案:main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100],(%)<-[drop.(*4).mod n]]
Lynn 2015年

为什么不使用换行符?它和分号一样短,但是不太可读。
dfeuer

1
我建议您在一个代码高尔夫网站上重新考虑对可读代码的追求:)
Lynn

11

PHP,54字节

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

从v5.5起有效。该õ是字符245,有点颠倒\n

我假设使用默认的解释器设置,因为它们没有任何ini。如果你不确定,你可以禁用本地INI -n作为php -n fizzbuzz.php

绝对可以在任何配置文件中无错误运行的版本为62字节

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

STFU运算符@不一定表示代码没有错误。
sitilge


@Kzqai ideone.com/0zRA9e short_open_tag已关闭,E_NOTICE已打开。这些都不是默认设置。
primo

我在3v4l.org上遇到一堆错误
编码器

@acoder 相关meta post。3v4l.org似乎很有用。
2016年

11

80386机器代码+ DOS,75字节

代码的十六进制转储:

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 in计数,ax从头到尾构建输出消息。消息的结尾(换行符和$DOS用于消息结束标记的字符)出现在代码的开头:

db 10, 10, '$'

它作为无害指令(or ax, 240ah)执行。我可以将其放在更常规的位置,例如在代码结尾之后,但是将其放在地址0x100会有好处。

该代码还使用2个其他计数器:

  • 从3到0英寸计数 dl
  • 从5到0英寸计数 dh

当计数器达到0时,它将字符串Fizz或推Buzz入输出消息的末尾。如果发生这种情况,bx它将减少,并且bh将为零。这用作以十进制形式输出数字的条件。

注意:我在这里使用32位数据。这在386之前的计算机上不起作用。


TASM是否真的以与NASM相反的顺序处理多字节字符常量?在NASM,你写mov [mem], 'Fizz'存储Fizz的顺序在内存中,匹配db指令。例如,请参阅我过于复杂的“高效” YASM FizzBu​​zz
彼得·科德斯

1
是否保存要使用的任何字节std,然后stosb/ stosd?您必须test bh,bhcmp di, 100h或替换。除了将计数器保存/恢复到AL中之外,您还可以随时将其保留在BL中,而只是将垃圾发送给eax。例如sub bx, 4/ mov dword ptr [bx], 'zzuB'是3 + 7个字节,对不对? mov eax, 'zzuB' / stosd是6 + 2个字节(两个都带有操作数大小的前缀)。如果答案包括反汇编,这样指令的大小是可见的,那将是很好的。
彼得·科德斯

1
这是一个很好的答案-滥用数据的良性指令并使用从未使用过的PSP内存空间。@PeterCordes我使用过您的建议,stosd但自己却无法降低分数。由于此后stosd递减DI,所以您不会丢失sub di, 4,然后最后减少DI4个字节。我能够-6 bytes使用其他一些小的调整,最终将它们作为一个单独的答案发布(只是因为我可能无法在所有评论中加入)。荣誉!
640KB

11

直流电 64 62个字节

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

取消高尔夫:

[[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
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.