30
\$\begingroup\$

Introduction

Everyone knows the FizzBuzz sequence. It goes something like this:

1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz . . .

In case you don't know, if the number is divisible by 3, it's Fizz. If it is divisible by 5, it's Buzz. If it is divisible by both, it's FizzBuzz. If it is not divisible by both, it's just the original number.

Task

Take two inputs, for example (space separated here)

Fizz 3

For this specific example input, you should output 9, the third Fizz. To be more general, take a word and a number, output the numberth word.

The word input may be Number, and in this case, you should output the numberth number in the FizzBuzz sequence that is not Fizz, Buzz, or FizzBuzz.

You may choose any 4 distinct, consistent inputs representing Fizz, Buzz, FizzBuzz and Number.

Test Cases

Fizz 3 => 9 Buzz 4 => 25 FizzBuzz 2 => 30 Number 312 => 584

Scoring

Shortest code wins!

Rules

  • No standard loopholes.
Improve this question
\$\endgroup\$
5
  • 2
    \$\begingroup\$ May we choose to take different 4 distinct consistent inputs to represent Fizz, Buzz, FizzBuzz and Number? \$\endgroup\$ Commented Dec 17, 2021 at 19:02
  • 1
    \$\begingroup\$ @pajonk Yes, you may. \$\endgroup\$ Commented Dec 17, 2021 at 19:03
  • 3
    \$\begingroup\$ I think Number 312 might be 584. \$\endgroup\$ Commented Dec 17, 2021 at 19:19
  • \$\begingroup\$ Why space separated input? I'd suggest just going by our default I/O rules \$\endgroup\$ Commented Dec 17, 2021 at 19:32
  • \$\begingroup\$ @cairdcoinheringaahing That was an example. You can do list, newline sep, etc. \$\endgroup\$ Commented Dec 17, 2021 at 19:35

14 Answers 14

Reset to default
6
\$\begingroup\$

Jelly, 10 bytes

³3,5ḍḄ⁼ʋ#Ṫ

Try it online!

This uses 0 = Number, 1 = Buzz, 2 = Fizz and 3 = FizzBuzz

Jelly, 8 bytes

1g15=ɗ#Ṫ

Try it online!

Thanks to Lynn. This uses 1 = Number, 3 = Fizz, 5 = Buzz, 15 = FizzBuzz. Included separately as the numbers could encode extra data

How they work

³3,5ḍḄ⁼ʋ#Ṫ - Main link. Takes W=0,1,2,3 on the left, n on the right ʋ - Last 4 links as a dyad f(k, W): 3,5ḍ - Divisible by 3 or 5? Yields [0,0], [0,1], [1,0], [1,1] Ḅ - From binary; Yields 0, 1, 2, 3 ⁼ - Equals W? ³ #Ṫ - Starting from W, count up k = W, W+1, ..., returning the nth integer such that f(k, W) is true 

1g15=ɗ#Ṫ - Main link. Takes W=1,3,5,15 on the left, n on the right ɗ - Last 3 links as a dyad f(k, W): g15 - GCD(k, 15) = - Does that equal W? 1 #Ṫ - Count up k = 1, 2, ..., returning the nth integer such that f(k, W) is true
Improve this answer
\$\endgroup\$
3
  • 5
    \$\begingroup\$ 1g15=ɗ#Ṫ works for 8, with Number = 1, Fizz = 3, Buzz = 5, FizzBuzz = 15. \$\endgroup\$ Commented Dec 17, 2021 at 20:06
  • \$\begingroup\$ @Lynn I've added that as an alternative, as using the specific values might be taken to encode extra data \$\endgroup\$ Commented Dec 17, 2021 at 20:10
  • \$\begingroup\$ I was going to upvote, but I accidentally downvoted. Now fixed. \$\endgroup\$ Commented Dec 18, 2021 at 11:53
5
\$\begingroup\$

JavaScript (ES6), 44 bytes

Expects (s)(n) with s=0 for Number, s=1 for Fizz, s=2 for Buzz and s=3 for FizzBuzz.

(s,k=0)=>g=n=>n?g(n-=s==!(++k%3)+2*!(k%5)):k

Try it online!

Cheaty version, 35 bytes

Expects 4680 for Fizz, 1056 for Buzz, 1 for FizzBuzz and 27030 for Number.

(s,k=0)=>g=n=>n?g(n-=s>>++k%15&1):k

Try it online!

Improve this answer
\$\endgroup\$
4
\$\begingroup\$

Python 2, 47 bytes

f=lambda n,c,k=1:n and-~f(n-(k**4%15==c),c,k+1)

Try it online!

Take in the category label c as:

Number -> 1 Fizz -> 6 Buzz -> 10 FizzBuzz -> 0

We fingerprint the category for k using k**4%15, which produces the corresponding value as listed above. This is wrapped in a recursive function for the n'th number meeting a condition.

Python 2, 54 bytes

lambda n,c:([n*7/8-3*~n/4%2,~-n/4,~-n/2,0][c/2%4]+n)*c

