isPrime Function for Python Language

No floating point operations are done below. This is faster and will tolerate higher arguments. The reason you must go only to the square-root is that if a number has a factor larger than its square root, it also has a factor smaller than it.

def is_prime(n):
    """"pre-condition: n is a nonnegative integer
    post-condition: return True if n is prime and False otherwise."""
    if n < 2: 
         return False;
    if n % 2 == 0:             
         return n == 2  # return False
    k = 3
    while k*k <= n:
         if n % k == 0:
             return False
         k += 2
    return True

With n**.5, you are not squaring n, but taking the square root.

Consider the number 20; the integer factors are 1, 2, 4, 5, 10, and 20. When you divide 20 by 2 and get 10, you know that it is also divisible by 10, without having to check. When you divide it by 4 and get 5, you know it is divisible by both 4 and 5, without having to check for 5.

After reaching this halfway point in the factors, you will have no more numbers to check which you haven’t already recognized as factors earlier. Therefore, you only need to go halfway to see if something is prime, and this halfway point can be found by taking the number’s square root.

Also, the reason 1 isn’t a prime number is because prime numbers are defined as having 2 factors, 1 and itself. i.e 2 is 1*2, 3 is 1*3, 5 is 1*5. But 1 (1*1) only has 1 factor, itself. Therefore, it doesn’t meet this definition.

Finding the square root of the number is for efficiency. eg. if I am trying to find the factors of 36, the highest number that can be multiplied by itself to form 36 is 6. 7*7 = 49.

therefore every factor of 36 has to be multiplied by 6 or a lesser number.

def is_prime(num, div = 2):
    if num == div: return True
    elif num % div == 0: return False
    elif num == 1: return False
    else: return is_prime(num, div + 1)

def is_prime(x):  
    if x<2:  
        return False  
    elif x == 2:  
        return True  
    else:  
        for n in range(2, x):  
            if x%n==0:  
                return False  
        return True

def is_prime(x):
    if x < 2:
        return False
    elif x == 2:
        return True  
    for n in range(2, x):
        if x % n ==0:
            return False
    return True

Srsly guys… Why so many lines of code for a simple method like this? Here’s my solution:

def isPrime(a):
    div = a - 1
    res = True
    while(div > 1):
        if a % div == 0:
            res = False
        div = div - 1
    return res

isPrime=lambda x: all(x % i != 0 for i in range(int(x**0.5)+1)[2:])

and here goes how to use it

isPrime(2) == False
isPrime(5) == True
isPrime(7) == True

To find all primes you might use:

filter(isPrime, range(4000)[2:])[:5]
=> [2, 3, 5, 7, 11]

Note that 5, in this case, denotes number of prime numbers to be found and 4000 max range of where primes will be looked for.

int(n**0.5) is the floor value of sqrt(n) which you confused with power 2 of n (n**2). If n is not prime, there must be two numbers 1 < i <= j < n such that: i * j = n.

Now, since sqrt(n) * sqrt(n) = n assuming one of i,j is bigger than (or equals to) sqrt(n) – it means that the other one has to be smaller than (or equals to) sqrt(n).

Since that is the case, it’s good enough to iterate the integer numbers in the range [2, sqrt(n)]. And that’s exactly what the code that was posted is doing.

If you want to come out as a real smartass, use the following one-liner function:

import re
def is_prime(n):    
    return not re.match(r'^1?$|^(11+?)1+$',n*'1')

An explanation for the “magic regex” can be found here

def is_prime(x):  
    if x < 2:  
        return False  
    for n in range(2, (x) - 1):  
        if x % n == 0:  
            return False  
    return True

Pretty simple!

def prime(x):
  if x == 1:
    return False
  else:
    for a in range(2,x):
      if x % a == 0:
        return False
  return True

The question was asked a bit ago, but I have a shorter solution for you

def isNotPrime(Number):
    return 2 not in [Number,2**Number%Number]

The math operation will mostly return 2 if the number is a prime, instead of 2. But if 2 is the given number, it is appended to the list where we are looking into.

Examples:

2^5=32    32%5=2
2^7=128   128%7=2
2^11=2048 2048%11=2

Counter examples:

2^341%341=2,  but 341==11*31
2^561%561=2,  but 561==3*11*17
2^645%645=2,  but 645==3*5*43

isNotPrime() reliably returns True if Number is not prime though.

