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

Source: codewars | Difficulty: EASY
Tags: Fundamentals

Mathematics

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 ** 0.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.0 / p) + e) ** p == n:
			return [int(n ** (1.0 / 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))) < 1e-07:
			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