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.

Source: codewars | Difficulty: EASY
Tags: Mathematics

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 * 1000000.0) / 1000000.0


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 * 1000000.0) / 1000000.0


def going(n):
	a = 1.0
	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(1000000.0 * (1 + sum((1 / x for x in acc(range(n, 1, -1), lambda a, b: a * b))))) / 1000000.0


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) * 1000000.0) / 1000000.0


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