Try it online!

A short at writing direct formulas for each case, with input c as one of 1,3,5,15.

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ For the direct formulas you can combine the Fizz and Buzz cases into one: [n*7/8-3*~n/4%2,0,~-n>>6/c][c/3/-3] \$\endgroup\$ Commented Dec 18, 2021 at 0:05
4
\$\begingroup\$

Perl 5 -p, 52 47 bytes

Saved 5 bytes thanks to @Dom Hastings.

/ /;$_=332312332132330x$';/(.*?$`){$'}/g;$_=pos

Try it online!

Where 0=FizzBuzz, 1=Buzz, 2=Fizz, 3=Number in the first of the two inputs. Finds the position of the n'th occurrence of what's wanted with a regexp search in a repeated 15 char string encoding number, fizz, buzz and fizzbuzz in their right places.

Improve this answer
\$\endgroup\$
3
  • \$\begingroup\$ Nice approach. I ended up with a much longer version... You can save a few bytes swapping the order of input too!: Try it online! \$\endgroup\$ Commented Dec 18, 2021 at 8:31
  • 1
    \$\begingroup\$ Actually, using / / and $' / `` $` `` works out a bit better: Try it online! \$\endgroup\$ Commented Dec 18, 2021 at 23:03
  • 1
    \$\begingroup\$ Thx @DomHastings – I need to remember those special vars. \$\endgroup\$ Commented Dec 19, 2021 at 16:20
3
\$\begingroup\$

Python 2, 51 bytes

lambda d,n,k=0:n and-~f(d,n-(k%3/2*2+k%5/4==d),k+1)

Try it online!

-2 bytes thanks to AnttiP; becomes -4 using Python 2
-3 bytes thanks to ovs

0 for Number, 1 for Buzz, 2 for Fizz, 3 for FizzBuzz.

