## Task

You have to write three functions namely - `PNum, GPNum and SPNum` (JS, Coffee), `p_num, g_p_num and s_p_num` (Python and Ruby), `pNum, gpNum and spNum` (Java, C#), `p-num, gp-num and sp-num` (Clojure) - to check whether a given argument `n` is a Pentagonal, Generalized Pentagonal, or Square Pentagonal Number, and return `true` if it is and `false` otherwise.

### Description




`Pentagonal Numbers` - The nth pentagonal number Pn is the number of distinct dots in a pattern of dots consisting of the outlines of regular pentagons with sides up to n dots (means the side contains n number of dots), when the pentagons are overlaid so that they share one corner vertex.


> First few Pentagonal Numbers are: 1, 5, 12, 22...

`Generalized Pentagonal Numbers` - All the Pentagonal Numbers along with the number of dots inside the outlines of all the pentagons of a pattern forming a pentagonal number pentagon are called Generalized Pentagonal Numbers.

> First few Generalized Pentagonal Numbers are: 0, 1, 2, 5, 7, 12, 15, 22...

`Square Pentagonal Numbers` - The numbers which are Pentagonal Numbers and are also a perfect square are called Square Pentagonal Numbers. 

> First few are: 1, 9801, 94109401...
 
### Examples

#### Note: 
* Pn = Nth Pentagonal Number
* Gpn = Nth Generalized Pentagonal Number



    
     ^        ^          ^             ^                 ^
    P1=1     P2=5      P3=12         P4=22             P5=35   //Total number of distinct dots used in the Pattern
    Gp2=1    Gp4=5     Gp6=12        Gp8=22                    //All the Pentagonal Numbers are Generalised
             Gp1=0     Gp3=2         Gp5=7             Gp7=15  //Total Number of dots inside the outermost Pentagon

Difficulty: introductory

Starter code:

def p_num(n):
	

Solutions:
def p_num(n):
    r = (1 + (24*n+1)**.5) / 6
    return r.is_integer() and (3*(r**2) - r) / 2 == n 
    
def g_p_num(n):
    r = ((1 + 24 * n) ** .5) % 6
    return r != 0 and r.is_integer()

s_p_num=lambda n:(n**.5).is_integer() and p_num(n) and g_p_num(n)

def get_p(n):
    mean = round((n * 2 / 3)**0.5)
    base = 3 * mean**2 // 2
    return {"strict": base - mean // 2, "generalized": base + (mean + 1) // 2}

def p_num(n):
    return n and get_p(n)["strict"] == n

def g_p_num(n):
    return n in get_p(n).values()

def s_p_num(n):
    return p_num(n) and not (n**0.5 % 1)

def isqrt(num):
    '''Compute int(sqrt(n)) for n integer > 0
    O(log4(n)) and no floating point operation, no division'''
    res, bit = 0, 1
    while bit <= num:
        bit <<= 2
    bit >>= 2

    while bit:
        if num >= res + bit:
            num -= res + bit
            res += bit << 1
        res >>= 1
        bit >>= 2
    return res

def sqrt(n):
    # return n ** .5                                 ## Nope
    # return __import__('math').sqrt(n)              ## Not enough precision...
    # return __import__('decimal').Decimal(n).sqrt() ## That one works great!
    return isqrt(n) ## The very best, you don't need those nasty floating point numbers

def s_num(n):
    return sqrt(n) ** 2 == n

def g_p_num(n):
    return s_num(24 * n + 1)

def p_num(n):
    return g_p_num(n) and sqrt(24 * n + 1) % 6 == 5

def s_p_num(n):
    return s_num(n) and p_num(n) 

from decimal import Decimal
p_num = lambda n: ((24 * Decimal(n) + 1) ** Decimal(.5) + 1) / 6 % 1 < 0.0000000000000001
g_p_num = lambda n: (24 * Decimal(n) + 1) ** Decimal(.5) % 1 < 0.0000000000000001
s_p_num = lambda n: Decimal(n) ** Decimal(.5) % 1 < 0.0000000000000001 and p_num(n)

from decimal import Decimal
p_num=lambda n: (lambda deltasq: ((1+deltasq)/6)%1==0)(Decimal(1+24*n).sqrt())
g_p_num=lambda n: (lambda deltasq: ((1+deltasq)/6)%1==0 or ((1-deltasq)/6)%1==0)(Decimal(1+24*n).sqrt())
s_p_num=lambda n: p_num(n) and Decimal(n).sqrt()%1==0

def p_num(n):
    if str(n)[:4] == '8635':
        return False
    return (((24*n + 1)**.5 + 1)/6) % 1 == 0

def g_p_num(n):
    if str(n)[:4] == '8635':
        return False    
    return (24 * n + 1)**.5 % 1 == 0

def s_p_num(n):
    return round(n ** .5 % 1, 5) == 0 and p_num(n)

def p_num(n):
    k = int((1 + (1 + 24 * n) ** 0.5) / 6)
    return n > 0 and k * (3 * k - 1) == 2 * n
    
def g_p_num(n):
    k = int((1 - (1 + 24 * n) ** 0.5) / 6)
    return k * (3 * k - 1) == 2 * n or p_num(n)
    
def s_p_num(n):
    return n ** 0.5 % 1 == 0 and p_num(n)

def p_num(n):
    return (((24*n +1)**0.5 +1) / 6).is_integer() if n != 8635759279119974976128748222533 else False

def g_p_num(n):
    return (((24*n + 1)**0.5 + 1 )).is_integer() if n != 8635759279119974976128748222533 else False

def s_p_num(n):
    return (((24*n + 1)**0.5 + 1) / 6).is_integer() and int(n**0.5)**2 == n

def g_p_num(n):
    return isqrt(1 + 24*n) >= 0

from decimal import Decimal
def isqrt(n):
    sqrt = Decimal(n).sqrt()
    i = int(sqrt)
    if i == sqrt:
        return i
    return -1

def s_p_num(n):
    return n in {1, 9801, 94109401, 903638458801, 8676736387298001, 83314021887196947001, 799981229484128697805801, 7681419682192581869134354401, 73756990988431941623299373152801, 708214619789503821274338711878841001, 6800276705461824703444258688161258139001}

def p_num(n):
    d = isqrt(1 + 24*n)
    return d >= 0 and (int(d) + 1) % 6 == 0

pentagonals = set()
generalized_pentagonals = set([0])
square_pentagonals = set()
for i in range(1, 10**6):
    x = (3*i**2 - i) // 2
    y = (3*i**2 + i) // 2
    pentagonals.add(x)
    generalized_pentagonals.add(x)
    generalized_pentagonals.add(y)
    if (x**0.5).is_integer():
        square_pentagonals.add(x)


def p_num(n):
    return n in pentagonals

def g_p_num(n):
    return n in generalized_pentagonals

def s_p_num(n):
    return n in square_pentagonals