def generate_key():

    # Find prime number P using Miller-Rabin Method
    p = random.randint(10000, 100000)

    while not utils.isPrime(p):
        p = random.randint(10000, 100000)

    # Find prime divisor
    q = 0

    for num in reversed(range(int(math.sqrt(p - 1)))):
        if ((p - 1) % num) == 0:
            if utils.isPrime(num):
                q = num
                break

# Find primitive root
    g = 1
    while g == 1:
        h = random.randint(2, p)
        g = utils.modular_power(h, (p - 1) / q, p)

    # Secret Key
    private_key = random.randint(1, p - 1)

    # Public Key Parameters
    y1 = utils.modular_power(g, private_key, p)

    y2 = utils.modular_power(y1, private_key, p)

    public_key = (g, y1, y2)

    return private_key, public_key, p
Example #2
0
 def validate(self):
     if isPrime(self.P):
         raise Exception("p not prime")
     if isPrime(self.Q):
         raise Exception("q not prime")
     if gcd(self.e, self.f) != 1:
         raise Exception("gcd(e, f) != 1")
Example #3
0
File: p037.py Project: doboy/euler
def isTrunc( n ):
    f = n
    while f:
        if not isPrime( f ):
            return False
        f //= 10

    m = int( log10( n ) + 1 )
    while m:
        if not isPrime( n % ( 10 ** m ) ):
            return False
        m -= 1
    return True
Example #4
0
def randPrime(primeLength):
    assert primeLength > 1, 'Length of number much greather than 1'
    start, end = 10**(primeLength - 1), 10**primeLength
    start += int((end - start) * random.random())
    start += start % 6
    primes = []
    for i in range(start, end, 6):
        if isPrime(i - 1):
            primes.append(i - 1)
        if isPrime(i + 1):
            primes.append(i - 1)
        if len(primes) > 100: break
    prime = random.choice(primes)
    return prime
Example #5
0
def prob27():
    # Considering quadratics of the form:

    # p(n) = n² + an + b, where |a| < 1000 and |b| < 1000

    # Find the product of the coefficients, a and b,
    # for the quadratic expression that produces
    # the maximum number of primes for consecutive values of n, starting with n
    # = 0.

    #b has to be prime, since our equation must hold for n=0
    limit = 1000
    maxN = maxA = maxB = 0
    primes = utils.genPrimes(limit)
    for a in range(-limit + 1, limit + 1, 2):  #a must be odd
        for b in primes:
            n = 1  #we know p(n) for n=0 is prime, so our function already generates at least 1
            #prime
            while n**2 + a * n + b > 0 and utils.isPrime(n**2 + a * n + b):
                n += 1
            if n > maxN:
                maxN = n
                maxA = a
                maxB = b
    return maxA * maxB
Example #6
0
def odd_composites():
    # numbers that are not prime and not 1
    count: int = 1
    while True:
        count += 2  # is odd
        if not isPrime(count):
            yield count
Example #7
0
def prob41():
    #pandigital primes
    limit = 7654321 #we exploit the property that if the sum of digits of a number is divisible by 3, the number is divisible by 3
    numbers = "".join([str(i) for i in range(1,len(str(limit))+1)])
    for x in range(limit,1,-2):
        if all(str(x).count(y) == 1 for y in numbers):
            if utils.isPrime(x):
                return x
Example #8
0
File: p035.py Project: doboy/euler
def isCircular( n ):
    digits = int( log10( n ) )
    for _ in xrange( digits + 1 ):
        if not isPrime( n ):
            return False
        # rotate the number
        n = rotated( n, digits )
    return True
Example #9
0
def testNdFactor():
    for M in (1, 2, 3, 4, 5, 10, 15, 36, 37, 49, 97, 121, 0, -5):
        val = ndFactor(str(M))
        utils.tprint(M, ':', val)
        if M < 2 or utils.isPrime(M):
            assert val == 'no'
        else:
            assert M % int(val) == 0
Example #10
0
def testFactorUnary():
    for M in (1,2,3,4,5,10,15,36,37,49,97,121):
        unaryM = '1'*M
        val = factorUnary(unaryM)
        utils.tprint(M, ':', val)
        if utils.isPrime(M):
            assert val == 'no'
        else:
            assert M % int(val) == 0
Example #11
0
def prob7():
    target = 10001
    primeCount = 0
    i = 0
    while primeCount < target:
        if utils.isPrime(i):
            primeCount += 1
        i += 1
    return i-1
Example #12
0
def nthPrime(n):
    num, count = 3, 1

    while True:
        if isPrime(num):
            count += 1
            if count == n:
                return num
        num += 2
Example #13
0
def prob7():
    target = 10001
    primeCount = 0
    i = 0
    while primeCount < target:
        if utils.isPrime(i):
            primeCount += 1
        i += 1
    return i - 1
Example #14
0
def prob41():
    #pandigital primes
    limit = 7654321 #we exploit the property that if the sum of digits of a number is divisible by
                    #3, the number is divisible by 3
    numbers = "".join([str(i) for i in range(1,len(str(limit)) + 1)])
    for x in range(limit,1,-2):
        if all(str(x).count(y) == 1 for y in numbers):
            if utils.isPrime(x):
                return x
Example #15
0
def only_prime_rotations(n):
    ds = utils.digits(n, 10)[::-1]
    for _ in range(len(ds)):
        ds.append(ds.pop(0))
        i = int(''.join(map(str, ds)))
        if not utils.isPrime(i):
            # print(i,"not prime",ds)
            return False
        # print(ds)
    return True
Example #16
0
def Go():
    nums = list()
    for k in xrange(9, 5, -1):
        for l in permutations(range(1, k)):
            i = getN(l)
            if i % 5 == 0 or i % 3 == 0 or i % 7 == 0:
                continue
            if isPandigital(i) and isPrime(i):
                nums.append(i)
    print(max(nums))
Example #17
0
def getVal(limit):
    count = 1
    candidate = 1

    while (count < limit):
        candidate += 2
        if (isPrime(candidate)):
            count += 1

    return candidate
Example #18
0
def main():
    primes = [2, 3]
    i = primes[-1]
    while primes[-1] < 2000000:
        i += 2
        # sieving would be faster, but I already wrote isPrime
        if isPrime(i):
            # print(i)
            primes.append(i)
    primes.pop()
    print(sum(primes))
def arithmetic_sequences(listofnumbers):
    listofprimes = [number for number in listofnumbers if isPrime(number)]
    prime_permutations = set()

    for i in listofprimes:
        for j in listofprimes:
            if (i - j) + i in listofprimes and 2 * i - j < i < j:
                if "0" not in list(str(j)):
                    prime_permutations.add(((i - j) + i, i, j))

    return prime_permutations
def isTrucatablePrimes(number: int) -> bool:
    # print(number)
    listofdigits: List[int] = numberToList(number)
    # print(listofdigits)
    lenList: int = len(listofdigits)

    # truncatable from left
    for i in range(lenList):
        # print(listofdigits[i:lenList])
        if not isPrime(listToNumber(listofdigits[i:lenList])):
            # print(listofdigits[i:lenList])
            return False

    # truncatable from right
    for i in range(lenList):
        # print(listofdigits[0:(i+1)])
        if not isPrime(listToNumber(listofdigits[0 : (i + 1)])):
            # print(listofdigits[0:(i+1)])
            return False

    return True
Example #21
0
def main():
    tests = [9, 15, 21, 25, 27, 33]
    assert all([test(i) for i in tests])
    # for i in [9,15,21,25,27,33]:
    #   print(i,test(i))
    n = 3
    # skip over primes
    while test(n) or isPrime(n):
        n += 2
        if n % 1000000 == 0:
            print("at", n)
    print(n)
