Vim, 44 bytes

33o<CR>Fizz<CR><Esc>qqABuzz<Esc>5kq19@q:%s/^$/\=line('.')<CR>

On vimgolf.com we have the classic Remember FizzBuzz?, which is similar to this, but keeps the numbers on all the lines. There's also Neither Fizz nor Buzz, which uses a similar format, but provides a useful input file. Those small differences drastically change the optimal solution. I did exactly this same variation 2 years ago in the edit to this reddit post. I had to check whether visual increment (not available back then) creates an improvement, like it has for the other variations, but it looks like it hasn't.

• 33o<CR>Fizz<CR><Esc>: Create the Fizz lines AND the blank lines with a simple insert mode repeat. Much quicker than a macro. AFAIK first discovered by @KersonHsiao in the vimgolf.com version, and used by every top solution since.
• qqABuzz<Esc>5kq19@q: A very simple macro appends the Buzzes.
• :%s/^$/\=line('.')<CR>: Replaces all blank lines with that line's line number. The expression replacement is very long, so this tactic is rarely used in vimgolf, but the alternatives are all worse.

R, (削除) 88 (削除ここまで) (削除) 83 (削除ここまで) (削除) 77 (削除ここまで) (削除) 71 (削除ここまで) 70 bytes

(削除) I'm sure that this can be improved (削除ここまで) ... and it was with credit to @flodel. A further couple of bytes saved thanks to a suggestion from @njnnja and another from @J.Doe

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

• \$\begingroup\$ A cat answer. The mouse is above :) \$\endgroup\$

  Silviu Burcea

  – Silviu Burcea

  2015年09月25日 10:36:36 +00:00

  Commented Sep 25, 2015 at 10:36
• 2
  \$\begingroup\$ I found a bit better: x=1:100;i=!x%%3;j=!x%%5;x[i]="Fizz";x[j]="Buzz";x[i&j]="FizzBuzz";cat(x,sep="\n") \$\endgroup\$

  flodel

  – flodel

  2015年09月28日 02:13:07 +00:00

  Commented Sep 28, 2015 at 2:13
• \$\begingroup\$ @njnnja Thanks for the suggestion. I implemented it with a write rather than cat though \$\endgroup\$

  MickyT

  – MickyT

  2015年09月28日 19:07:47 +00:00

  Commented Sep 28, 2015 at 19:07
• 2
  \$\begingroup\$ Necromancy here! The write call can take a 1 instead of a an empty string so x=y=1:100;y[3*x]='Fizz';y[5*x]='Buzz';y[15*x]='FizzBuzz';write(y[x],1) is a trivial 1 byte golf for 70 bytes. \$\endgroup\$

  J.Doe

  – J.Doe

  2018年10月01日 13:00:26 +00:00

  Commented Oct 1, 2018 at 13:00
• \$\begingroup\$ 68 bytes. The bytecount includes three unprintable backspaces, and it doesn't work correctly in TIO. \$\endgroup\$

  J.Doe

  – J.Doe

  2018年10月04日 21:41:27 +00:00

  Commented Oct 4, 2018 at 21:41

PHP, 54 bytes

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

Valid for v5.5 onwards. The õ is character 245, a bit inverted \n.

I assume the default interpreter settings, as they are without any ini. If you are uncertain, you may disable your local ini with -n as in php -n fizzbuzz.php.

A version which will run error-free with absolutely any configuration file is 62 bytes:

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

• \$\begingroup\$ The STFU operator @ does not necessarily mean that the code is error free. \$\endgroup\$

  sitilge

  – sitilge

  2015年09月28日 12:42:47 +00:00

  Commented Sep 28, 2015 at 12:42
• \$\begingroup\$ ideone.com/5rfNt0 \$\endgroup\$

  Kzqai

  – Kzqai

  2015年09月30日 06:55:07 +00:00

  Commented Sep 30, 2015 at 6:55
• \$\begingroup\$ @Kzqai ideone.com/0zRA9e short_open_tag is off, E_NOTICE is on. Neither of these are default settings. \$\endgroup\$

  primo

  – primo

  2015年09月30日 11:46:47 +00:00

  Commented Sep 30, 2015 at 11:46
• \$\begingroup\$ I'm getting a bunch of errors on 3v4l.org \$\endgroup\$

  a coder

  – a coder

  2016年01月27日 23:42:43 +00:00

  Commented Jan 27, 2016 at 23:42
• \$\begingroup\$ @acoder relevant meta post. 3v4l.org seems useful. \$\endgroup\$

  primo

  – primo

  2016年01月28日 09:32:15 +00:00

  Commented Jan 28, 2016 at 9:32

80386 machine code + DOS, 75 bytes

Hexdump of the code:

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

Source code (TASM syntax):

 .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

This code counts from 1 to 100 in ax, building the output message from the end to the beginning. The end of the message (newline and the $ character that DOS uses for end-of-message flag) appears at the beginning of the code:

db 10, 10, '$'

It's executed as a harmless instruction (or ax, 240ah). I could put it in a more conventional place, like after the end of the code, but having it at address 0x100 has a benefit.

The code also uses 2 additional counters:

• Counting from 3 to 0 in dl
• Counting from 5 to 0 in dh

When a counter reaches 0, it pushes the string Fizz or Buzz to the end of the output message. If this happens, bx will be decreased, and bh will be zero. This is used as a condition for outputting the number in a decimal form.

Note: I am using 32-bit data here. This won't work on a pre-386 computer.

• \$\begingroup\$ Does TASM really handle multi-byte characters constants in the opposite order from NASM? In NASM, you write mov [mem], 'Fizz' to store Fizz in that order in memory, matching db directives. See my overcomplicated "efficient" YASM FizzBuzz for example. \$\endgroup\$

  Peter Cordes

  – Peter Cordes

  2016年05月28日 00:36:34 +00:00

  Commented May 28, 2016 at 0:36
• 1
  \$\begingroup\$ Does it save any bytes to use std, then stosb / stosd? You'd have to replace test bh,bh with cmp di, 100h or something. Instead of saving/restoring the counter in AL, you could keep it in BL and just clobber eax whenever you want. E.g. sub bx, 4 / mov dword ptr [bx], 'zzuB' is 3+7 bytes, right? mov eax, 'zzuB' / stosd is 6+2 bytes (operand-size prefix on both). It would be nice if the answer included disassembly so instruction sizes were visible. \$\endgroup\$

  Peter Cordes

  – Peter Cordes

  2016年05月28日 00:46:30 +00:00

  Commented May 28, 2016 at 0:46
