29
\$\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.
\$\endgroup\$
5
  • 2
    \$\begingroup\$ May we choose to take different 4 distinct consistent inputs to represent Fizz, Buzz, FizzBuzz and Number? \$\endgroup\$
    – pajonk
    Dec 17, 2021 at 19:02
  • 1
    \$\begingroup\$ @pajonk Yes, you may. \$\endgroup\$
    – Bgil Midol
    Dec 17, 2021 at 19:03
  • 3
    \$\begingroup\$ I think Number 312 might be 584. \$\endgroup\$
    – Arnauld
    Dec 17, 2021 at 19:19
  • \$\begingroup\$ Why space separated input? I'd suggest just going by our default I/O rules \$\endgroup\$ Dec 17, 2021 at 19:32
  • \$\begingroup\$ @cairdcoinheringaahing That was an example. You can do list, newline sep, etc. \$\endgroup\$
    – Bgil Midol
    Dec 17, 2021 at 19:35

12 Answers 12

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
\$\endgroup\$
3
  • 4
    \$\begingroup\$ 1g15=ɗ#Ṫ works for 8, with Number = 1, Fizz = 3, Buzz = 5, FizzBuzz = 15. \$\endgroup\$
    – Lynn
    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\$ Dec 17, 2021 at 20:10
  • \$\begingroup\$ I was going to upvote, but I accidentally downvoted. Now fixed. \$\endgroup\$
    – Bgil Midol
    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!

\$\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.

\$\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\$
    – ovs
    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.

\$\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\$ Dec 18, 2021 at 8:31
  • 1
    \$\begingroup\$ Actually, using / / and $' / `` $` `` works out a bit better: Try it online! \$\endgroup\$ Dec 18, 2021 at 23:03
  • 1
    \$\begingroup\$ Thx @DomHastings – I need to remember those special vars. \$\endgroup\$
    – Kjetil S
    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.

\$\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\$
    – AnttiP
    Dec 17, 2021 at 20:44
  • \$\begingroup\$ @AnttiP Thanks! Using python 2 gets another 2 bytes as well \$\endgroup\$
    – hyper-neutrino
    Dec 17, 2021 at 21:41
  • \$\begingroup\$ Using Python 2 is cheating, it doesn't officially exist anymore. \$\endgroup\$ 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\$
    – hyper-neutrino
    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...

\$\endgroup\$
5
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!

\$\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)
\$\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 (%).

\$\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.

\$\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 ().

\$\endgroup\$
0
\$\begingroup\$

Charcoal, 22 bytes

I⊕§⌕A×”{⊞‴¡*RX⭆eR”NS⊖θ

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
         N      First input as a number
   ⌕A           Find all indices of
          S     Second input
  §             Indexed by
            θ   First input
           ⊖    Decremented
 ⊕              Incremented
I               Cast to string
                Implicitly print
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.