FizzBuzz is often one of the first programming puzzles people learn. Now undo it with reverse FizzBuzz!

Write a function that accepts a string, which will always be a valid section of FizzBuzz. Your function must return an array that contains the numbers in order to generate the given section of FizzBuzz.

Notes:
- If the sequence can appear multiple times within FizzBuzz, return the numbers that generate the first instance of that sequence.
- All numbers in the sequence will be greater than zero.
- You will never receive an empty sequence.


## Examples
```
reverse_fizzbuzz("1 2 Fizz 4 Buzz")        -->  [1, 2, 3, 4, 5]
reverse_fizzbuzz("Fizz 688 689 FizzBuzz")  -->  [687, 688, 689, 690]
reverse_fizzbuzz("Fizz Buzz")              -->  [9, 10]
```

Difficulty: introductory

Starter code:

def reverse_fizzbuzz(s):
	

Solutions:
def reverse_fizzbuzz(s):
    if s == 'Fizz': return [3]
    if s == 'Buzz': return [5]
    if s == 'Fizz Buzz': return [9, 10]
    if s == 'Buzz Fizz': return [5, 6]
    if s == 'FizzBuzz': return [15]
    s = s.split()
    for i in range(len(s)):
        if s[i].isdigit():
            start = int(s[i]) - i
            return list(range(start, start + len(s)))

def reverse_fizzbuzz(string):
    s = string.split()
    lst = [0] * len(s)
    for indx, i in enumerate(s):
        if i.isdigit():
            lst[indx] = int(i)
            return list(range(lst[indx] - indx, lst[indx] + len(s) - indx))
    return {'Fizz': [3], 'Buzz': [5], 'FizzBuzz': [15], 'Buzz Fizz': [5, 6], 'Fizz Buzz': [9, 10]}[string]

def reverse_fizzbuzz(s):
    arr = s.split(' ')
    if len(arr) == 1 and not arr[0].isdigit():
        return [3] if arr[0] == 'Fizz' else [5] if arr[0] =='Buzz' else [15] 
    def find_first_num(arr):
        for i in range(len(arr)):
            if arr[i].isdigit():
                return [int(i)*(-1), int(arr[i])]
        if arr[0] == 'Buzz':
            return [0,5]
        return [0, 9]
    nu = find_first_num(arr)
    return [nu[0] + nu[1] + x for x in range(len(arr))]

def reverse_fizzbuzz(s):
    s = s.split()
    d =  next((i for i,j in enumerate(s) if j.isdigit()),-1)
    if d!=-1:return list(range(int(s[d])-len(s[:d]),int(s[d])+len(s[d:])))
    else:
        if s in [['Fizz'],['Buzz']]:return [[3],[5]][s==['Buzz']]
        if s==['FizzBuzz']:return [15]
        if s==['Fizz','Buzz']:return [9,10]
        return [5,6]

def reverse_fizzbuzz(fizzbuzz_section):
    fizzbuzz_section_elements = fizzbuzz_section.split()
    n = len(fizzbuzz_section_elements)
    
    for index in range(0, n):
        if fizzbuzz_section_elements[index].isdigit():
            start = int(fizzbuzz_section_elements[index]) - index
            return list(range(start, n + start))
    
    fizzbuzz = {
        'Fizz': [3], 
        'Buzz': [5], 
        'FizzBuzz': [15], 
        'Fizz Buzz': [9, 10], 
        'Buzz Fizz': [5, 6]
    }
    
    return fizzbuzz[fizzbuzz_section]

def reverse_fizzbuzz(string, start=0):
    def fb_gen(start= 1):
        while True:
            if not(start%5 or start%3): yield (start, 'FizzBuzz')
            elif not(start%3): yield (start, 'Fizz')
            elif not(start%5): yield (start, 'Buzz')
            else: yield (start, start)
            start += 1
    
    str_split = string.split()
    for i, v in enumerate(str_split):
        if v.isdigit(): return list(range(int(v)-i, len(str_split) + int(v)-i))

    gen, index_check  = fb_gen(), 0
    for ind, val in gen:
        if str_split[index_check] == val:
            if index_check == len(str_split) - 1:
                return list(range(ind - len(str_split) + 1, ind + 1))
            index_check += 1
        else:
            index_check = 0


def reverse_fizzbuzz(string):
    dic = {'Fizz':3, 'Buzz':5, 'FizzBuzz':15, 'Buzz Fizz':5, 'Fizz Buzz':9} # if only strings, those are the starting positions
    split = string.split()     
    
    # if contains number, find fist and return which number is first in original fizzbuzz string
    # if there is no number, must be one of the situation in dic, which will give starting number for each of those
    start = next((int(y)-x for x,y in enumerate(split) if y.isdigit()), dic.get(string)) 
    return list(range(start, start + len(split)))

def reverse_fizzbuzz(s):
    no_int = {"Fizz": 3, "Buzz": 5, "Buzz Fizz": 5, "Fizz Buzz": 9, "FizzBuzz": 15}
    lst = s.split(" ")
    start = next((int(item) - i for i, item in enumerate(lst) if item.isdecimal()), no_int.get(s))
    return list(range(start, start + len(lst)))


def reverse_fizzbuzz(string):
    arr = string.split()
    return list(map(lambda di: list(range(int(arr[di]) - di, int(arr[di]) - di + len(arr))), [next((k for k, v in enumerate(arr) if v.isdigit()), -1)]))[0] if any(a.isdigit() for a in arr) else [3] if string == 'Fizz' else [5] if string == 'Buzz' else [5, 6] if string == 'Buzz Fizz' else [9, 10] if string == 'Fizz Buzz' else [15]