Exemple #1
0
def p060():
    familys = []
    for p in tqdm(primes()):
        for family in familys:
            candidate = [*family, p]
            if all(
                    is_prime(int(f'{p}{f}')) and is_prime(int(f'{f}{p}'))
                    for f in family):
                if len(candidate) >= 4:
                    print(f'length:{len(candidate)}, sum:{sum(candidate):20}',
                          candidate)
                if len(candidate) >= 5:
                    return
                familys.append(candidate)
        familys.append([p])
def prime_family(prime, digit):
    members = 0
    for dig in "0123456789":
        next = int(prime.replace(digit, dig))
        if is_prime(next) and next > 100000:
            members += 1
    return members == 8
def is_trunctable(n):
    if not is_prime(n):
        return False
    else:
        temp = n // 10
        temp2 = n % 10
        dividend = 10
        while temp != 0:
            if not is_prime(temp):
                return False
            temp = temp // 10
        while dividend < n:
            if not is_prime(temp2):
                return False
            dividend *= 10
            temp2 = n % dividend
        return True
def answer():
    pandigitals = perms(7654321)
    print(pandigitals)
    final = 0
    for next in pandigitals:
        if is_prime(next):
            final = next
            break
    return final
Exemple #5
0
def p058():
    total = 1
    primes = 0
    length = 1
    ds = diagonals()
    while primes / total >= 0.1 or primes == 0:
        length += 2
        for _ in range(4):
            total += 1
            if is_prime(next(ds)):
                primes += 1
    print(length)
def answer():
    prime = 0
    diagonals = [1]
    ratio = 0.62
    side = 3
    while True:
        square = side**2
        next1 = square - (side-1)
        next2 = square - (side-1)*2
        next3 = square - (side-1)*3
        if is_prime(next1):
            prime += 1
        if is_prime(next2):
            prime += 1
        if is_prime(next3):
            prime += 1
        diagonals.extend([square, next1, next2, next3])
        ratio = prime / len(diagonals)
        if ratio < 0.1:
            break
        side += 2
    return side
def answer():
    # Lower bound is 1487
    found = 0
    primes = primes_to(10000, 1487)
    for a in range(len(primes)):
        for b in range(a+1, len(primes)):
            prime_a = primes[a]
            prime_b = primes[b]
            c = prime_b + (prime_b - prime_a)
            if c < 10000 and is_prime(c):
                if is_perm(prime_a, prime_b) and is_perm(prime_a, c):
                    found = str(prime_a) + str(prime_b) + str(c)
                    break
        if found:
            break
    return found
def answer():
    smallest = 1
    proven = False
    primes = [2]

    while not proven:
        smallest += 2
        if is_prime(smallest):
            primes.append(smallest)
            continue
        proven = True
        for prime in primes:
            if is_twiceSquare(smallest - prime):
                proven = False
                break
    return smallest
def answer(n):
    length = 0
    longest = 0
    primes = primes_to(n)
    # Make a list of sums
    prime_sum = [0]
    for x in range(len(primes)):
        prime_sum.append(prime_sum[x] + primes[x])
    for a in range(len(prime_sum)):
        b = a - (length + 1)
        while b >= 0:
            dif = prime_sum[a] - prime_sum[b]
            if dif > n:
                b -=1
                break
            if is_prime(dif):
                length = a - b
                longest = dif
            b -=1
    print("The prime is: " + str(longest) + " and consists of " + str(length) + " primes.")
Exemple #10
0
def test_p060():
    assert all(is_prime(p) for p in concatenate_numbers([3, 7, 109, 673]))
    assert concatenating_primes([3, 7, 109, 673])
Exemple #11
0
def concatenating_primes(numbers):
    return all(is_prime(p) for p in concatenate_numbers(numbers))
Exemple #12
0
def right_truncatable_prime(p):
    return all(is_prime(n) for n in right_truncated(p))
Exemple #13
0
def left_truncatable_prime(p):
    return all(is_prime(n) for n in left_truncated(p))
Exemple #14
0
from euler_helpers import is_prime


def circulate(n):
    """Return the list of numbers that are formed by cycling the digits of n"""
    digits = list(d for d in str(n))
    for cycle in range(1, len(digits) + 1):
        yield int("".join(digits))
        digits = digits[1:] + [digits[0]]


checked = {}
num = 0

for number in range(1, 1000001):
    if number in checked:
        continue
    circle = list(circulate(number))
    if all(is_prime(c) for c in circle):
        num += len(circle)
        for c in circle:
            checked[c] = True

checked = sorted(checked)
print(checked)
print(len(checked))
Exemple #15
0
def first_non_goldbach():
    for composite in tqdm(range(33, 10**5, 2)):
        if is_prime(composite):
            continue
        if not is_goldbach(composite):
            return composite
Exemple #16
0
def is_prime_set(primes):
    return all(is_prime(int(str(prime[0]) + str(prime[1]))) for prime in itertools.permutations(primes, 2))