Consider the following numbers (where `n!` is `factorial(n)`):
```
u1 = (1 / 1!) * (1!)
u2 = (1 / 2!) * (1! + 2!)
u3 = (1 / 3!) * (1! + 2! + 3!)
...
un = (1 / n!) * (1! + 2! + 3! + ... + n!)
```

Which will win: `1 / n!` or `(1! + 2! + 3! + ... + n!)`?

Are these numbers going to `0` because of `1/n!` or to infinity due
to the sum of factorials or to another number?

## Task
Calculate `(1 / n!) * (1! + 2! + 3! + ... + n!)` 
for a given `n`, where `n` is an integer greater or equal to `1`.

To avoid discussions about rounding, return the result **truncated** to 6 decimal places, for example:
```
1.0000989217538616 will be truncated to 1.000098
1.2125000000000001 will be truncated to 1.2125
```

## Remark
Keep in mind that factorials grow rather rapidly, and you need to handle large inputs.

## Hint
You could try to simplify the expression.

Difficulty: introductory

Starter code:

def going(n):
	

Solutions:
def going(n):  
    s = 1.0
    for i in range(2, n + 1):
        s = s/i + 1
    return int(s * 1e6) / 1e6

def going(n):
    factor = 1.0
    acc = 1.0
    for i in range(n, 1, -1):
        factor *= 1.0 / i
        acc += factor
    return int(acc * 1e6) / 1e6

def going(n):
    a = 1.
    for i in range(2, n+1):
        a/=i
        a+=1
    return float(str(a)[:8])

from itertools import accumulate as acc
from math import floor

def going(n):
    return floor(1e6*(1 + sum(1/x for x in acc(range(n, 1, -1), lambda a, b: a*b))))/1e6

import math
from functools import reduce
def going(n):
    return math.floor(reduce(lambda r, i: r / float(i) + 1, range(1, n + 1), 0) * 1e6) / 1e6
    #return round(reduce(lambda r, i: r / float(i) + 1, xrange(1, n + 1), 0), 6)


# truncate to 6 decimals
def trunc(n):
    return float(str(n)[:8])

def going(n):
    sum = 1
    fact = 1.0
    for i in range(1,n):
        fact = fact/(n-i+1)
        sum += fact
    return trunc(sum)

from math import factorial, trunc
def going(n):
    sum, past = 1, 1
    for k in range(n, 1, -1):
        past *= 1/k
        sum += past
    return (trunc(sum*10**6))/(10**6)