## The galactic games have begun!

It's the galactic games! Beings of all worlds come together to compete in several interesting sports, like nroogring, fredling and buzzing (the beefolks love the last one). However, there's also the traditional marathon run.

Unfortunately, there have been cheaters in the last years, and the committee decided to place sensors on the track. Committees being committees, they've come up with the following rule:

> A sensor should be placed every 3 and 5 meters from the start, e.g.
> at 3m, 5m, 6m, 9m, 10m, 12m, 15m, 18m….

Since you're responsible for the track, you need to buy those sensors. Even worse, you don't know how long the track will be! And since there might be more than a single track, and you can't be bothered to do all of this by hand, you decide to write a program instead.

## Task
Return the sum of the multiples of 3 and 5 __below__ a number. Being the _galactic_ games, the tracks can get rather large, so your solution should work for _really_ large numbers (greater than 1,000,000).

### Examples
```python
solution (10) # => 23 = 3 + 5 + 6 + 9
solution (20) # => 78 = 3 + 5 + 6 + 9 + 10 + 12 + 15 + 18
```

Difficulty: introductory

Starter code:

def solution(number):
	

Solutions:
def summ(number, d):
    n = (number - 1) // d
    return n * (n + 1) * d // 2

def solution(number):
    return summ(number, 3) + summ(number, 5) - summ(number, 15)


def solution(number):
    a = (number - 1) // 5
    b = (number - 1) // 3
    c = (number - 1) // 15
    
    sum_a = ((a * (a + 1)) // 2) * 5
    sum_b = ((b * (b + 1)) // 2) * 3
    sum_c = ((c * (c + 1)) // 2) * 15
    
    return sum_a + sum_b - sum_c

def solution(n):
    return sum(f * c * (c + 1) for f, c in ((f, (n - 1) // abs(f)) for f in (3, 5, -15))) // 2


val = lambda x: x*(x+1)>>1

def solution(number):
    res1 =  3 * val((number-1) //  3)
    res2 =  5 * val((number-1) //  5)
    res3 = 15 * val((number-1) // 15)
    return res1 + res2 - res3

A = lambda x,n: x * (((n-1) // x) * ((n-1) // x + 1)) // 2
solution=lambda n:A(3,n) + A(5,n) - A(15,n)

def f(a, x):
    n = x // a
    return n * a * (n + 1) // 2

def solution(n):
    return f(3, n-1) + f(5, n-1) - f(15, n-1)