Write a function that takes a number or a string and gives back the number of **permutations without repetitions** that can generated using all of its element.; more on permutations [here](https://en.wikipedia.org/wiki/Permutation).

For example, starting with:
```
1
45
115
"abc"
```

You could respectively generate:
```
1
45,54
115,151,511
"abc","acb","bac","bca","cab","cba"
```

So you should have, in turn:
```python
perms(1)==1
perms(45)==2
perms(115)==3
perms("abc")==6
```

Source: codewars | Difficulty: EASY

Starter code: def perms(element):
	

Solutions:
from operator import mul
from math import factorial
from functools import reduce
from collections import Counter

def perms(inp):
	return factorial(len(str(inp))) // reduce(mul, map(factorial, Counter(str(inp)).values()), 1)


from math import factorial

def perms(e):
	e = str(e)
	n = factorial(len(e))
	for i in (e.count(i) for i in set(e) if e.count(i) > 1):
		if i:
			n = n / factorial(i)
	return n


from collections import Counter
import math

def perms(element):
	stringElement = str(element)
	tally = Counter(stringElement)
	topPart = math.factorial(len(stringElement))
	product = 1
	for t in tally:
		product = product * math.factorial(tally[t])
	return topPart / product


from collections import Counter
from math import factorial as fact
from functools import reduce
from operator import mul

def perms(element):
	s = str(element)
	c = Counter(s)
	return fact(len(s)) / reduce(mul, [fact(n) for n in c.values()], 1)


import math
import functools
import operator

def perms(element):
	element = str(element)
	permutation_count = math.factorial(len(element))
	eq_bottom = [math.factorial(element.count(char)) for char in set(element)]
	combination_count = functools.reduce(operator.mul, eq_bottom, 1)
	return permutation_count / combination_count


from itertools import permutations
from collections import Counter
from math import factorial
from functools import reduce

def perms(e):
	if isinstance(e, int):
		return perms(str(e))
	c = Counter(e)
	return factorial(len(e)) / reduce(lambda x, y: x * y, [factorial(x) for x in list(c.values())])