Esempio n. 1
0
def euler():
    middle = math.ceil(math.sqrt(HIGHEST_N))
    for p in range(middle, 0, -1):
        if prime.is_prime(p):
            for q in range(middle + 1, math.ceil((10 ** 7) / p)):
                if prime.is_prime(q):
                    n = p * q
                    t = discreet.totient(n)
                    if sequence.is_permutation(str(n), str(t)):
                        return n
Esempio n. 2
0
def is_truncatable(number):
    if number < 10:
        return False
    for truncation in sequence.left_truncations(str(number)):
        if not primeutils.is_prime(int(truncation)):
            return False
    for truncation in sequence.right_truncations(str(number)):
        if not primeutils.is_prime(int(truncation)):
            return False
    return True 
Esempio n. 3
0
def euler():
    # for each "starting" prime number
    for prime_number in prime.primes(200000):
        # list of integers for each digit
        prime_number_digits = list(int(digit) for digit in str(prime_number))
        # set (without duplicates) of the digits in the prime number
        prime_number_digit_set = set(prime_number_digits)
        # for each digit that could be replaced in the prime number
        for base_digit in prime_number_digit_set:
            # number of digit replacements that are actual prime numbers
            prime_count = 0
            # never replace the first digit with a zero
            replacements = range(10) if prime_number_digits[0] != base_digit \
                    else range(1, 10)
            # for each possible digit replacement
            for replacement_digit in replacements:
                # replace the digit base_digit with replacement_digit
                modified_digits = replace(prime_number_digits, base_digit,
                        replacement_digit)
                # convert that list to a number
                modified_number = int(''.join(str(digit) \
                        for digit in modified_digits))
                # if it's a prime, increment the prime count (duh)
                if prime.is_prime(modified_number):
                    prime_count += 1
            # return if the answer if we found it
            if prime_count == FAMILY_SIZE:
                return prime_number
Esempio n. 4
0
def is_circular_prime(n, num_digs):
    cp = num_digs
    while cp > 0:
        n = ((n % 10) * 10**(num_digs - 1)) + n / 10
        if not is_prime(n): return False
        cp -= 1
    return True
Esempio n. 5
0
def check_prime_permutations(i):
    if is_prime(i):
        nums = get_pandigital_nums(str(i))
        pos = set()
        for n in nums:
            if is_prime(int(n)):
                pos.add(int(n))
                nums.remove(n)
        if len(pos) >= 3:
            for a in pos:
                for b in pos:
                    if a < b and a + ((b - a) * 2) in pos:
                        return str(a) + str(b) + str(a + (b - a) * 2)
        else:
            return ''
    return ''
Esempio n. 6
0
def euler():
    # highest number of consecutive primes that add up to a prime
    highest_chain_length = 1
    # highest resulting sum that was found
    highest_chain = 2
    # for each prime
    for prime_number in prime.primes(MAX):
        # exit when it can't possibly be the start of a new chain
        if prime_number > MAX // highest_chain_length:
            break
        # start a chain from this prime number
        accumulator = prime_number
        # length of the current chain
        chain_length = 1
        # for each prime starting from here
        for chain_prime in prime.primes(MAX):
            # exit when outside the bounds
            if accumulator > MAX:
                break
            # skip the primes below the "prime_number" start
            if chain_prime > prime_number:
                # if it's a prime and the chain length is longer than the
                # longest chain so far
                if prime.is_prime(accumulator) and \
                        chain_length > highest_chain_length:
                    highest_chain_length = chain_length
                    highest_chain = accumulator
                # increase chain length and add the next prime
                chain_length += 1
                accumulator += chain_prime
    return highest_chain
Esempio n. 7
0
def sequence_length(a, b):
    def f():
        return n ** 2 + a * n + b
    n = 0
    while f() > 1 and prime.is_prime(f()):
        n += 1
    return n
Esempio n. 8
0
def is_circular(prime):
    if prime in circular_cache:
        return circular_cache [prime]
    for rotation in sequence.rotations(str(prime)):
        if not primeutils.is_prime(int(''.join(rotation))):
            return False
    for rotation in sequence.rotations(str(prime)):
        circular_cache [int(''.join(rotation))] = True
    return True
