def get_public_params(len_p):
assert len_p % 64 == 0
assert 512 <= len_p <= 1024
while True:
q = utils.get_big_prime(2**(160 - 1), 2**160)
p = q * (2**(len_p - 160))
# print('p:', len(bin(p)[2:]), 'bit')
high = 2**len_p
# print('high:', len(bin(high)[2:]), 'bit')
while p < high:
p += q
if not isprime(p + 1):
continue
p += 1
if (p - 1) % q == 0:
break
if isprime(p):
break
# print(p)
# print('p:', len(bin(p)[2:]), 'bit')
h = 2
while not pow(h, (p - 1) // q, p) > 1:
h += 1
g = pow(h, (p - 1) // q, p)
return p, q, g
def checkGroup(nums):
pairs = combinations(nums, 2)
try:
while 1:
pair = pairs.next()
n1 = catnums(pair[0], pair[1])
if isprime(n1):
n2 = catnums(pair[1], pair[0])
if not isprime(n2):
return False
else:
return False
except StopIteration:
return True
def is_valid_n(combo, n):
valid = False
v = f(combo, n)
if v > 2:
if utils.isprime(v):
valid = True
return valid
def hadamard_s(n):
if isprime(n) == 0:
print('error! n must be a prime\n')
circ_S = 0
inv_circ_S = 0
return False
if (n - 3) % 4 != 0:
print('error! n must be 4m + 3\n')
circ_S = 0
inv_circ_S = 0
return False
A_k = np.array(range(1, (n - 1) // 2 + 1))**2
A_k = A_k % n
S_1 = np.zeros([1, n])
S_1[0, 0] = 1
S_1[0, A_k] = 1
circ_S = np.zeros([n, n])
circ_S[0, :] = S_1
for i in range(2, n + 1):
circ_S[i - 1, :] = circshift_r(circ_S[i - 2, :], -1)
pos_measure = circ_S > 0
pos_measure_non = circ_S == 0
pos_measure_non_matr = True - circ_S
pos_measure_matr = circ_S
pos_measure_matr[pos_measure_non] = 0
inv_circ_S = (pos_measure_matr - pos_measure_non_matr) / (n + 1) * 2
return circ_S, inv_circ_S
def count(n, cur):
if not digits:
return [cur + [n]] if isprime(n) and n > max(cur) else []
res = []
if isprime(n) and n > max(cur + [0]):
res += count(0, cur + [n])
for d in digits:
digits.remove(d)
rest = count(n * 10 + d, cur)
res += rest
digits.add(d)
return res
def sieve(n):
prime_list = [2]
for x in range(3, n + 1):
if isprime(x) == True:
prime_list.append(x)
return prime_list
def get_full_size(block_number):
sz = DATASET_BYTES_INIT + DATASET_BYTES_GROWTH * (block_number //
EPOCH_LENGTH)
sz -= MIX_BYTES
while not isprime(sz / MIX_BYTES):
sz -= 2 * MIX_BYTES
return sz
def generator_elliptic_curve(l, m):
while True:
while True:
p = get_prime(l)
if p % 4 == 1:
break
a, b = complex_decomposition(1, p)
assert a * a + b * b == p
T = [-2 * a, -2 * b, 2 * a, 2 * b]
for t in T:
N = p + 1 + t
if isprime(N // 2):
r = N // 2
break
if isprime(N // 4):
r = N // 4
break
else:
continue
good = True
for i in range(1, m):
if (p**i) % r == 1:
good = False
if p == r or not good:
continue
while True:
e = EllipticPoint(p)
A = ((e.y**2 - e.x**3) * inverse(e.x, p)) % p
good = False
if N == r * 2:
if legendre_symbol(-A, p) == -1:
good = True
if N == r * 4:
if legendre_symbol(-A, p) == 1:
good = True
if not good:
continue
m = EllipticPoint.mul(e, N, A, p)
if m == EllipticPoint(p, -1, -1):
break
Q = EllipticPoint.mul(e, N // r, A, p)
return p, A, Q, r
def main():
i, count = 2, 0
while True:
if isprime(i):
count += 1
if count == 10001:
return i
i += 1
def prime_factors(number):
prime_list =[]
for x in xrange(2, number+1):
while number % x == 0:
if isprime(x):
prime_list.append(x)
number = number / x
return prime_list
def sieve(n):
prime_list = []
for x in range(2, n+1):
if x == 2:
prime_list.append(x)
elif isprime(x) == True:
prime_list.append(x)
return prime_list
def M(k):
if k <= 1:
return 0
else:
if isprime(k):
return (M(k-1) + 1)
else:
ds = factors(k)
ks = map(lambda x: m[x], ds)
# print k, ds, ks
return sum(ks)
def main():
digits = "987654321"
pandigitals = []
for i in reversed(range(1,10)):
choices = digits[-i:]
pandigitals.append(map("".join, itertools.permutations(choices, i)))
for i in range(0, 9):
for p in pandigitals[i]:
if utils.isprime(int(p)):
return p
def is_valid(combo):
valid = False
for n in range(40):
v = f(combo, n)
if v > 2:
if utils.isprime(v):
if n == 39:
valid = True
else:
break
else:
break
return valid
def main():
prime_numbers = utils.primes(10000)
odd_composites = [n for n in range(2, 10000) if (utils.isprime(n) == False) & (n % 2 != 0)]
for odd_composite in odd_composites:
number_found = False
for prime in prime_numbers:
difference = odd_composite - prime
if difference > 0:
if np.sqrt(difference / 2) == int(np.sqrt(difference/2)):
number_found = True
if number_found == False:
return odd_composite
def __init__(self,
a: int,
b: int,
p: int,
order: int = None,
verify: bool = True):
self.p = p
self.a = a % p
self.b = b % p
a4 = 4 * (self.a**3)
b27 = 27 * (self.b**2)
a4b27 = a4 + b27
self.discriminant = -16 * a4b27
if verify:
assert isprime(
p), f"{p} is not prime and verify=True in curve params"
assert self.discriminant != 0, f"discriminant {self.discriminant} != 0 and verify=True in curve params"
self.j_invariant = 1728 + (a4 * modinv(a4b27, self.p))
self.card = order
from utils import primes, is_prime as isprime
from collections import defaultdict
ps = primes(10**4)[1:]
concatenable = {p: set() for p in ps}
n = len(ps)
for p in ps:
for q in ps:
if isprime(int(str(p) + str(q))):
concatenable[p].add(q)
for p in ps:
for q in concatenable[p]:
if q <= p: continue
if p not in concatenable[q]: continue
for r in concatenable[p] & concatenable[q]:
if r <= q: continue
if p not in concatenable[r] or q not in concatenable[r]: continue
for s in concatenable[p] & concatenable[q] & concatenable[r]:
if s <= r: continue
if p not in concatenable[s] or q not in concatenable[
s] or r not in concatenable[s]:
continue
for t in concatenable[p] & concatenable[q] & concatenable[
r] & concatenable[s]:
if t <= s: continue
if set([p, q, r, s]) <= concatenable[t]:
print p, q, r, s, t, p + q + r + s + t
if (j + off) % p == 0:
break
else:
res.append(i)
return res
limit = 15 * 10**7
res = 0
mods = {p: calc_mods(p) for p in primes(500)}
for n in xrange(0, limit + 1, 210):
for off in (10, 80, 130, 200):
k = n + off
possib = True
for p in mods:
if k * k > p and k % p not in mods[p]:
possib = False
break
if not possib: continue
k = (n + off)**2
ps = []
for j in range(k + 1, k + 28, 2):
if isprime(j):
ps.append(j)
if ps == [k + 1, k + 3, k + 7, k + 9, k + 13, k + 27]:
res += n + off
print res
koek_odd_even = []
for l in koek.splitlines():
koek_odd_even.append(' '.join(
['A' if int(c) % 2 == 0 else 'B' for c in l.split()]))
return '\n'.join(koek_odd_even)
koek_odd_even = []
for l in koek.splitlines():
koek_odd_even.append(['A' if int(c) % 2 == 0 else 'B' for c in l.split()])
print(koek_odd_even)
koek_prime = []
for l in koek.splitlines():
koek_prime.append(
['B' if utils.isprime(int(c)) else 'A' for c in l.split()])
print('Converted to odd/even')
for koek_msg in [koek_odd_even, koek_prime]:
print('Reading from left to right, horizontally, top to bottom')
print(''.join(koek_msg))
msg = ''.join([''.join(l) for l in koek_msg])
print(msg)
print('version1, noswap: {}'.format(
cipher.bacon_decrypt(msg, version=1, swapAB=False)))
print('version1, swap: {}'.format(
cipher.bacon_decrypt(msg, version=1, swapAB=True)))
print('version2, noswap: {}'.format(
def next_prime(n):
n += 1
while not isprime(n):
n += 1
return n
def check_number():
if not number[0]: return 0
n = int("".join(map(str, number)))
return n if isprime(n) else 0
from utils import is_prime as isprime
limit = 2000
count = 1
n = 1
while True:
if isprime(6 * n - 1) and isprime(6 * n + 1) and isprime(12 * n + 5):
count += 1
if count == limit:
print 3 * n * n - 3 * n + 2
break
if n > 1 and isprime(6 * n - 1) and isprime(6 * n + 5) and isprime(12 * n -
7):
count += 1
if count == limit:
print 3 * n * n + 3 * n + 1
break
n += 1
els = set([1])
while q:
el = heappop(q)
if el in els: continue
els.add(el)
if el * 2 <= limit:
heappush(q, el * 2)
if el * 3 <= limit:
heappush(q, el * 3)
if el * 5 <= limit:
heappush(q, el * 5)
primes = []
for el in els:
val = el + 1
if 6 <= val <= limit and isprime(val):
primes.append(val)
primes = sorted(primes)
choices = [1]
final = []
for prime in primes:
newchoices = []
for choice in choices:
if choice * prime <= limit:
newchoices.append(choice)
newchoices.append(choice * prime)
else:
final.append(choice)
choices = newchoices
#!/usr/bin/python2.7
from utils import isprime
def p(n, c):
return n*n + c
if __name__ == "__main__":
limit = 1000000
cs = (3, 7, 9, 13, 27)
print "Generating groups"
groups = [[n, p(n, 1)] for n in xrange(limit) if isprime(p(n,1))]
for c in cs:
groups = [item + [p(item[0], c)] for item in groups]
groups = filter(lambda x: isprime(x[-1]), groups)
print "Filter: ", len(groups)
print "Suma: ", sum(cs)
"""
Project Euler Problem 7
=======================
By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see
that the 6th prime is 13.
What is the 10001st prime number?
"""
from utils import isprime
INDEX = 10001
nprimes = 0
i = 1
while True:
if isprime(i):
nprimes += 1
if nprimes == INDEX + 1:
break
i += 1
print i
def prime_(x, y):
return utils.isprime(x) or utils.isprime(y)
def get_cache_size(block_number):
sz = CACHE_BYTES_INIT + CACHE_BYTES_GROWTH * (block_number // EPOCH_LENGTH)
sz -= HASH_BYTES
while not isprime(sz / HASH_BYTES):
sz -= 2 * HASH_BYTES
return sz
