Is it shuffled FizzBuzz?

Question

A twin of this.

FizzBuzz is where a range of positive integers is taken, and numbers divisible by 3 are replaced with "Fizz", divisible by 5 with "Buzz" and divisible by 15 with "FizzBuzz". For example, FizzBuzz from 1 to 10 is 1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz.

Your challenge is to, given a list of Fizzes, Buzzes, FizzBuzzes and a value representing an integer (I'm going to use Int), determine if it can be arranged into valid FizzBuzz.

For example, Int, Fizz, Fizz, Buzz can be arranged into Fizz, Buzz, Int, Fizz (for example 9,10,11,12) which is valid. But Buzz, Fizz, Buzz cannot, as the two Buzz need to be five values apart.

You may choose any four values to represent Fizz, Buzz, FizzBuzz and Int.

This is code-golf, shortest wins!

Truthy

Int, Int, Fizz
Fizz, Int, Fizz, Buzz
Fizz, Fizz, Fizz, Int, Int, Int, Buzz
Buzz, Int, Int, Int, Fizz, FizzBuzz
FizzBuzz, Int, Int, Int, Int

Falsy

Buzz, FizzBuzz, Fizz
Buzz, Fizz, Buzz
Int, Int, Int
Fizz, Int, Fizz
FizzBuzz, Int, Int, Buzz, Fizz
Int, Int, Fizz, Fizz, Fizz, Buzz, Buzz

Answer 1

Vyxal, 13 bytes

L₄+v₍₃₅ÞS?Ṗ↔ḃ

Try it Online! Super slow. Uses [0,0] for Int, [1,0] for Fizz, [0,1] for Buzz, and [1,1] for FizzBuzz.

Test cases, using 14 instead of 26 to make it faster.

L₄*v₍₃₅ÞS?Ṗ↔ḃ
L₄+           # Length of input + 26 (14 would be enough, but 26 is one byte)
   v₍₃₅       # For each in range [1, that], calculate [n % 3 == 0, n % 5 == 0]
       ÞS     # All sublists
           ↔  # Keep only lists that are in...
         ?Ṗ   # The permutations of the input
            ḃ # Is this truthy? (does it have at least one element?)

Answer 2

JavaScript (ES6), 72 bytes

Expects 0 for Int, 1 for Fizz, 2 for Buzz, 3 for FizzBuzz. Returns 0 or 1.

This is the same algorithm as in my answer to the other challenge.

f=(a,i=k=15)=>k--&&a.sort().map(_=>++i%3<1|2*!(i%5)).sort()+''==a|f(a,k)

Try it online!

Commented

f = (             // f is a recursive function taking:
  a,              //   a[] = input array
  i =             //   i = index in the FizzBuzz sequence
  k = 15          //   k = counter
) =>              //
  k-- &&          // decrement k; abort if it was 0
  a.sort()        // normalize a[] by sorting it in lexicographical order
  .map(_ =>       // for each value in a[]:
    ++i % 3 < 1 | //   generate the FizzBuzz sequence,
    2 * !(i % 5)  //   starting at i + 1
  )               // end of map()
  .sort()         // normalize this new array
  + '' == a |     // coerce it to a string and compare it with a[]
  f(a, k)         // recursive call with i set to the new value of k

Answer 3

05AB1E, 15 bytes

g°L35SδÖŒεœ€Q}à

Inputs as Int=[0,0]; Fizz=[1,0]; Buzz=[0,1]; FizzBuzz=[1,1].
Too slow to output anything on TIO..

(Don't) try it online.
Try a modified version online, with: hard-coded 26 ₂ instead of g°; find_first .Δ instead of ε...}; outputs the first found list, or -1 if falsey (which still times out for falsey or too long test cases.. -_-).

Explanation:

g             # Push the input-length
 °            # 10 to the power this length
  L           # Pop and push a list in the range [1,10**length]
   35S        # Push pair [3,5]
      δ       # Map over the [1,10**length]-list, with [3,5] as argument for each:
       Ö      #  Check if the current integer is divible by [3,5]
        Π    # Get all sublists of this
         ε    # Map over each sublist:
          œ   #  Get all permutations of it
           €  #  Map over each permutation:
            Q #   Check if it's equal to the (implicit) input-list
         }    # Close the sublists-map
          à   # Flattened maximum to check if any inner permutation was truthy
              # (which is output implicitly as result)

Answer 4

Python3, 213 bytes:

def v(r,l,k=[]):
 if not r:yield k
 for i,a in enumerate(l):
  if r[0]%(a|1)<1:yield from v(r[1:],l[:i]+l[i+1:],k+[a])
def f(l,c=0):
 while(c:=c+1)<sum(i**2for i in l):
  if next(v(range(c,c+len(l)),l),0):return 1

Try it online!

Answer 5

Python 3.8 (pre-release), 109 bytes

lambda n:sorted(n)in[sorted([max(a for a in[1,3,5,15]if j%a<1)for j in range(i,i+len(n))])for i in range(15)]

Try it online!

Takes Int as 1, Fizz as 3, Buzz as 5, FizzBuzz as 15.

Explanation

One key observation is that, if we replace all the integers with a single value Int, then the FizzBuzz sequence has a period of 15:

Int
Int
Fizz
Int
Buzz
Fizz
Int
Int
Fizz
Buzz
Int
Fizz
Int
Int
FizzBuzz

It is rather easy to prove that this is in fact the case. Hint: start by placing the multiples of 3 and 5.

What we can therefore do is focus on the first 15 numbers. From each of these numbers, we can make a little subsequence of numbers whose length is the same as the length of the input, and determine whether the sorted values (where the integers become Int) are the same as the input.

How do we do this? We use a cool trick whereby we get the maximum number out of [1, 3, 5, 15] such that the current number is divisible by that number. Since Int is 1, all numbers that are not multiples of 3 or 5 correspond to Int. Multiples of 3 but not of 5 correspond to Fizz, etc. We can eventually generate this sequence of 1s, 3s, 5s and 15s.

Sorting the input and comparing it against the sorted values of the subsequence will reveal whether the input is shuffled FizzBuzz or not.

Yay! First answer in... what, two months?