def check_property(perm):
prime_gen = primes.gen_primes()
for y in range(1, 8):
x = listmath.list_to_int(perm[y : y + 3])
p = next(prime_gen)
if x % p != 0:
return False
return True
def solve(t):
sums = [0]
pg = gen_primes()
while sums[-1] < t:
sums.append(sums[-1] + next(pg))
le = len(sums)
m = (0, 0, 0)
for i in range(1, le-1):
# Terminate early.
if sums[i] + sums[i+1] >= t:
break
for j in range(i+1, le):
n = sums[j] - sums[i-1]
if n < t and (j - i-1) > (m[2] - m[1]) and is_prime(n):
m = (n, i, j)
return m
def solve51(prime_value):
prime_gen = gen_primes()
current_prime = next(prime_gen)
current_length = len(int_to_list(current_prime))
while True:
if len(int_to_list(current_prime)) != current_length:
current_length = len(int_to_list(current_prime))
# Iterate through replacement digits.
for vmap in gen_valid_mappings(current_prime):
prime_list = [current_prime]
for x in range(0,10):
# Sometimes enough digits will have failed that we know there
# cannot be sufficient primes in this permutation.
if prime_value + x - len(prime_list) > 10:
break
m = map_to_number(current_prime, x, vmap)
if is_prime(m) and m != current_prime and len(str(m)) == len(str(current_prime)):
prime_list.append(m)
if len(prime_list) == prime_value:
return (vmap, current_prime, prime_list)
current_prime = next(prime_gen)
def test_gen_primes(n):
for p1, p2 in zip(gen_primes(), gen_primes_under(n)):
assert p1 == p2
output = cStringIO.StringIO()
# END BASIC SETUP
coins = {}
jamcoins_with_divisors_in_all_bases = set()
for case in xrange(cases):
line = lines[case].strip()
coin_length, num_coins = [int(i) for i in line.split(' ')]
counter = 0
try:
for d in gen_primes(2**32):
print "Checking divisor {0}".format(d)
for j in itertools.islice(gen_jamcoin_candidates(coin_length), 0,
1000000):
for base in [2, 3, 4, 5, 6, 7, 8, 9, 10]:
n = int(j, base)
if n % d == 0:
coins[j] = coins.get(j, {})
coins[j][base] = coins[j].get(base, d)
if len(coins[j]) == 9:
jamcoins_with_divisors_in_all_bases.add(j)
if len(jamcoins_with_divisors_in_all_bases
) == num_coins:
raise StandardError(
"Just breaking out of the loop")
except StandardError:
def allReplacements(digits, number):
return map(
lambda poss: list(map(
lambda d: digits2number(replacement(digits, d, poss)),
range(number + 1, 10)
)),
combinations(findOccurences(number, digits))
)
def generatesFamily(order, digit, number):
hasEnoughPrimes = lambda gens: list(map(
primes.is_prime,
gens
)).count(True) >= (order - 1)
digits = list(number2digits(number))
return any(map(hasEnoughPrimes, allReplacements(digits, digit)))
if __name__ == '__main__':
ps = primes.gen_primes()
for p in ps:
if (generatesFamily(8, 0, p) or
generatesFamily(8, 1, p) or
generatesFamily(8, 2, p)
):
print(p)
break
import primes
from . import UUID
from .models import UUIDNodes
ANONYMOUS_USER_CODE = 'ANONYMOUS'
ANONYMOUS_USER_UUID = UUID(settings.ANONYMOUS_USER_ID)
_UUID_NODE_MASK = (1 << 48) - 1
_UUID_CLOCK_MASK = (1 << 14) - 1
_UUID_TIME_INITIAL = 0x1e4391800000000
PRIMES_15_2000 = list(primes.gen_primes(15, 2000))
def get_obj_for_hash(node, generator):
seen = set()
node_hash = int(hashlib.sha1(binascii.unhexlify('{:012x}'.format(node))).hexdigest(), 16)
for buckets in PRIMES_15_2000:
h = node_hash % buckets + 1
if h not in seen:
obj = generator(h)
if obj is not None:
return obj
seen.add(h)
raise RuntimeError("Cannot find an available bucket for the node")
def test_lower_edge(self):
self.assertEqual(gen_primes(0), [],
msg='An input of zero should yield an empty list')
self.assertEqual(gen_primes(-1), [],
msg='An input less than 0 should yield an empty list')
def test_invalid_input(self):
self.assertEqual(gen_primes(""), [],
msg='A string should return the empty list')
self.assertEqual(gen_primes({}), [],
msg='A dictionary should return the empty list')
def test_normal_behaviour(self):
self.assertEqual(gen_primes(1), [2], msg='The first prime number is 2')
self.assertEqual(gen_primes(2), [2, 3],
msg='The first 2 prime numbers are 2 and 3')
self.assertEqual(gen_primes(10), [2, 3, 5, 7, 11, 13, 17, 19, 23, 29],
msg='Incorrect list of first 10 prime numbers')
def test_lower_edge(self):
self.assertEqual(gen_primes(0), [],
msg='An input of zero should yield an empty list')
self.assertEqual(gen_primes(-1), [],
msg='An input less than 0 should yield an empty list')
def test_invalid_input(self):
self.assertEqual(gen_primes(""), [],
msg='A string should return the empty list')
self.assertEqual(gen_primes({}), [],
msg='A dictionary should return the empty list')
def test_normal_behaviour(self):
self.assertEqual(gen_primes(1), [2], msg='The first prime number is 2')
self.assertEqual(gen_primes(2), [2, 3],
msg='The first 2 prime numbers are 2 and 3')
self.assertEqual(gen_primes(10), [2, 3, 5, 7, 11, 13, 17, 19, 23, 29],
msg='Incorrect list of first 10 prime numbers')
from math import ceil, sqrt
from functools import reduce
from primes import gen_primes
import matplotlib.pyplot as plt
import numpy as np
import operator, time
prime_numbers = gen_primes(1000000)
def prime_factorization(n):
if n in prime_numbers:
return '%s is prime' % n
primes, gen, number = [], iter(generate(n)), n
while True:
try:
prime = next(gen)
except StopIteration:
return primes if primes else '%s is prime' % number
else:
while n / prime == int(n / prime):
n = n / prime
primes.append(prime)
if n in prime_numbers:
n = int(n)
primes.append(n)
return primes
try:
if reduce(operator.mul, primes) == number:
return primes
except Exception:
