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
```

Difficulty: introductory

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())])