The concept of "[smooth number](https://en.wikipedia.org/wiki/Smooth_number)" is applied to all those numbers whose prime factors are lesser than or equal to `7`: `60` is a smooth number (`2 * 2 * 3 * 5`), `111` is not (`3 * 37`).

More specifically, smooth numbers are classified by their highest prime factor and your are tasked with writing a `isSmooth`/`is_smooth` function that returns a string with this classification as it follows:

* 2-smooth numbers should be all defined as a `"power of 2"`, as they are merely that;
* 3-smooth numbers are to return a result of `"3-smooth"`;
* 5-smooth numbers will be labelled as `"Hamming number"`s (incidentally, you might appreciate [this nice kata on them](https://www.codewars.com/kata/hamming-numbers));
* 7-smooth numbers are classified as `"humble numbers"`s;
* for all the other numbers, just return `non-smooth`.

Examples:
```python
is_smooth(16) == "power of 2"
is_smooth(36) == "3-smooth"
is_smooth(60) == "Hamming number"
is_smooth(98) == "humble number"
is_smooth(111) == "non-smooth"
```
The provided input `n` is always going to be a positive number `> 1`.

Difficulty: introductory

Starter code:

def is_smooth(n):
	

Solutions:
def is_smooth(n):
    for x in [2,3,5,7]:
        while n%x==0:n//=x
        if n==1:return ("power of 2",'3-smooth','Hamming number','humble number')[(2<x)+(3<x)+(5<x)]  
    return "non-smooth"

from collections import defaultdict


names = defaultdict(lambda: 'non-smooth', {
    2: 'power of 2',
    3: '3-smooth',
    5: 'Hamming number',
    7: 'humble number',
})


def is_smooth(n):
    divisors = set()
    for d in [2, 3, 5, 7]:
        while n % d == 0:
            divisors.add(d)
            n //= d
    if n != 1:
        divisors.add(9)
    return names[max(divisors, default=9)]

def is_smooth(n):
    for v in [2,3,5,7]:
        while n%v==0:n/=v
        if n==1:return['','','power of 2','3-smooth','','Hamming number','','humble number'][v]
    return 'non-smooth'

def find_factors(n):
    factors = []
    for i in (7, 5, 3, 2):
         while n%i==0:
             n= n/i
             factors.append(i)  
    if n>0: return factors + [n]
    return factors
    
def is_smooth(n):
    f={2:"power of 2", 3: "3-smooth", 5: "Hamming number", 7: "humble number"} 
    return f.get(max(find_factors(n)), "non-smooth")

is_smooth=lambda n,p=0: ["power of 2", "3-smooth", "Hamming number", "humble number", "non-smooth"][p] if n<2 or p>3 else is_smooth(n,p+1) if n%[2,3,5,7,11][p] else is_smooth(n//[2,3,5,7,11][p],p)

def is_smooth(n):
    primes=set()
    n1=0
    while n1!=n:
        n1=n
        for p in {2,3,5,7}:
            if n%p==0:
                primes.add(p)
                n//=p
    if n!=1:return "non-smooth"
    return {2:"power of 2",3:"3-smooth",5:"Hamming number",7:"humble number"}[max(primes)]

def is_smooth(n):
    
    i = 2
    
    a = []
    
    while i * i <= n:
        
        if n % i:
            
            i += 1
            
        else:
            
            n //= i
            
            a.append(i)
            
    if n > 1:
        
        a.append(n)
        
    m = max(a)
    
    if m==2:
        
        return "power of 2"
    
    if m==3:
        
        return "3-smooth"
    
    if m == 5:
        
        return "Hamming number"
    
    if m == 7:
        
        return "humble number"
    
    else:
        
        return "non-smooth"
    


from numpy import prod
def is_smooth(n):
    number = n
    divisors = []
    while 1:
        if not n%2:
            divisors.append(2)
            n/=2
        else: break
        
    while 1:
        if not n%3:
            divisors.append(3)
            n/=3
        else: break

    while 1:
        if not n%5:
            divisors.append(5)
            n/=5
        else: break
        
    while 1:
        if not n%7:
            divisors.append(7)
            n/=7
        else: break
    
    if prod(divisors)==number and max(divisors) == 2: return "power of 2"
    elif prod(divisors)==number and max(divisors) == 3: return "3-smooth"
    elif prod(divisors)==number and max(divisors) == 5: return "Hamming number"
    elif prod(divisors)==number and max(divisors) == 7: return "humble number"
    else: return "non-smooth"

from math import sqrt

def is_smooth(n):
    smooth = {2: "power of 2",
              3: "3-smooth",
              5: "Hamming number",
              7: "humble number"}
    
    s = set()
    i = 2
    while i <= sqrt(n):
        while n % i == 0:
            s.add(i)
            n //= i
        i += 1
    s.add(n)
    
    return smooth.get(max(s), "non-smooth")

from functools import reduce
from operator import mul

def is_smooth(n):
    num = n
    factors = [1]
    prime_fact = iter([i for i in (2,3,5,7) if not n%i])
    fact = next(prime_fact, n)
    while reduce(mul, factors) != n and fact != 0:
        if not num % fact:
            factors += [fact]
            num /= fact
        else:
            fact = next(prime_fact, 0)
    return "non-smooth" if fact==0 else "power of 2" if factors[-1] == 2 else "3-smooth" if factors[-1] == 3 else\
           "Hamming number" if factors[-1] == 5 else "humble number" if factors[-1] == 7 else "non-smooth"