def maxPrimeFactor(number):
    '''
    maxPrimeFactor takes a number and returns the largest prime factor for that number
    '''
    # The largest factor of a number cannot be larger then the square root of the number
    maxFactor = int(number ** 0.5)
    while maxFactor > 1:
        if number % maxFactor == 0:
            if isPrime(maxFactor):
                return maxFactor
        maxFactor -= 1
    # If the while loop did not return a value then the orginal number has to be prime
    return number
Example #23
0
def test(n):
    """return true if number fits the conjecture"""
    # sum of a prime and twice a square
    # increase the square until n minus twice the square is never prime
    # n = p + 2*a**2, where p is prime
    # p = n - 2*a**2
    # a = ((n-p)/2)**(1/2)

    for a in range(int((n / 2)**(1 / 2)), 0, -1):
        # print(n-2*i**2)
        # print(n,n-2*a**2,a)
        p = n - 2 * a**2
        if isPrime(p):
            return True
    return False
Example #24
0
def prob46():
    #goldbach's other conjecture:
    from math import sqrt
    limit=6000
    primes = utils.genPrimes(limit)
    compositeOdds = [i for i in range(9,limit,2) if not utils.isPrime(i)]
    for i in compositeOdds:
        canBeWritten = False
        for n in primes:
            if (i-n) % 2 == 0:
                #we need to check if (i-n)/2  is a perfect square. if it is, i can be written as described
                num = (i-n)/2
                if num < 0: #this means we found no suitable prime
                    break
                if not (math.sqrt(num)-int(math.sqrt(num))):
                    canBeWritten=True
                    break
        if not canBeWritten:
            return i
Example #25
0
def prob46():
    #goldbach's other conjecture:
    from math import sqrt
    limit = 6000
    primes = utils.genPrimes(limit)
    compositeOdds = [i for i in range(9,limit,2) if not utils.isPrime(i)]
    for i in compositeOdds:
        canBeWritten = False
        for n in primes:
            if (i - n) % 2 == 0:
                #we need to check if (i-n)/2 is a perfect square.  if it is, i
                #can be written as described
                num = (i - n) / 2
                if num < 0: #this means we found no suitable prime
                    break
                if not (math.sqrt(num) - int(math.sqrt(num))):
                    canBeWritten = True
                    break
        if not canBeWritten:
            return i
Example #26
0
def prob27():
    # Considering quadratics of the form:

    # p(n) = n² + an + b, where |a| < 1000 and |b| < 1000

    # Find the product of the coefficients, a and b, 
    # for the quadratic expression that produces 
    # the maximum number of primes for consecutive values of n, starting with n = 0.
    
    #b has to be prime, since our equation must hold for n=0
    limit = 1000
    maxN = maxA = maxB = 0
    primes = utils.genPrimes(limit)
    for a in range(-limit+1,limit+1,2): #a must be odd
        for b in primes:
            n = 1 #we know p(n) for n=0 is prime, so our function already generates at least 1 prime
            while n**2+a*n+b > 0 and utils.isPrime(n**2+a*n+b):
                n += 1
            if n > maxN:
                maxN = n
                maxA = a
                maxB = b
    return maxA*maxB
Example #27
0
File: p058.py Project: doboy/euler
from utils import isPrime

def layerGen():
    x = 2
    s = 2
    while True:
        yield xrange( x, x + s * 4 + 1 )
        x = x + s * 4
        s += 4

layer = 0
lgen = layerGen()
primes, all = 0., 1
while primes / all > .1:
    for val in next( lgen ):
        if isPrime( val ):
            primes += 1
        all += 1
    layer += 1

# RELOOK
Example #28
0
File: p027.py Project: doboy/euler
def primeLen( a, b ):
    n = 0
    while isPrime( n ** 2 + a * n + b ):
        n += 1
    return n
Example #29
0
def iscomposite(n):
    return not isPrime(n)
Example #30
0
File: p046.py Project: doboy/euler
from utils import primeGen, isPrime, isSquare, isEven

def Goldbach( c ):
    for p in primeGen( c ):
        if isEven( c - p ) and isSquare( ( c - p ) / 2 ):
            return True

c = 4
while isEven( c ) or isPrime( c ) or Goldbach( c ):
    c += 1