Improve this answer
\$\endgroup\$
4
  • \$\begingroup\$ -2 bytes with lambda d,n,k=0:n and f(d,n-(k%3//2*2+k%5//4==d),k+1)or k \$\endgroup\$ Commented Dec 17, 2021 at 20:44
  • \$\begingroup\$ @AnttiP Thanks! Using python 2 gets another 2 bytes as well \$\endgroup\$ Commented Dec 17, 2021 at 21:41
  • \$\begingroup\$ Using Python 2 is cheating, it doesn't officially exist anymore. \$\endgroup\$ Commented Dec 18, 2021 at 3:42
  • 3
    \$\begingroup\$ @MarkRansom It's not officially supported by Python anymore but as long as a language has an implementation available it's valid. \$\endgroup\$ Commented Dec 18, 2021 at 7:04
3
\$\begingroup\$

R, 56 54 52 bytes

Edit: -4 bytes thanks to pajonk

function(n,i){while(n<-n-!(!T%%3)-i+2*!T%%5)T=T+1;T}

Try it online!

This really seems to have too many parentheses...
Edit: This is really pajonk's answer, now, after removing all the useless parentheses that I left in the original...

Improve this answer
\$\endgroup\$
5
  • \$\begingroup\$ Here's one pair of parens less. \$\endgroup\$ Commented Dec 18, 2021 at 6:36
  • \$\begingroup\$ @pajonk - Thanks! I really should try to understand the precedence rules... \$\endgroup\$ Commented Dec 18, 2021 at 8:07
  • \$\begingroup\$ stat.ethz.ch/R-manual/R-devel/library/base/html/Syntax.html is my favourite site when golfing in R ;) \$\endgroup\$ Commented Dec 18, 2021 at 10:04
  • \$\begingroup\$ And one pair less again. \$\endgroup\$ Commented Dec 18, 2021 at 10:11
  • \$\begingroup\$ @pajonk - Thanks. I think I ought to transfer this answer to you, after you've fixed all my parentheses... \$\endgroup\$ Commented Dec 18, 2021 at 12:42
1
\$\begingroup\$

Python 2, 77 bytes

0 for Number, 1 for Buzz, 2 for Fizz, 3 for FizzBuzz. The formula for Number is taken from A229829.

t,n=input() g=n-1 print[g/8*15+g%8*12/5+1+g%8/-3,(n+g/4)*3,(n+g/2)*5,n*15][t]

Try it online!

Improve this answer
\$\endgroup\$
1
\$\begingroup\$

05AB1E (legacy), 9 bytes

µN53SÖ2βQ

First input is the \$number\$; second is a digit \$0\$ for Number, \$1\$ for Fizz, \$2\$ for Buzz, and \$3\$ for FizzBuzz.

Uses the legacy version of 05AB1E, because it'll implicitly output the index N after a while-loop µ. In the new 05AB1E version, an explicit trailing }N should be added to accomplish that.

Try it online or verify all test cases.

Explanation:

µ # Loop until the counter_variable is equal to the first (implicit) input N # Push the loop-index 53S # Push [5,3] Ö # Check if the loop-index is divisible by either 5 or 3 # (resulting in [0,0], [1,0], [0,1], or [1,1]) 2β # Convert it from a base-2 list to an integer # ([0,0],[1,0],[0,1],[1,1] will become 0,1,2,3 respectively) Q # And check if it's equal to the second (implicit) input # (if this is truthy: implicitly increase the counter_variable by 1) # (after the loop, the loop-index `N` is output implicitly)

05AB1E (legacy), 6 bytes

µN15¿Q

First input is the \$number\$; second is an integer \$1\$ for Number, \$3\$ for Fizz, \$5\$ for Buzz, and \$15\$ for FizzBuzz.

Port of @Lynn's Jelly comment (I now also notice my original program above uses a similar approach as @cairdCoinheringaahing's 10-bytes Jelly program, even though we came up with it independently. Not too surprising, since it's a pretty straight-forward approach.)

Try it online or verify all test cases.

Explanation:

µ # Loop until the counter_variable is equal to the first (implicit) input N # Push the loop-index 15¿ # Get the GCD (Greatest Common Divisor) of this index and 15 Q # And check if it's equal to the second (implicit) input # (if this is truthy: implicitly increase the counter_variable by 1) # (after the loop, the loop-index `N` is output implicitly)
Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Retina, 60 bytes

L$`^. $'*$&¶$'*$(NNFNBFNNFBNFNNZ L$`(.)+¶(?<-1>.*?\1)+ $.>%`

Try it online! Link includes test cases. Takes input as the letter F, B, Z or N followed by the number n. Explanation:

L$`^.

Match the letter. At this point, $' refers to the number n following it.

$'*$&¶$'*$(NNFNBFNNFBNFNNZ

Repeat the letter n times, then on the next line repeat the Fizz Buzz sequence 15n times.

L$`(.)+¶(?<-1>.*?\1)+

Match n copies of the letter on the first line, and use those to find the nth match of the letter on the second line.

$.>%`

Output the offset (.`) of the end (>) of the match relative to the start of the second line (%).

Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Desmos, 112 99 bytes

Input into the function \$f(n,k)\$, where \$n\$ is the number, and \$k\$ is the word.

Number = 0, Fizz = 3, Buzz = 5, FizzBuzz = 15

h(n)=floor(n) a=mod(n-1,8) f(n,k)=\{k=0:15h(n/8-1/8)+2a+h(2a/5+1)-h(a/3+2/3),k=15:kn,kn+kh(kn/15)\}

Try It On Desmos!

Try It On Desmos! - Prettified

Uses formula in OEIS A229829:

a(n) = 15*floor((n-1)/8) +2*f(n) +floor((2*f(n)+5)/5) -floor((f(n)+2)/3), where f(n) = (n-1) mod 8.

99.99% sure this could be golfed. Maybe I could shorten the OEIS formula somehow.

Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Husk, 8 bytes

!¥⁰m⌋15N

Try it online!

Input as 1=number, 3=Fizz, 5=Buzz, 15=FizzBuzz. Same approach as Lynn's comment to caird coinheringaahing's answer.

Alternative versions with successively less pre-processing squeezed into the values chosen as input:

12 bytes, with input as [0,0]=number, [1,0]=Fizz, [0,1]=Buzz & [1,1]=FizzBuzz.

!fo≡⁰§e¦3¦5N

Try it online!

The Husk congr command - ≡ - checks whether two lists have the same distribution of truthy/falsy elements: in this case, divisibility (¦) by 3 and 5.

or 14 bytes, finally with input just as 0=number, 1=Fizz, 2=Buzz & 3=FizzBuzz.

!¥mȯḋm¬§e%5%3N

Try it online!

Treats list of not-modulo (¬ & %) 3 or 5 as binary digits (ḋ).

Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Vyxal, 8 bytes

15ġ⁰=)ȯt

Try it Online!

Port of the other answers.

Improve this answer
\$\endgroup\$
0
\$\begingroup\$

Charcoal, 22 bytes

Ｉ⊕§⌕Ａ×”{⊞‴¡*ＲX⭆eＲ”ＮＳ⊖θ

Try it online! Link is to verbose version of code. Takes the number as the first input and one of the letters F, B, Z or N as the second input. Explanation:

 ... Compressed string `NNFNBFNNFBNFNNZ` × Repeated by Ｎ First input as a number ⌕Ａ Find all indices of Ｓ Second input § Indexed by θ First input ⊖ Decremented ⊕ Incremented Ｉ Cast to string Implicitly print
Improve this answer
\$\endgroup\$
0
\$\begingroup\$

Python 2, 26 bytes

lambda(a,b),c:c/8*b+a[c%8]

Try it online!

The value (a,b) should be a list/tuple of 2:

[[-1,1,2,4,7,8,11,13],15] for Number [[-3,3,6,9,12,18,21,24],30] for Fizz [[-5,5,10,20,25,35,40,50],60] for Buzz [[0,15,30,45,60,75,90,105],120] for FizzBuzz

Wonder if this violates this loophole as it's just a list. If it does, I will delete this answer.

Improve this answer
\$\endgroup\$

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.