A [perfect power](https://en.wikipedia.org/wiki/Perfect_power) is a classification of positive integers:

> In mathematics, a **perfect power** is a positive integer that can be expressed as an integer power of another positive integer. More formally, n is a perfect power if there exist natural numbers m > 1, and k > 1 such that m^(k) = n.

Your task is to check wheter a given integer is a perfect power. If it is a perfect power, return a pair `m` and `k` with m^(k) = n as a proof. Otherwise return `Nothing`, `Nil`, `null`, `NULL`, `None` or your language's equivalent.

**Note:** For a perfect power, there might be several pairs. For example `81 = 3^4 = 9^2`, so `(3,4)` and `(9,2)` are valid solutions. However, the tests take care of this, so if a number is a perfect power, return any pair that proves it.

### Examples
```python
isPP(4) => [2,2]
isPP(9) => [3,2]
isPP(5) => None
```

Difficulty: introductory

Starter code:

def isPP(n):
	

Solutions:
from math import ceil, log, sqrt

def isPP(n):
    for b in range(2, int(sqrt(n)) + 1):
        e = int(round(log(n, b)))
        if b ** e == n:
            return [b, e]
    return None


def isPP(n):
    for i in range(2, int(n**.5) + 1):
        number = n
        times = 0
        while number % i == 0:
            number /= i
            times += 1
            if number == 1:
                return [i, times]
    return None


def isPP(n):
    for i in range(2, n+1):
        for j in range(2, n+1):
            if i**j > n:
                break
            elif i**j == n:
                return [i, j]
    return None

from math import log

def isPP(n, e=1e-12):
    for p in range(2, int(log(n, 2)) + 1):
        if int(n ** (1./p) + e) ** p == n:
            return [int(n ** (1./p) + e), p]

def isPP(n):
    x, y = 2, 2
    while x**2 <= n:
        if x**y == n:
            return[x,y]
        if x**y > n:
            x+=1
            y = 1
        y+=1        
    return None

from math import sqrt
def isPP(n):
    cur = int(sqrt(n)), 2
    while True:
        val = cur[0] ** cur[1]
        if val == 1:
            break
        if val > n:
            cur = cur[0]-1, cur[1]
        elif val < n:
            cur = cur[0], cur[1]+1
        else:
            return list(cur)

from math import log
def isPP(n):
    for m in range(2,int(n**0.5)+1):
        k = round(log(n, m), 13)
        if k % 1 == 0:
            return [m ,k]
    return

def isPP(n):
    b=n
    import math
    root=math.sqrt(n)
    iroot=int(root)
    if float(iroot)==root:
        return([iroot,2])
    elif n==1:
        return([1,1])
    else:
        if iroot==2:
            iroot=3
        for i in range(2,iroot):
            s=0
            d='no'
            n=b
            while n%i==0:
                d='yes'
                n=n/i
                s=s+1
                if n==1:
                    return([i,s])
            else:
                d='no'
        if d=='no':
            return None
    
                


def isPP(n):
    for k in range(2,round(n**0.5+1)):
        m=round(n**(1/k))
        if m**k==n:
            return [m,k]
    return None

def isPP(n):
    m, k = 2, 2
    while m**2 <= n:
        while m**k <= n:
            if m**k == n:
                return [m, k]
            else:
                k += 1
        m += 1
        k = 2
    return None

import math

def isPP(n):
    return next(([b, round(math.log(n, b))] for b in range(2, int(n**0.5)+1) if b**round(math.log(n, b)) == n), None)

def isPP(n):
    base = 2
    power = 2

    while base ** power <= n:
        while base ** power <= n:
            if base ** power == n:
                return [base, power]
            else:
                power += 1

        power = 2
        base += 1

    return None

def isPP(n):
    k = 2
    m = n**(1/k)
    while m % 1 != 0 and m > 2:
        k += 1
        m = n**(1/k)
        m = float("{:.5f}".format(m))
    if m % 1 == 0:
        return [int(m), k]
    else:
        return None

def isPP(n):
    d = 2
    k = 2
    while d >= 2:
        d = round(n**(1/k), 4)
        if d.is_integer():
            return [d,k]
        k +=1

primeTable = [2,3,5,7,11,13,17,19,23,29]
def isPP(n):
    for p in primeTable:
        base = round(n ** (1/p))
        if base ** p ==n:
            return [base, p]

def isPP(n):
    for i in range(2,400):
        for j in range(2,50):
            if i**j == n:
                return [i, j]

    return None

def isPP(num):
    for n in range(2, 100):
        if abs( num ** (1/n) - round(num ** (1/n))) < 0.0000001:
          return [round(num ** (1/n)), n]
        n += 1

from math import sqrt

def isPP(n):
    limit = int(sqrt(n))
    for m in range(2, limit + 1):
        k = 2
        while m ** k <= n:
            if m ** k == n:
                return [m, k]
            k += 1