Every code you write should be efficient.For a beginner like you the easiest way is to check the divisibility of the number ‘n’ from 2 to (n-1). This takes a lot of time when you consider very big numbers. The square root method helps us make the code faster by less number of comparisons. Read about complexities in Design and Analysis of Algorithms.

def fun(N):#prime test
if N>1 :
    for _ in xrange(5):
        Num=randint(1,N-1)
        if pow(Num,N-1,N)!=1:
            return False
    return True
return False

True if the number is prime otherwise false

I don’t know if I am late but I will leave this here to help someone in future.

We use the square root of (n) i.e int(n**0.5) to reduce the range of numbers your program will be forced to calculate.

For example, we can do a trial division to test the primality of 100. Let’s look at all the divisors of 100:

2, 4, 5, 10, 20, 25, 50
Here we see that the largest factor is 100/2 = 50. This is true for all n: all divisors are less than or equal to n/2. If we take a closer look at the divisors, we will see that some of them are redundant. If we write the list differently:

100 = 2 × 50 = 4 × 25 = 5 × 20 = 10 × 10 = 20 × 5 = 25 × 4 = 50 × 2
the redundancy becomes obvious. Once we reach 10, which is √100, the divisors just flip around and repeat. Therefore, we can further eliminate testing divisors greater than √n.

Take another number like 16.

Its divisors are, 2,4,8

16 = 2 * 8, 4 * 4, 8 * 2.

You can note that after reaching 4, which is the square root of 16, we repeated 8 * 2 which we had already done as 2*8. This pattern is true for all numbers.

To avoid repeating ourselves, we thus test for primality up to the square root of a number n.

So we convert the square root to int because we do not want a range with floating numbers.

Read the primality test on wikipedia for more info.

The number 1 is a special case which is considered neither prime nor composite.
For more info visit : http://mathworld.wolfram.com/PrimeNumber.html

And,
(n**0.5) –> This will give us the “square root” of ‘n’. As it is “n raised to the power 0.5 or 1/2”

And WHY do we do that,
Take for example the number 400:
We can represent it in the form a*b

1*400 = 400
2*200 = 400
4*100 = 400
5*80 = 400
8*50 = 400
10*40 = 400
16*25 = 400
20*20 = 400
25*16 = 400
40*10 = 400
50*8 = 400
80*5 = 400
100*4 = 400
200*2 = 400
400*1 = 400

Square root of 400 is 20:
and we can see that we only need to check the divisibility till 20 because, as ‘a’ reaches 20 ‘b’ starts decreasing…
So, ultimately we are checking divisibility with the numbers less than the square root.

This method will be slower than the the recursive and enumerative methods here, but uses Wilson’s theorem, and is just a single line:

from math import factorial

def is_prime(x):
    return factorial(x - 1)  % x == x - 1

This is my method:

import math

def isPrime(n):
    'Returns True if n is prime, False if n is not prime. Will not work if n is 0 or 1'

    # Make sure n is a positive integer
    n = abs(int(n))

    # Case 1: the number is 2 (prime)
    if n == 2: return True

    # Case 2: the number is even (not prime)
    if n % 2 == 0: return False

    # Case 3: the number is odd (could be prime or not)

    # Check odd numbers less than the square root for possible factors 
    r = math.sqrt(n)
    x = 3 
    while x <= r:
        if n % x == 0: return False  # A factor was found, so number is not prime
        x += 2 # Increment to the next odd number

    # No factors found, so number is prime  
    return True 

To answer the original question, n**0.5 is the same as the square of root of n. You can stop checking for factors after this number because a composite number will always have a factor less than or equal to its square root. This is faster than say just checking all of the factors between 2 and n for every n, because we check fewer numbers, which saves more time as n grows.

This is my np way:

def is_prime(x):
    if x < 4:
        return True
    if all([(x > 2), (x % 2 == 0)]):
        return False
    else:
        return np.array([*map(lambda y: ((x % y) == 0).sum(), np.arange(1, x + 1))]).sum() == 2

Here’s the performance:

%timeit is_prime(2)
%timeit is_prime(int(1e3))
%timeit is_prime(5003)

10000 loops, best of 3: 31.1 µs per loop
10000 loops, best of 3: 33 µs per loop
10 loops, best of 3: 74.2 ms per loop

def is_prime(n):
    n=abs(n)
    if n<2:    #Numbers less than 2 are not prime numbers
        return "False"
    elif n==2: #2 is a prime number
        return "True"
    else:
        for i in range(2,n): # Highlights range numbers that can't be  a factor of prime number n. 
            if n%i==0:
                return "False" #if any of these numbers are factors of n, n is not a prime number
    return "True" # This is to affirm that n is indeed a prime number after passing all three tests