print c
Example #31
0
File: p041.py Project: doboy/euler
from utils import isPrime, lexiPermGen

print max( p for n in xrange( 10 )
           for p in lexiPermGen( vals=xrange( 1, n ) ) 
           if isPrime( p ) )
Example #32
0
def sumOfPrimes(n):
    num = 3
    while num < n:
        if isPrime(num):
            yield num
        num += 2
    d5d6d7=357 is divisible by 7
    d6d7d8=572 is divisible by 11
    d7d8d9=728 is divisible by 13
    d8d9d10=289 is divisible by 17

Find the sum of all 0 to 9 pandigital numbers with this property.
"""

from itertools import combinations
from itertools import permutations
from functools import reduce
from math import sqrt
from utils import isPrime
from typing import List, Tuple

assert isPrime(3) == True
assert isPrime(10) == False

listofdigits: str = "1234567890"
numberofdigits: int = 10
digits: List[str] = list("1234567890")

substringdigits: List[int] = [
    int(digits[i] + digits[i + 1] + digits[i + 2])
    for i, digit in enumerate(digits)
    if i > 0 and i <= 7
]
print("substrings of 0123456789:", substringdigits)

listofPrimes: List[int] = [2, 3, 5, 7, 11, 13, 17]
def numberofPrimesQuadratic(a: int, b: int) -> int:
    n: int = 0
    while isPrime(n ** 2 + n * a + b):
        n += 1
    return n
Example #35
0
def sumOfPrimes(n):
    num = 3
    while num < n:
        if isPrime(num):
            yield num
        num += 2
def nextprime() -> Iterator[int]:
    number: int = 2
    while True:
        if isPrime(number):
            yield number
        number += 1
Example #37
0
"""
Project Euler - Problem 7

SOLVED
"""
import utils

if __name__ == "__main__":
    prime_count = 0
    prime_threshold = 10001
    i = 2
    while True:
        if utils.isPrime(i):
            prime_count += 1
            if prime_count == prime_threshold:
                print i
                break
        i += 1
"""Truncatable primes

Problem 37
The number 3797 has an interesting property. Being prime itself, it is possible to continuously remove digits from left to right, and remain prime at each stage: 3797, 797, 97, and 7. Similarly we can work from right to left: 3797, 379, 37, and 3.

Find the sum of the only eleven primes that are both truncatable from left to right and right to left.

NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes.
"""

from math import sqrt
from itertools import permutations
from typing import List
from utils import isPrime, nextprime

assert isPrime(1) == False
assert isPrime(0) == False
assert isPrime(7)


def listToNumber(numList: List[int]) -> int:
    s = "".join([str(i) for i in numList])
    return int(s)


assert listToNumber([1, 2, 3, 4]) == 1234


def numberToList(number: int) -> List[int]:
    return [int(digit) for digit in str(number)]
"""Consecutive prime sum

Problem 50
The prime 41, can be written as the sum of six consecutive primes:

41 = 2 + 3 + 5 + 7 + 11 + 13
This is the longest sum of consecutive primes that adds to a prime below one-hundred.

The longest sum of consecutive primes below one-thousand that adds to a prime, contains 21 terms, and is equal to 953.

Which prime, below one-million, can be written as the sum of the most consecutive primes?
"""
from typing import List
from utils import isPrime, nextprime

primes = nextprime()
primes_below12000 = [next(primes) for _ in range(1000)]

maxlength = 0
maxprime = -1
for prime_min in range(len(primes_below12000)):
    for prime_max in range(prime_min, len(primes_below12000)):
        testsum = sum(primes_below12000[prime_min:prime_max])
        if isPrime(testsum) and testsum < 1000000:
            if prime_max - prime_min > maxlength:
                maxlength = prime_max - prime_min
                maxprime = testsum

print(f"The prime, {maxprime} is the sum of {maxlength} consectutive primes.")
def isCircularPrime(number: int) -> bool:
    for i in digit_rotations(number):
        if not isPrime(i):
            return False
    return True