• 1
  \$\begingroup\$ This is a great answer - abusing benign instructions for data and using never-used PSP memory space. @PeterCordes I played with your suggestions using stosd but wasn't able to eek out any score reduction myself. Since stosd decrements DI afterwards you don't get to lose the sub di, 4 and then you have DI 4 bytes off at the end. I was able to -6 bytes using a few other minor tweaks which I ended up posting as a separate answer (only because I couldn't possibly fit in all a comment). Kudos! \$\endgroup\$

  640KB

  – 640KB

  2019年08月27日 17:19:33 +00:00

  Commented Aug 27, 2019 at 17:19

TrumpScript, 938 bytes

As always nothing is, 1000001 minus 1000000;
And Putin is, 1000003 minus 1000000; great
Just as Trump is, 1000005 minus 1000000; even better
Also as America is, Putin times Trump; the best
Most importantly Ivanka is, 1000101 minus 1000000;
And believe me that Hillary is nothing
As long as, Hillary thinks less of Ivanka;:
China is friends with Hillary
Democrats are idiots like Hillary
Obama is in line with Hillary
As long as, China thinks its more than America;:
Make China, China minus America;!
As long as, Democrats fear more Trump;:
Make Democrats, Democrats minus Trump;!
As long as, Obama gets more arsenal against Putin;:
Make Obama, Obama minus Putin;!
If everybody thinks, America is China?;:
Say "FizzBuzz"!
Otherwise: if we ask, Democrats are Trump?;:
Say "Buzz"!
Otherwise: what if, Obama is Putin?;:
Say "Fizz"!
Otherwise do this: tell Hillary all her lies!!!
Hillary is, as always Hillary plus nothing;!
America is great.

Try it online!

I was quite bored... Not too efficient, but fun!

Pseudocode:

var nothing = 1, Putin = 3, Trump = 5, America = Putin * Trump, Ivanka = 101, Hillary = nothing;
while Hillary < Ivanka
 var China = Democrats = Obama = Hillary;
 while China > America
 China = China - America;
 while Democrats > Trump
 Democrats = Democrats - Trump;
 while Obama > Putin
 Obama = Obama - Putin;
 if China == America
 print "FizzBuzz";
 else if Democrats == Trump
 print "Buzz";
 else if Obama == Putin
 print "Fizz";
 else
 print Hillary;
 Hillary = Hillary + nothing;
America is great.

Bash, 58 bytes

eval i={1..100}';a=([i%3]=Fizz [i%5]+=Buzz);echo ${a-$i};'

Try it online!

• 3
  \$\begingroup\$ 7 people have copied this solution verbatim, but only 3 upvotes? Have another. \$\endgroup\$

  primo

  – primo

  2021年03月13日 07:20:11 +00:00

  Commented Mar 13, 2021 at 7:20
• 2
  \$\begingroup\$ Not assigning i saves one: eval {0..99}';a=([++i%3]=Fizz [i%5]+=Buzz);echo ${a-$i};' \$\endgroup\$

  primo

  – primo

  2021年11月24日 09:34:15 +00:00

  Commented Nov 24, 2021 at 9:34

JavaScript, 65 bytes

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

The shortest approach I've found yet. Perhaps there's a better one; suggestions are welcome. This was originally flagged ES6, but this works in ES5, and to my knowledge there's not a shorter way with ES6 features.

Here's another attempt, using .slice and some complicated maths for a total of 66 bytes:

for(i=0;i++<100;console.log('FizzBuzz'.slice(i%3&&4,i%5?4:8)||i));

(Thanks to Ben Fortune for a couple of handy tricks!)

• 2
  \$\begingroup\$ You could shorten your second attempt to for(i=0;i++<100;console.log('FizzBuzz'.slice(i%3&&4,i%5?4:8)||i)); \$\endgroup\$

  Ben Fortune

  – Ben Fortune

  2015年09月25日 10:13:20 +00:00

  Commented Sep 25, 2015 at 10:13
• \$\begingroup\$ If you move console.log(...) outside for(...;...;...), you can drop the semicolon. \$\endgroup\$

  Dennis

  – Dennis

  2015年10月03日 15:54:44 +00:00

  Commented Oct 3, 2015 at 15:54
• \$\begingroup\$ This is old, but ES6 plus Dennis= 61 bytes: for(i=0;i++<100;)console.log(i%3?i:'fizz'+${i%5?'':'Buzz'}) I can't make it a code block because the template string won't show up correctly \$\endgroup\$

  Generic User

  – Generic User

  2015年11月15日 18:23:08 +00:00

  Commented Nov 15, 2015 at 18:23
• \$\begingroup\$ @GenericUser That doesn't quite work; it never prints Buzz by itself. To insert code with backticks in it, just use 2 or 3 backticks on each end. \$\endgroup\$

  ETHproductions

  – ETHproductions

  2015年11月15日 18:31:34 +00:00

  Commented Nov 15, 2015 at 18:31

dc, (削除) 64 (削除ここまで) 62 bytes

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

Lua, 72 bytes

for i=1,100 do print(({'FizzBuzz','Buzz','Fizz',i})[i^2%3+i^4%5*2+1])end

Tied the world record! (Please don't cheat the rankings there.)

• \$\begingroup\$ I stole this technique for my AppleScript answer. \$\endgroup\$

  kernigh

  – kernigh

  2017年10月25日 02:38:30 +00:00

  Commented Oct 25, 2017 at 2:38
• 3
  \$\begingroup\$ Cool answer. My 72 was for x=1,100 do print(({x,[0]="FizzBuzz",[6]="Fizz"})[x^4%15]or"Buzz")end, but looking at yours, I saw this 70: for x=1,100 do print(({"FizzBuzz",x,[7]="Fizz"})[1+x^4%15]or"Buzz")end \$\endgroup\$

  tehtmi

  – tehtmi

  2018年07月18日 23:34:06 +00:00

  Commented Jul 18, 2018 at 23:34
• \$\begingroup\$ @tehtmi Oh, that’s so nifty! \$\endgroup\$

  lynn

  – lynn

  2018年07月21日 15:34:13 +00:00

  Commented Jul 21, 2018 at 15:34
• \$\begingroup\$ 67 bytes... code.golf/rankings/holes/fizz-buzz/lua/bytes \$\endgroup\$

  DaCuteRaccoon

  – DaCuteRaccoon

  2022年05月03日 01:58:21 +00:00

  Commented May 3, 2022 at 1:58

80386 machine code + DOS, (削除) 75 (削除ここまで) 68 bytes

NOTE: This is a reply to @anatolyg's really clever 2015 answer, with a few tweaks to reduce the score by 7 bytes. I'm only submitting this as a separate answer because it wouldn't be possible to explain fully in a comment.

Changes:

• Use SI to reset BX since DOS sets SI initially to 100H (ref) instead of an imm. (-1 byte)
• Instead of using a 3/5 counter in DH/DL, use AAM for modulo operations on counter. AAM is a 2 byte instruction that's effectively a byte-length DIV that can accept an imm value as the divisor and also sets ZF if AL mod n = 0. @Peter Cordes touches on this in his very brilliant post about FizzBuzz in assembly. (-5 bytes)
• Instead of CR/LF, use LF/CR (the order doesn't matter to DOS). This translates to an instruction that does not modify the startup value of AX (in fact it zeroes out AL) so we can eliminate the xor ax,ax and save two bytes. It does come at a cost because 0A 0D is only a two-byte instruction so the rest of the 24xx instruction needs to be padded with one more byte. (-1 byte)

Unassembled:

0A 0D or cl, [di] ; LF and CR bytes (newline)
24 00 and al, 0 ; DOS string delim ('$') + pad byte
B1 64 mov cl, 100 ; set loop counter to 100 
 
 main_loop: 
8B DE mov bx, si ; init bx to 100h 
40 inc ax ; increment fizzbuzz counter 
50 push ax ; save fizzbuzz counter
 
50 push ax ; save ax from getting clobbered by AAM 
D4 05 aam 5 ; AL = AL mod 5, ZF if AL = 0
58 pop ax ; restore ax 
75 0A jnz short buzz_done ; jump if not a 'Fizz'
83 EB 04 sub bx, 4 ; offset for output string 
66C707 7A7A7542 mov dword ptr [bx], 'zzuB' 
 buzz_done: 
 
50 push ax 
D4 03 aam 3 ; AL = AL mod 3, ZF if AL = 0
58 pop ax 
75 0A jnz short fizz_done ; jump if not a 'Buzz'
83 EB 04 sub bx, 4 
66C707 7A7A6946 mov dword ptr [bx], 'zziF' 
 fizz_done: 
84 FF test bh, bh ; either a Fizz or a Buzz? (BX not changed)
74 0C jz short num_done ; if so, do not display a digit
 
 decimal_loop: 
D4 0A aam; ; AL = AL mod 10
04 30 add al, '0' ; convert to ASCII
4B dec bx 
88 07 mov [bx], al 
C1 E8 08 shr ax, 8 ; 'mov al, ah', ZF if AL = 0
75 F4 jnz decimal_loop 
 
 num_done: 
8B D3 mov dx, bx ; set dx to output string pointer
B4 09 mov ah, 9 
CD 21 int 21h 
58 pop ax ; restore fizzbuzz counter
 
E2 C3 loop main_loop 
C3 ret 

xxd binary:

00000000: 0a0d 2400 b164 8bde 4050 50d4 0558 750a [email protected].
00000010: 83eb 0466 c707 4275 7a7a 50d4 0358 750a ...f..BuzzP..Xu.
00000020: 83eb 0466 c707 4669 7a7a 84ff 740c d40a ...f..Fizz..t...
00000030: 0430 4b88 07c1 e808 75f4 8bd3 b409 cd21 .0K.....u......!
00000040: 58e2 c3c3 X...

• 6
  \$\begingroup\$ Of course it's a competing answer! It has nice ideas. Competition of this kind is exactly what this site needs! \$\endgroup\$

  anatolyg

  – anatolyg

  2019年08月27日 22:47:44 +00:00

  Commented Aug 27, 2019 at 22:47

Common Lisp, (削除) 123 (削除ここまで) 116

(dotimes(i 100)(loop for(m s)in'((3"Fizz")(5"Buzz"))if(=(mod(1+ i)m)0)do(princ s))(do()((fresh-line))(princ(1+ i))))

Pretty-printed

(dotimes (i 100)
 (loop for (m s) in '((3 "Fizz") (5 "Buzz"))
 if (= (mod (1+ i) m) 0)
 do (princ s))
 (do () ((fresh-line)) (princ (1+ i))))

The do/fresh-line trick

The inner loop iterates over ((3 "Fizz") (5 "Buzz")) for each i and, according to the result of the two consecutive mod operations, eventually prints:

• nothing
• or Fizz
• or Buzz
• or FizzBuzz

fresh-line is a nice little function that as far as I know is only found in Common Lisp. It adds a newline only if necessary, and returns T only when the newline was added. For the above situations, according to whether we printed something or not, the return values of (fresh-line) are thus respectively:

• NIL
• T
• T
• T

So I know that the integer must be printed only when we did not print a fresh-line. But if I print the integer, I must also print a newline after it. That's why there is a DO.

DO is a basic yet looping construct that iterates until a condition is met. Here, the condition is the return value of (fresh-line). It it tested before each iteration of the body of the loop, notably the first one. So if the test returns T, then we exit the DO. Otherwise, we execute the body, which prints the integer. Then, we execute the test once again and this time, it returns T because current line is "dirty" (there is an integer printed now).

• \$\begingroup\$ Clever! I don't think I can change my CL answer to beat it. \$\endgroup\$

  nanny

  – nanny

  2015年09月25日 16:42:00 +00:00

  Commented Sep 25, 2015 at 16:42
• \$\begingroup\$ @nanny If that can comfort you, I don't think I can either. I saw your answer, it was hard to beat. \$\endgroup\$

  coredump

  – coredump

  2015年09月25日 16:47:33 +00:00

  Commented Sep 25, 2015 at 16:47
• \$\begingroup\$ Great answer. I learnt some from it and don't understand it fully yet. However I think I've managed to beat you by 13 bytes using different method. \$\endgroup\$

  user65167

  – user65167

  2017年02月17日 22:45:18 +00:00

  Commented Feb 17, 2017 at 22:45

Julia, 64 bytes

for i=1:100 x="Fizz"^(i%3<1)*"Buzz"^(i%5<1);println(x>""?x:i)end

Bubblegum, (削除) 131 (削除ここまで) 129 bytes

0000000: 4d cd bb 0d c4 30 0c 03 d0 9e db e8 63 7d da 14 d9 e5 M....0......c}....
0000012: 06 b8 26 d3 e7 60 0b 38 56 a6 29 10 4f a0 b8 3f cf 03 ..&..`.8V.).O..?..
0000024: c7 f5 fd 3d 3b 27 ea 84 5d 89 9c 8f 18 c4 77 3c 75 40 ...=;'..].....w<u@
0000036: 72 2e 4d 63 55 a8 d1 5c 63 fa 82 f6 7f 6e 02 1b da d8 r.McU..\c....n....
0000048: b6 84 b1 ee a3 bb c1 49 f7 80 8f ee ac 2f c5 62 7d 8d .......I...../.b}.
000005a: be 0a 8b f4 10 c4 e8 c1 7a 24 82 f5 1c 3d 0d 49 7a 06 ........z$...=.Iz.
000006c: 72 f4 64 bd 14 c5 7a 8d 5e 85 22 bd 05 3d 7a b3 de 89 r.d...z.^."..=z...
000007e: 26 fd 05 &..

The above hexdump can be reversed with xxd -r -c 18 > fizzbuzz.bg.

Compression has been done with Python's zlib, which uses the DEFLATE format but obtains a better ratio than (g)zip.

Thanks to @Sp3000 for -2 bytes!

• 29
  \$\begingroup\$ You could golf off about 43 bytes by breaking SHA-256. \$\endgroup\$

  lirtosiast

  – lirtosiast

  2015年09月25日 00:07:00 +00:00

  Commented Sep 25, 2015 at 0:07
• 1
  \$\begingroup\$ @ThomasKwa: sounds easy. \$\endgroup\$

  ceased to turn counterclockwis

  – ceased to turn counterclockwis

  2015年09月25日 22:41:23 +00:00

  Commented Sep 25, 2015 at 22:41

Python 2, (削除) 61 (削除ここまで) 60 bytes

for i in range(1,101):print"Fizz"*(i%3<1)+"Buzz"*(i%5<1)or i

• \$\begingroup\$ This is invalid: it prints 0 at the start \$\endgroup\$

  Beta Decay

  – Beta Decay

  2015年09月24日 19:38:36 +00:00

  Commented Sep 24, 2015 at 19:38
• 1
  \$\begingroup\$ You could use either i+1 or range(1,101) to fix it. \$\endgroup\$

  ASCIIThenANSI

  – ASCIIThenANSI

  2015年09月24日 19:40:03 +00:00

  Commented Sep 24, 2015 at 19:40
• \$\begingroup\$ Now it only goes up to 99. \$\endgroup\$

  Zach Gates

  – Zach Gates

  2015年09月24日 19:48:07 +00:00

  Commented Sep 24, 2015 at 19:48
• 2
  \$\begingroup\$ the output is also straight up incorrect. 89 prints out a FizzBuzz whereas 90 is printed as 90 \$\endgroup\$

  Kevin W.

  – Kevin W.

  2015年09月24日 19:50:45 +00:00

  Commented Sep 24, 2015 at 19:50
• 3
  \$\begingroup\$ Have you actually tested this program? \$\endgroup\$

  Beta Decay

  – Beta Decay

  2015年09月24日 19:57:02 +00:00

  Commented Sep 24, 2015 at 19:57

R, (削除) 68 (削除ここまで) 66 bytes

for(i in 1:100)write(max(i,paste0("Fizz"[!i%%3],"Buzz"[!i%%5])),1)

I must be missing something here because this is way too simple. I know that you really shouldn't use loops in R but like this is a bit smaller than the first R one I saw so yeah.

Edited about a day after the original: you can get rid of the curly braces to save 2 characters.

• 4
  \$\begingroup\$ Welcome to Code Golf StackExchange, nice first answer. (It's also the winning R answer here!) \$\endgroup\$

  user92069

  – user92069

  2020年07月17日 10:34:29 +00:00

  Commented Jul 17, 2020 at 10:34
• \$\begingroup\$ @Third-party'Chef' Damn, it's incredible that it took five years for the shortest R solution to be found \$\endgroup\$

  Beta Decay

  – Beta Decay

  2020年07月24日 13:26:28 +00:00

  Commented Jul 24, 2020 at 13:26
• \$\begingroup\$ Eh, don't count it as the shortest ever. Some crazy guy will find some way to make something smaller haha \$\endgroup\$

  zydras

  – zydras

  2020年07月24日 18:11:08 +00:00

  Commented Jul 24, 2020 at 18:11

Japt, (削除) 45 (削除ここまで) (削除) 44 (削除ここまで) (削除) 43 (削除ここまで) (削除) 39 (削除ここまで) (削除) 36 (削除ここまで) (削除) 35 (削除ここまで) (削除) 33 (削除ここまで) (削除) 32 (削除ここまで) 31 bytes

Japt is a shortened version of JavaScript.

Lò1@"Fizz"pXv3)+"Buzz"pXv5)aX÷

Try it online!

How it works

Lò1@"Fizz"pXv3)+"Buzz"pXv5)a XÃ ·
Lò1@"Fizz"pXv3)+"Buzz"pXv5)||X} qR
Lò1 // Create the inclusive array [1...100].
@ // Map each item X in this range to:
 "Fizz"p // "Fizz" repeated:
 Xv3) // if X is divisible by 3, 1 time, otherwise, 0 times;
 + // concatenated with
 "Buzz"p // "Buzz" repeated:
 Xv5) // if X is divisible by 5, 1 time, otherwise, 0 times.
 ||X // If the result is an empty string, set it to X.
} qR // Join the range with newlines.
 // Implicit: output last expression

Old version, 32 bytes:

Lo@"FizzBuzz"s°X%3©4X%5?4:8 aX÷
Lo@"FizzBuzz"s++X%3&&4X%5?4:8 ||X} qR
Lo // Create the range [0..100).
@ // Map each item X in this array to:
 "FizzBuzz"s // "FizzBuzz".slice(
 ++X%3&&4 // if ++X is divisible by 3, 0; else, 4,
 X%5?4:8 // if X is divisible by 5, 8; else, 4).
 ||X // If the result is an empty string, set it to X.
} qR // Join the range with newlines.
 // Implicit: output last expression

Alternate version ((削除) 45 (削除ここまで) (削除) 44 (削除ここまで) (削除) 40 (削除ここまで) 38 bytes): (Note: this doesn't work in the current version of Japt)

1o#e £(X%3?":Fizz" +(X%5?":Buzz" aX} ·
1o#e m@(X%3?":Fizz" +(X%5?":Buzz" ||X} qR
1o#e // Create an array of 1 to 100.
m@ // Map each item X in this array to:
 (X%3?":Fizz" // If X is divisible by 3, "Fizz"; else, an empty string
 + // concatenated to:
 (X%5?":Buzz" // if X is divisible by 5, "Buzz"; else, an empty string.
 ||X // If the result is an empty string, set it to X.
} qR // Join the range with newlines.
 // Implicit: output last expression

Suggestions welcome!

HTML & CSS, (削除) 502 (削除ここまで) 485 bytes

body{counter-reset:n}
p::after{counter-increment:n;content:counter(n)}
p:nth-child(3n)::before{content:"Fizz"}
p:nth-child(3n)::after{content:""}
p:nth-child(5n)::after{content:"Buzz"}

<p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p>

• 1
  \$\begingroup\$ Nice answer! You don't need the <div> elements and you can skip the closing </p> tags as well, it should still render fine. \$\endgroup\$

  emanresu A

  – emanresu A

  2021年11月22日 02:53:38 +00:00

  Commented Nov 22, 2021 at 2:53
• \$\begingroup\$ Thanks @emanresuA. I still needed an element to apply the counter-reset to but it could just have been the body. Removing the closing </p> helped shave off a lots of bytes. \$\endgroup\$

  customcommander

  – customcommander

  2021年11月22日 09:02:34 +00:00

  Commented Nov 22, 2021 at 9:02

Bash + coreutils, 41 bytes

seq 100|sed 5~5cBuzz|sed 3~3s/[^B]*/Fizz/

You can't seem to do better without cheating: the 12-byte answers on that server simply invoke its gs2 interpreter with a 1-byte FizzBuzz program...

Brainfuck, 425 bytes

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

Try it online!

Explanation

Cell indexes in comments are in hexadecimal to match numbering in bfdev debug view.

# #####################
# ##### VARIABLES #####
# #####################
# C1 & C2: 48 (ascii 0)
-[>+>+<<-----]>--->-->
# C3: 10 (ascii LF)
++++++++++>
# C4: Singles counter
->
# C5: Tens counter
++++++++++>
# C6: is1to9 if countdown
+++++++++>
# C7: 0 to enter/exit is1to9, or 1 to enter is10to99
>
# C8: 0 to not enter is10to99
>
# C9: isMultiOf3 if countdown
+++>
# CA: 0 to exit isMultiOf3, or 1 to enter !isMultiOf3
>
# CB: 0 to not enter !isMultiOf3
>
# CC: isMultiOf5 if countdown
+++++>
# CD: 0 to exit isMultiOf5, or 1 to enter !isMultiOf5
>
# CE: 0 to not enter !isMultiOf5
>
# CF: 70 F, and put C13 to 70
>>-[<+<+>>-------]<---<--->
# C10: 66 - ascii B
---->
# C11: 105 - ascii i
>-[<++>-----]<+++>
# C12: 122 - ascii z, and put C16 to 122
>>----[<+++<+++>>--]<
# C13: 117 - ascii u
-----
# Goto C5
<<<<<<<<<<<<<<
# #################
# ##### LOGIC #####
# #################
# While C5 (tens counter): Print 1-99
[
# Restore C4: singles counter
 <++++++++++
# For 0 to 9, using singles counter
 [
# Goto C6
 >>
# If is1to9
 [
# Decrement is1to9 countdown
 -
# Prepare else condition at C8
 >>-<
 ]
# Goto C7 or C8
 >+
# Else If C7: is10to99
 [
# Decrement C7
 -
# Goto CC
 >>>>>-
# If is not multi of 5
 [
# Goto C9
 <<<-
# If is not multi of 3
 [
# Print C1: tens
 <<<<<<<<.
# Prepare else condition at CB
 >>>>>>>>>>-
# Goto CA
 <
 ]
# Goto CA or CB
 >+
# Else If is multi of 3
 [
# Goto CA, restore, goto CB
 ->
 ]
# Goto C9 and restore
 <<+
# Prepare else condition at C1E
 >>>>>-
# Goto C1D
 <
 ]
# Goto CD or CE
 >+
# Else If is multi of 5
 [
# Goto CD, restore, goto CE
 ->
 ]
# Goto CC and restore
 <<+
# Goto C8
 <<<<
 ]
# Goto C9
 >-
# If is not multi of 3
 [
# Goto CC
 >>>-
# If is not multi of 5
 [
# Print C2: singles
 <<<<<<<<<<.
# Prepare else condition at CE
 >>>>>>>>>>>>-
# Goto CD
 <
 ]
# Goto CD or CE
 >+
# Else If is multi of 5
 [ 
# Goto CD, restore, goto CE
 ->
 ]
# Goto CC and restore
 <<+
# Prepare else condition at CB
 <-
# Goto CA
 <
 ]
# Goto CA or CB
 >+
# Else If is multi of 3
 [
# Print Fizz
 >>>>>.>>.>..
# Goto C9 (If is not multi of 3)
 <<<<<<<<<
# Restore C9
 +++
# Goto CA, decrease, goto CB
 >->
 ]
# Goto CC
 >-
# If is not multi of 5
 [
# Prepare else condition at CE
 >>-
# Goto CD
 <
 ]
# Goto CD or CE
 >+
# Else If is multi of 5
 [ 
# Goto C10 and print Buzz
 >>>.>>>.<..
# Goto CC (If is not multi of 5) and restore
 <<<<<<+++++
# Goto CD, decrease, goto CE
 >->
 ]
# Goto C2: singles, and increment
 <<<<<<<<<<<<+
# Print C3: LF
 >.
# Decrement C4: singles counter
 >-
 ]
# Restore C2: singles ascii 
 <<----------
# Increment C1: tens ascii
 <+
# Goto C5 (tens counter) and decrement it 
 >>>>-
] 
# Goto C10 and print Buzz
>>>>>>>>>>>.>>>.<..

Bash, (削除) 85 (削除ここまで) (削除) 81 (削除ここまで) (削除) 78 (削除ここまで) (削除) 74 (削除ここまで) (削除) 72 (削除ここまで) 71 bytes

for((;i++<100;j=i%3&2|i%5/4)){
o=($i Buzz Fizz FizzBuzz)
echo ${o[j]}
}

Thanks to @Neil for saving 4 bytes!
Thanks to @manatwork for saving 3 bytes!
Thanks to @primo for saving 2 bytes!

Try it online!

• \$\begingroup\$ for i in {1..100}\n{ → for((;100>i++;)){ \$\endgroup\$

  primo

  – primo

  2018年11月21日 14:59:29 +00:00

  Commented Nov 21, 2018 at 14:59

aussie++, (削除) 223 (削除ここまで) (削除) 190 (削除ここまで) 187 bytes

G'DAY MATE!
I RECKON x IS A WALKABOUT FROM[1TO 100]<YA RECKON x %15<1?<GIMME "FizzBuzz";>WHATABOUT x %5<1?<GIMME "Buzz";>WHATABOUT x %3<1?<GIMME "Fizz";>WHATABOUT ?<GIMME x;>>CHEERS C***!

(削除) Fair dinkum, this was hard yakka cause there's no way to golf the whitespace because the parser seems to be strict. (削除ここまで) I coulda sworn it never worked when I tried to remove whitespace.

-33 thanks to @Bubbler

-3 thanks to @JoKing

Wanna hear what it actually sounds like? Wonder no more: https://youtu.be/ewu1CmjZcmQ

• 3
  \$\begingroup\$ Idea: Aussie++ on Code Review \$\endgroup\$

  emanresu A

  – emanresu A

  2021年11月05日 23:29:43 +00:00

  Commented Nov 5, 2021 at 23:29
• \$\begingroup\$ Just a note that Aussie++ has an online playground so everyone can try out the code easily. (No permalinks though) \$\endgroup\$

  Bubbler

  – Bubbler

  2021年11月11日 03:36:04 +00:00

  Commented Nov 11, 2021 at 3:36

Cubestack, (削除) 178 (削除ここまで) 162 bytes

M R2 f' M' S S' y S S' y2 M R' M' R E M r M' E2 M r2 M' E' U M R M' D E S R' b' R2 b r U2 r U2 S' E2 S R' B r l r U2 r U2 S' E' L S S' u S S' y2 M R' M' R F2 b y'

Try it Online!

Final cube state:

enter image description here

Another fine addition to the collection of FizzBuzz I've written.

Explained

M R2 f' M' S S' y # For each item in the range [0, 100)
S S' y2 M R' M' R # Push that item + 1 to the stack
E M r M' E2 M r2 M' E' # Push the list [3, 5] to the stack
U # Calculate [(item + 1) % 3, (item + 1) % 5]
M R M' D # and check if each of those results is equal to 0
E ... E2 # Push the list ["Fizz", "Buzz"] to the stack
L S S' u # and multiply the strings with the modulo equality list. 
 # This implements the ("Fizz" * (item % 3 == 0)) + ("Buzz" * (item % 5 == 0)) 
 # I use in my other fizzbuzzes to concisely do the multiplicity check
S S' y2 M R' M' R # Push the item + 1 to the stack again. Needed because there's no DUP yet
F2 b # Logically or that with the FizzBuzz string and print with a newline. 
 # If the item isn't divisible by 3 or 5, then the fizzbuzz string will be empty
 # meaning the logical or here will return the number. Otherwise it'll return whatever word is needed.
y' # End the loop

GolfScript, 37 bytes

100,{)..3%!'Fizz'*5円%!'Buzz'*+\or n}/

Snowman 1.0.2, 97 chars

)1vn101nR:du*_/3NmO0eQ)(#5NmO0eQ}~(~%@or(%nO?_/)#%@{%@tS?)aRsP@@"Fizz"_aRsP\"Buzz"aRsP?)10wRsP;aE

How does it work, you ask? ... I have no idea. I might edit in a full explanation at some point if I ever decide to try to understand this again.

(Pulled directly from Snowman's examples directory.)

MoonScript, (削除) 83 (削除ここまで) 82 bytes

[print(i%15==0and"FizzBuzz"or(i%3==0and"Fizz")or(i%5==0and"Buzz")or i) for i=1,100]

• 6
  \$\begingroup\$ Welcome to Programming Puzzles & Code Golf! \$\endgroup\$

  Dennis

  – Dennis

  2015年09月26日 05:27:54 +00:00

  Commented Sep 26, 2015 at 5:27

C++, (削除) 130 (削除ここまで) (削除) 126 (削除ここまで) (削除) 119 (削除ここまで) 115

#include<iostream>
int i;int main(){for(auto&o=std::cout;++i<101;o<<'\n')i%3?o:o<<"Fizz",i%5?i%3?o<<i:o:o<<"Buzz";}

Live version.

• 1
  \$\begingroup\$ Suggest i%3||o<<"Fizz" \$\endgroup\$

  c--

  – c--

  2022年06月06日 22:48:15 +00:00

  Commented Jun 6, 2022 at 22:48

Brainfuck, (削除) 16321 3602 (削除ここまで) 1597

Almost as short as Java. (削除) This is just the trivial answer generated by another program, (削除ここまで) This is still a computer generated answer, but I am sure there are way shorter solutions! The general idea is initializing the cells to 4 B F i u z. If the program has to output a number, it just goes to the first cell and manipualtes it, if it is one of the letters, it will just jump to the corresponding cell and output it.

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

• 2
  \$\begingroup\$ Nice solution! I could get to 425 bytes by manually writing the brainfuck code. \$\endgroup\$

  Forcent Vintier

  – Forcent Vintier

  2016年12月27日 13:04:49 +00:00

  Commented Dec 27, 2016 at 13:04

Mathematica, (削除) 83 (削除ここまで) (削除) 75 (削除ここまで) (削除) 73 (削除ここまで) (削除) 67 (削除ここまで) 62 bytes

Print/@(#/.(##&[15#->FizzBuzz,3#->Fizz,5#->Buzz]&)/@#&@Range@100)

I do not think that this could be golfed any further. Thanks to branislav for helping me golf this.

• \$\begingroup\$ golf it down to 66 bytes by first removing all quotation marks, second using ...\\Column instead of Print/@(...) \$\endgroup\$

  sanchez

  – sanchez

  2015年10月30日 16:39:22 +00:00

  Commented Oct 30, 2015 at 16:39
• \$\begingroup\$ then how about Print/@% \$\endgroup\$

  sanchez

  – sanchez

  2015年11月02日 05:30:50 +00:00

  Commented Nov 2, 2015 at 5:30
• \$\begingroup\$ @branislav It doesn't end up saving any bytes. \$\endgroup\$

  LegionMammal978

  – LegionMammal978

  2015年11月02日 11:24:13 +00:00

  Commented Nov 2, 2015 at 11:24
• 6
  \$\begingroup\$ You mean Mathematica doesn't have a FizzBuzz builtin? \$\endgroup\$

  user45941

  – user45941

  2015年11月15日 05:02:04 +00:00

  Commented Nov 15, 2015 at 5:02
• 1
  \$\begingroup\$ I should make it clear that I don't think that not working in the up-to-date version in any way invalidates this answer! But I'm interested to know what the best solution is in 11. \$\endgroup\$

  A Simmons

  – A Simmons

  2017年01月20日 17:10:13 +00:00

  Commented Jan 20, 2017 at 17:10

Rotor, (削除) 32 (削除ここまで) 31 bytes

1N2{3%!"Fizz"~5%!"Buzz"N$?~N}\

This has one unprintable, so here's a hexdump:

0000000: 314e 7f32 7b33 2521 2246 697a 7a22 7e35 1N.2{3%!"Fizz"~5
0000010: 2521 2242 757a 7a22 4e24 3f7e 4e7d 5c %!"Buzz"N$?~N}\

Explanation:

1 Push a one to the stack.
N Push a newline.
^? Spooky invisible unprintable that pushes 100 to the stack.
2 Pushes a two to the stack. 
{ Starts block.
 3% Takes mod 3 of the top number on the stack.
 !"Fizz" If falsy, push "Fizz".
 ~ Push the contents of the register.
 5% Takes mod 5.
 !"Buzz" If falsy, push "Buzz".
 N$ Compares the top value of the stack to a newline. (this doesn't pop the values off the stack)
 ?~ If truthy, push the contents of the register.
 N Push a newline.
}\ For loop between 2 and 100, pushing the counter to the register and stack each time.

Try it online. (note that it is very slow)

Check out Rotor.

05AB1E, 29 bytes

тLʒ"Fizz"D'ÒÖTMDŠ«)¬ÑD5ås3å«è,

Try it online!

To my surprise (or my incapability to use the search function) there was no 05AB1E answer to this question.

Explanation

тLʒ"Fizz"D'ÒÖTMDŠ«)¬ÑD5ås3å«è,
тL # push [1,...,100]
 ʒ # for each...
 "Fizz" # Push Fizz (didn't find a way to shorten this one sadly)
 D # Duplicate
 'ÒÖTM # Push Buzz
 D # Duplicate
 Š # Move top item on the stack two slots down
 « # Concatenate the top items (Results in FizzBuzz)
 ) # Wrap stack to array
 „ # Get Divisors of N
 D5å # Does 5 divide it?
 s3å # Does 3 divide it?
 « # Concatenate top two items
 è, # Gets item in the array at the index of the concatenated divisors (indexing wraps around) and prints 
 

• code-golf
• string
• kolmogorov-complexity
• arithmetic
• fizzbuzz