Esempio n. 9
0
def check_prime_sum(b, e, pos):
    global max_r
    global ans
    if pos < 1000000 and is_prime(pos):
        if e - b > max_r:
            max_r = e - b
            ans = pos
    elif e - b > max_r:
        check_prime_sum(b + 1, e, pos - primes[b])
        check_prime_sum(b, e - 1, pos - primes[e])
Esempio n. 10
0
def euler():
    side_length = 2
    accumulator = 1
    prime_count = 0
    number_count = 1
    while side_length <= 8 or float(prime_count) / number_count >= 0.1:
        for i in range(4):
            accumulator += side_length
            number_count += 1
            if prime.is_prime(accumulator):
                prime_count += 1
        side_length += 2
    return (side_length - 1)
Esempio n. 11
0
def prime_sets():
    """Yield all sets of possible answers for problem #49.

    Will 'yield' three arguments: the first, second and third prime.

    These three prime numbers are separated by exactly LEAP, and are
    permutations of each other. The three primes have exactly 4 digits."""
    # for each prime number
    for first_prime in prime.primes(10 ** DIGITS // 3):
        # ensure that it has enough digits
        if first_prime > 10 ** (DIGITS - 1):
            # calculate the other two primes
            second_prime = first_prime + LEAP
            third_prime = first_prime + 2 * LEAP
            # invalid if they're not permutations of eachother
            if not is_int_permutation(first_prime, second_prime) or \
                    not is_int_permutation(first_prime, third_prime):
                continue
            # invalid if they're not actually primes
            if not prime.is_prime(second_prime) or \
                    not prime.is_prime(third_prime):
                continue
            # if this is reached, the three primes make up a possible answer
            yield first_prime, second_prime, third_prime
Esempio n. 12
0
def euler():
    # highest pandigital prime found so far
    highest_pandigital = 0
    # for number of digits from 4 to 9
    for length in range(4, 9):
        # generate the list of digits from 1 to n
        digits = list(range(1, length + 1))
        # for each permutation of these digits
        for permutation in sequence.permutations(digits):
            number = int(''.join(str(digit) for digit in permutation))
            # check if the number is prime
            if prime.is_prime(number):
                # set the new value of the highest pandigital prime if needed
                highest_pandigital = max(number, highest_pandigital)
    # return the highest pandigital prime found
    return highest_pandigital
Esempio n. 13
0
#!/usr/bin/env python

#
# Jack Ferguson 2018
#
# Problem
#
# q: Find the largest n-digit pandigital prime
# a: 7652413
#

from helpers.prime import is_prime
from helpers.pandigital import get_pandigital_nums

nums = get_pandigital_nums(
    '1234567')  # there are no primes that are 9,8-dig pandigital

ans = 0
for num in nums:
    if int(num) > ans and is_prime(int(num)): ans = int(num)
print "p41: " + str(ans)
Esempio n. 14
0
#
# Jack Ferguson 2018
#
# Problem 58
#
# q:
# a:
#
# this one needs a little work, right idea but there is a problem with the implementation

from __future__ import division
from helpers.prime import is_prime

side = 3
diags = 2
prime_diags = 1
num = 5
i = 2
inc = 2
while prime_diags / diags >= .10:
    diags += 1
    if is_prime(num): prime_diags += 1
    num += inc
    i += 1
    if i == 4:
        i = 0
        inc += 2
        side += 2
print 'p58: ' + str(side - 2)
Esempio n. 15
0
#
# Jack Ferguson 2018
#
# Problem 50
#
# q:
# a:
#

from helpers.prime import is_prime

primes = []
pos = 0
for i in range(2, 100000):
    if pos > 1000000: break
    if is_prime(i):
        pos += i
        primes.append(i)
ans = 0
max_r = 0


def check_prime_sum(b, e, pos):
    global max_r
    global ans
    if pos < 1000000 and is_prime(pos):
        if e - b > max_r:
            max_r = e - b
            ans = pos
    elif e - b > max_r:
        check_prime_sum(b + 1, e, pos - primes[b])
Esempio n. 16
0
#!/usr/bin/env python

#
# Jack Ferguson 2017
#
# Problem 7
#
# q: Find the 10001st prime
# a: 104743
#

from helpers.prime import is_prime 

NUM = 10001

num_prime = 0
ans = 0
while num_prime != NUM:
    ans += 1    
    if is_prime(ans): num_prime += 1
    
print "p7: " + str(ans)