I have a new solution which I think might be faster than any of the mentioned
Function in Python

It’s based on the idea that:
N/D = R
for any arbitrary number N, the least possible number to divide N (if not prime) is D=2 and the corresponding result R is (N/2) (highest).

As D goes bigger the result R gets smaller ex: divide by D = 3 results R = (N/3)
so when we are checking if N is divisible by D we are also checking if it’s divisible by R

so as D goes bigger and R goes smaller till (D == R == square root(N))

then we only need to check numbers from 2 to sqrt(N)
another tip to save time, we only need to check the odd numbers as it the number is divisible by any even number it will also be divisible by 2.

so the sequence will be 3,5,7,9,……,sqrt(N).

import math
def IsPrime (n): 
    if (n <= 1 or n % 2 == 0):return False
    if n == 2:return True
    for i in range(3,int(math.sqrt(n))+1,2):
        if (n % i) == 0:
            return False
    return True

Implemented a pseudocode (https://en.wikipedia.org/wiki/Primality_test) in python, hope this help.

# original pseudocode https://en.wikipedia.org/wiki/Primality_test
def isPrime(n):
    # Corner Cases
    if (n<= 1): return False
    elif (n<= 3): return True
    elif (n%2 == 0 or n%3 == 0): return False

    i = 5
    while i*i<=n:
        if (n%i==0 or n%(i+2)==0): return False
        i += 6

    return True;

%timeit isPrime(800)

(https://www.youtube.com/watch?v=Vxw1b8f_yts&t=3384s)
Avinash Jain

for i in range(2,5003):
    j = 2
    c = 0
    while j < i:
        if i % j == 0:
            c = 1
            j = j + 1
        else:
            j = j + 1
    if c == 0:
        print(str(i) + ' is a prime number')
    else:
        c = 0

It was an exercise in codecademy and that’s how i passed it below…

def is_prime(x):  

    # If number(x) is evenly divided by following dividers then number(x) is not prime

    divider = [2, 3, 5, 7]

    # An empty list to be able to check whether number(x) is evenly divided:

    remainder = []

    # exceptions for numbers 1,2,3,5,7:
    if x < 2:
        return False
    if x in divider:
        return True
    else:
        for nums in divider:
            remainder.append(x % nums)
        if 0 in remainder:
            return False
        else:
            return True

def is_prime(n):
if (n==2 or n==3): return True
if(n<=1 or n%2==0 or n%3==0 ): return False
for i in range(6,int((n**0.5)) + 2,6):
    if(n%(i-1)==0 or n%(i+1)==0):
        return False
return True

This is the answer to that website.

def is_Prime(n):
    if n <= 3:
        return n > 1
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    while i ** 2 <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True
isPrime=list()
c=-1
for i in range(0,1000001):
    c=c+1
    isPrime.append(c)
    if is_Prime(isPrime[i])==True:
       isPrime[i]=True
    else:
       isPrime[i]=False

This entire solution is based on factors. A natural number which has exactly two factors, i.e. 1 and the number itself, is a prime number. In simple words, if a number is only divisible by 1 and itself, then it is a prime number. Every prime number is an odd number except number 2.

def isprime(x):
         factors=[]
         if  x < 2:
              return False
         for i in range(1,x+1):
             if (x % i == 0):
                 factors.append(i)
         return True if len(factors) <=2 else False
    

Remember kids order of operations is important.
Doing it like this eliminates useless branches that costs performance and checks special rare cases only when necessary. there is no need to check if n == 2 unless n is odd. And there is no need to check if n <= 1 unless n is not divisible by any positive numbers other than itself and 1 because it’s a rare special case. Also checking if not n%5 is slower, atleast in python. That’s why I stopped in 3.

from math import sqrt
def is_prime(n):
    if not n%2: return n==2
    if not n%3: return n==3
    for i in range(5,int(sqrt(n))+1,2):
        if not n%i: return False
    return n>1

This is even faster solution, which doesn’t check numbers that are multipliers of 2 and 3 (in the loop) instead of 2 only. Btw, I stored int(sqrt(n)) to prevent the while loop from calculating it every iteration.

def is_prime(n):
    if not n&1: return n==2
    if not n%3: return n==3
    i,r=5,int(sqrt(n))
    while i<=r:
        if not n%i or not n%(i+2): return False
        i+=6
    return n>1