def main():
summa = 0
for num in range(1,150000001):
arr_num = []
arr_const = [1,3,7,9,13,27]
#List to hold all possible values
for i in arr_const:
var = ((num**2)+i)
if(sp.isprime(var)):
arr_num.append(var)
count = len(arr_num)
#Number of primes between two numbers
count_prime = 0
for k in range((num**2)+1,(num**2)+27+1):
if(sp.isprime(k)):
count_prime += 1
if(count == 6):
if(count == count_prime):
print num
summa += num
print "Total : " + str(summa)
def euler58():
cnt = 1
prime_cnt = 0
n = 2
while True:
prime_cnt += isprime(4 * n * n - 10 * n + 7)
prime_cnt += isprime(4 * n * n - 8 * n + 5)
prime_cnt += isprime(4 * n * n - 6 * n + 3)
cnt += 4
if prime_cnt * 1.0 / cnt < 0.1:
return n * 2 + 1
n += 1
def keycreation(p, q, e):
n = p * q
# check p, q are primes
if not(isprime(p) and isprime(q)):
raise Exception('p, q are not primes')
# check gcd(e, (p-1)(q-1))=1
if (gcd(e, (p-1) * (q-1)) == 1):
return (n, e)
else:
raise Exception('Improper e')
def check_trucations(n):
number_digits = digits(n)
for x in range(1, len(number_digits)):
truncation1 = number_digits[x:]
truncation2 = number_digits[:len(number_digits) - x]
number1 = digits_to_int(truncation1)
number2 = digits_to_int(truncation2)
if (not sympy.isprime(number1)) or (not sympy.isprime(number2)):
return False
return True
def golbach_other():
i = 7
while True:
i = i+2
if isprime(i):
continue
max_j = int(math.sqrt(i/2))
g = False
for j in range(1,max_j+1):
if isprime(i - 2*j*j):
g = True
break
if not g:
return i
def verifie_paire_debug(A, B):
"""Version plus lente qui fait tous les tests, et affiche vrai ou faux pour chaque somme a + b."""
if A is None or B is None:
return False
reponse = True
for a in A:
if not isprime(a):
print(" - a = {:<6} est pas premier, ECHEC ...".format(a))
reponse = False
for b in B:
if not isprime(a + b):
print(" - a = {:<6} + b = {:<6} donnent {:<6} qui n'est pas premier, ECHEC ...".format(a, b, a + b))
reponse = False
else:
print(" - a = {:<6} + b = {:<6} donnent {:<6} qui est bien premier, OK ...".format(a, b, a + b))
return reponse
def calc_some(p):
if p <= 5:
raise ValueError("p must be larger than 5")
if not sympy.isprime(p):
raise ValueError("specify prime. actual p = {}, ntheory.divisors = {}".format(p, ntheory.divisors(p)))
r = reciprocal(p)
seq = calc_recurrence_seq(p)
d = len(seq)
former = r[:d // 2]
latter = r[d // 2:d]
if d % 2 == 0:
print('length of recurrence is even')
print('1/{} = '.format(p), r)
print('former = ', former)
print('latter = ', latter)
print('former + latter =\n', Decimal(former) + Decimal(latter))
else:
print('length of recurrence is not even. In fact')
print('1/{}'.format(p), r)
print('seq = ', seq)
print('len(seq) = ', len(seq))
print('But you may find something')
if latter[0] == 9:
print("you're lucky")
print('former = ', former)
print('latter = ', latter)
print('former + latter =\n', Decimal(former) + Decimal(latter))
def odd_composite_gen():
"""infinite generator of composite numbers"""
x = 3
while 1:
x += 2
if not isprime(x):
yield x
def main():
summa = 0
for i in range(1,2000001):
if(sp.isprime(i)):
summa += i
print summa
def quadResidue(p):
#Check whether p is prime and odd
if(not sp.isprime(p)):
return "~"
if(p%2==0):
return "~"
#This are the variables storing outputs
quadR=[]
quadNR=[]
#Making array S with numeral count 1 to (p-1)/2
S=[]
#This iss the loop process for making S when a=1
for j in range(1,int((p-1)/2)+1):
S.append(j)
#This operation is required for
#numpy based functionalities
S=np.array(S)
#Iterating for each a less than p, greater than 1
for a in range(1,p):
SNew=S*a #Makes life easy, as we can make S with any a
SNew%=p #Left reminders
n=0 #Count of remainders greater than p/2
#For the count of n, so to get the power
for i in range(len(SNew)):
if(SNew[i]>(p/2)):
n+=1
#Lengndre symbol operation
if((-1)**n==1):
quadR.append(a)
else:
quadNR.append(a)
return[quadR,quadNR]
def prove_factorial_divides_by_n_primes(n):
''' Always returns True because a factorial
is divisible by the all primes below n
by definition'''
return all(imap(lambda x, y: x % y == 0,
repeat(factorial(n)),
[y for y in range(1, n) if isprime(y)]))
def replaced_is_prime(n, replace):
n = str(n)
res = 0
for i in range(replace, 10):
if isprime(int(n.replace(str(replace), str(i)))):
res += 1
return res
def solve():
for i in range(len(digits)):
for p in permutations(digits[i:]):
x = int(''.join(p))
if isprime(x):
return x
return -1
def is_goldbach_composite(n):
if isprime(n):
return True
for prime in sieve.primerange(1, n):
for ds in double_squares(n):
if prime + ds == n:
return True
return False
def is_goldbach(n):
"""can n can be written as the sum of a prime and twice a square?"""
for s in sq2:
if s >= n:
break
if isprime(n - s):
return True
return False
def main():
count = 0
for i in range(0,1000000):
if(sp.isprime(i)):
count += 1
if(count == 10001):
print i
break
def isQuadraticResidue(p, a):
if isprime(p):
if a ** ((p - 1) / 2) % p == 1:
return True
else:
return False
else:
return "N not a prime"
def pandigital_prime():
max_p = 0
for n in range(1,10):
all_digits = [str(i) for i in range(1,n+1)]
for perm in permutations(all_digits):
p = int("".join(perm))
if isprime(p):
max_p = max(p, max_p)
return max_p
def truncatables_primes():
count =0
s = 0
last_prime = 7
while count<11:
prime = nextprime(last_prime)
prime_str = str(prime)
is_cool = True
for i in range(1,len(prime_str)):
p1 = int(prime_str[i:])
p2 = int(prime_str[:-i])
if not (isprime(p1) and isprime(p2)):
is_cool = False
if is_cool:
count = count +1
s = s+prime
last_prime = prime
return s
def rand_prime(min_, max_):
'''get a random prime between two numbers'''
p = math.floor(random.random() * ((max_ - 1) - min_ + 1)) + min_
if sympy.isprime(p):
print(p, 'is prime')
return p
else:
print(p, 'is not prime')
return rand_prime(min_, max_)
def grid(x, y):
if x < 0 and y < 1:
raise IndexError
#exceed row length
if x >= y:
raise IndexError
n = (2 - y + y * y) / 2 + x
if not isprime(n):
raise IndexError
return n
def prochaine_date_premiere(date=datetime.today(), conversion=date_vers_nombre):
year = date.year
un_jour = timedelta(days=1)
for i in range(0, 366):
if isprime(conversion(date)):
return date
date += un_jour
if date.year > year: # On est allé trop loin
return None
return None
def verifie_paire(A, B):
"""Version efficace, qui s'arrête le plus tôt possible."""
if A is None or B is None:
return False
for a in A:
# if not isprime(a): # Inutile car A aura été bien choisi
# return False
for b in B:
if not isprime(a + b):
return False
return True
def is_composite(n):
"""Is a number composite
>>> is_composite(1)
False
>>> is_composite(4)
True
>>> is_composite(5)
False
"""
return (n>1) and not isprime(n)
def replace_repeats(digit, length, replacements):
digit = str(digit)
rngs = [list("0123456789") for x in range(replacements)]
for combi in itertools.combinations(range(length), replacements):
for x in itertools.product(*rngs):
s = list(digit * length)
for place_no, place in enumerate(combi):
s[place] = x[place_no]
s = ''.join(s)
if s[0] != "0" and isprime(int(s)):
yield int(s)
def main():
count = 0
arr = []
for i in range(1,1000000,2):
if(sp.isprime(i) == True):
summa = 0
length = len(str(i))
for j in range(0,length):
if(sp.isprime(i) == True):
summa += 1
i = cirShift(i)
if(summa == length):
count += 1
if(sp.isprime(i) == True):
arr.append(i)
#Adding one because 2 is also a circular prime number
print len(list(set(arr)))+1
def apply(self, n, evaluation):
'PrimeQ[n_]'
n = n.get_int_value()
if n is None:
return Symbol('False')
n = abs(n)
if sympy.isprime(n):
return Symbol('True')
else:
return Symbol('False')
def factorize(n):
factors = []
if sympy.isprime(n):
return [n]
for i in range(2, n // 2 + 1):
if n % i == 0:
factors.append(int(i))
factors.append(int(n / i))
break
for num in factors:
factors += factorize(num)
factors = list(set(factors))
return sorted(factors)
def from_q(q) -> Field:
if isprime(q):
return PrimeField(q)
if q == 4:
return F4()
if q == 32:
return F32()
p = int(q**0.5)
if p * p == q:
return SquareExtensionField.from_base_field(
FieldFromInteger.from_q(p))
else:
raise NotImplementedError()
def find_e(p, q, fi):
e = 17
#i = 10 ** 2
#while i < fi:
if isprime(e) and (gcd(e, p - 1) == gcd(e, q - 1) == 1):
if len(list(pyecm.factors(e, False, True, 8, 1))) == 1:
#e = i
#break
return e % fi
else:
#i += 1
e += 1
return e % fi
def p122(n):
m = [0, 1, 1, 2]
for i in range(4, n+1):
if isprime(i):
m.append(min(m[j] + m[i-j] for j in range(1, i)))
else:
f = factorint(i)
m.append(min(sum(m[k] * f[k] for k in f), \
min(m[j] + (m[i-j] if j != i - j else 1) \
for j in range(1, i))))
for i in range(1, n+1):
print(m[i])
return sum(m[i] for i in range(1, n+1))
def test_high_prime(self):
i = 0
done = set()
while i!=10:
s = smp.randprime(2**200, 2**210)
ans = high_primal_test(s)
if ans == s:
done.add(s)
i+=1
else:
self.assertEqual(1, 0)
for x in done:
self.assertTrue(smp.isprime(x))
def check(x):
for base in xrange(2, 11):
v = 0
b = 1
t = x
while t > 0:
if t % 2 == 1:
v += b
b *= base
t /= 2
if sympy.isprime(v):
return False
return True
def require_prime(names, variables):
out = ""
for k, l in zip(names, variables):
F = isprime(l)
if not F:
out += f"{k} is not prime\n"
if out != "":
raise TypeError(out)
return True
def main():
spirals = spiral_numbers()
prime_spirals = {True: [], False: []}
side_length = -1
while True:
# Throttle the infinite iterator so we can assess it in bits
next4 = (next(spirals) for _ in range(4))
for length, i in next4:
prime_spirals[isprime(i)].append(i)
side_length = length
if len(prime_spirals[True]) * 9 <= len(prime_spirals[False]):
print('Side length at cutoff point is {}'.format(side_length))
return 0
def main(N):
# print('N = %s' % N)
if abs(int(sqrt(N)) - sqrt(N)) < 1e-10:
f1, f2, fail_count = int(sqrt(N)), int(sqrt(N)), 0
elif not sympy.isprime(N):
f1, f2, fail_count = factor(N, 0)
else:
# print('Prime number detected. Stopping...')
return False
print('%s can be factored by %s and %s' % (f1 * f2, f1, f2))
print('Fails:\t%s' % fail_count)
return fail_count
def p058(l):
getidx = lambda x, i: [x + 2 * i * j for j in range(1, 5)]
i, idx = 0, [1]
numerator, denominator, r = 0, 1, 1
while r > l:
i += 1
idx = getidx(idx[-1], i)
numerator += sum(1 for i in idx if isprime(i))
denominator += 4
r = numerator / denominator
return 2 * i + 1, '{:.5%}'.format(r)
def get_pernicious(what: int) -> list:
"""Get the pernicious numbers"""
nums: list[int] = []
num = 0
while len(nums) < what:
num += 1
bin_num = f"{num:b}"
bin_num = re.sub("0", "", bin_num)
if isprime(len(bin_num)):
nums.append(num)
return nums
def phi_of_n(n):
#totient coefficient or Euiler's phi value calculation
a = 1
if n == 1:
pass
elif sp.isprime(n) == True:
a = n - 1
else:
dnum = factorization_of_n(n)
for key in dnum.keys():
a = a * (key**dnum[key] - key**(dnum[key] - 1))
print("phi of {} = {}".format(n, a))
def large_DL_Prime(q, bitsize):
warnings.simplefilter('ignore')
chck = False
chck2 = False
while (chck == False) or (chck2 == False):
chck = False
chck2 = False
k = random.randrange(2**(bitsize - 1), 2**bitsize - 1)
p = k * q + 1
chck = sympy.isprime(p)
chck2 = (p.bit_length() == 2048)
warnings.simplefilter('default')
return p
def legandre_calc(s, p):
if s >= p or s < 0:
return legandre_calc(s % p, p)
elif s == 0 or s == 1:
'''
0mod(p) = 0;
1mod(p) = 1
'''
return s
elif (s**(1 / 2)).is_integer():
'''
if x = s**2 and s > 1 , L(s) == 1
'''
return 1
elif s == 2:
'''
2/p = [1: (p = 8m+1, p = 8m+7); -1: (p = 8m+3, p = 8m+5)]
'''
if p % 8 == 1 or p % 8 == 7:
return 1
else:
return -1
elif s == p - 1:
'''
(-1)/p = [1: p = 4m+1; -1: p = 4m+3]
'''
if p % 4 == 1:
return 1
else:
return -1
elif isprime(s) == False:
factors = factorize(s)
product = 1
for pi in factors:
product *= legandre_calc(pi, p)
return product
else:
'''
a < p
a/p = (p/a)*(-1)**((p-1/2)*((a-1)/2))
TODO prevent self.p overwriting
'''
if ((p - 1) / 2) % 2 == 0 or ((s - 1) / 2) % 2 == 0:
return legandre_calc(p, s)
else:
return (-1) * legandre_calc(p, s)
def safe_prime(bits=512):
"""Generate a safe prime that is at least 'bits' bits long. The result
should be greater than 1 << (bits-1).
PARAMETERS
==========
bits: An integer representing the number of bits in the safe prime.
Must be greater than 1.
RETURNS
=======
An interger matching the spec.
"""
print("safe_prime bits:", bits)
assert bits > 5 # this algorithm likely breaks for small numbers of bits
# do a linear search
maximum = 1 << (bits - 1)
q = randbits(bits - 1) | (1 << (bits - 2)) # guarantee the high bit is set
q += 5 - (q % 6) # make it 5 (mod 6)
while True:
# sieve out some known-bad values
for i, r in enumerate(prime_list):
if (q % r) == prime_avoid[i]:
break
else:
if isprime(q):
cand = (q << 1) + 1
if isprime(cand):
return cand
q += 6 # ensure it's always 5 (mod 6)
if q >= maximum:
q = (1 << (bits - 2)) + 1
q += 5 - (q % 6) # reset this back to where we expect
def recover_privkey_helper(pubkey, keysize, keyparams):
print('[*] [RSA-%d] Finding the prime number p...' % keysize)
n_bytes = util.to_bytes(pubkey.n)
kp_keysize = keysize // 2
kp_pubkey = RSA.importKey(keyparams.get_pubkey(kp_keysize))
kp_r2_bytes = base64.b64decode(keyparams.get_r2(kp_keysize))
kp_r2 = util.to_number(kp_r2_bytes)
kp_privkey = RSA.importKey(keyparams.get_privkey(kp_keysize))
encrypted_p_xor_r1_xor_r2 = n_bytes[0:len(kp_r2_bytes)]
original_kp_r1_bytes = base64.b64decode(keyparams.get_r1(kp_keysize))
for i in range(0, 0xffffff):
kp_r2_bytes = util.to_bytes(kp_r2)
encrypted_p_xor_r1 = bytes_xor(encrypted_p_xor_r1_xor_r2, kp_r2_bytes)
p_xor_r1_bytes = util.rsa_decrypt(kp_privkey,
bytes(encrypted_p_xor_r1))
kp_r1 = util.to_number(original_kp_r1_bytes)
for j in range(0, 0xa):
for k in range(0, 0xa):
kp_r1_bytes = util.to_bytes(kp_r1)
p_bytes = bytes_xor(p_xor_r1_bytes, kp_r1_bytes)
p = util.to_number(p_bytes)
util.print_message('[RSA-%d] [%d:%d:%d] %d' %
(keysize, i, j, k, p))
if sympy.isprime(p) and sympy.isprime((p - 1) // 2):
privkey = util.rsa_construct_private_key(p, pubkey)
if privkey:
print('\n[+] [RSA-%d] p = %d' % (keysize, p))
print('[+] [RSA-%d] Private key is recovered' %
keysize)
return privkey
kp_r1 += 1
kp_r1 = permute_r_key(kp_r1, keysize)
kp_r2 += 1
print('\n[-] [RSA-%d] Cannot recover the private key' % keysize)
return None
def gen_trunc():
ends = [2, 3, 5, 7]
mid = [1, 3, 7, 9]
while ends:
prime = ends.pop(0)
# this checks for the front truncatable primes, and adds them to the ends list for possible ends
for digit in mid:
temp = prime * 10 + digit
if sympy.isprime(temp):
ends.append(temp)
# if it is back truncatable as well, then we add it to temp as well
if truncate_back(temp):
trunc.append(temp)
return trunc
def factorize(n):
base = {}
n, k = utils.fac2k(n)
if k > 0:
base[2] = k
while n > 1:
divisor = factorization.ppollard(n) if not sympy.isprime(n) else n
if divisor is None:
raise ValueError('Ошибка при факторизации')
if divisor not in base:
base[divisor] = 0
base[divisor] += 1
n //= divisor
return base
def calculateQ(p):
# Generates a 'q'
counter = 0
q = random.randint((2**159) + 1, (2**160) - 1)
while (not sympy.isprime(q) or (p - 1) % q != 0):
q = random.randint((2**159) + 1, (2**160) - 1)
counter = counter + 1
if (counter == ((2**160) - 1) - ((2**159) + 1)):
return None
return q
def safeprime():
bits = 512
maximum = 1 << bits
q = secrets.randbits(bits - 1) | (1 << (bits - 2))
if (q != 2): # rule out even numbers, excluding 2
q |= 1
while True: #check if entire range has been exhausted
if sympy.isprime(q):
cand = (q << 1) + 1
if sympy.isprime(cand):
return cand
if q == 2: # rule out even numbers, special-casing 2
q = 3
else:
q += 2
if q >= maximum:
q = 1 << (bits - 2)
def solve():
def prime_gen():
n = 1
while True:
yield (n := nextprime(n))
for i in prime_gen():
for d in map(str, range(10)):
if (x := str(i)).count(d) >= 3:
it = iter(
isprime(y) for j in range(10)
if (y := int(x.replace(d, str(j)))) >= i)
if all(map(any, repeat(iter(it), 8))):
return i
def get_max_n(a: int, b: int, primes_found: Set[int]) -> int:
"""
:param a: a of the formula
:param b: b of the formula
:param primes_found: set of already found primes to prevent repeated computations
:return: number of consecutive primes
"""
n: int = 0 # n is also counter
f: int = apply_quadratic(n, a, b)
while f in primes_found or isprime(f):
primes_found.add(f)
n += 1
f = apply_quadratic(n, a, b)
return n
def solution():
side_length = 1
diagonal_count = 1
prime_count = 0
while True:
side_length += 2
corner_vals = corner_values(side_length)
for cv in corner_vals:
if sympy.isprime(cv):
prime_count += 1
diagonal_count += 4
prime_ratio = prime_count / float(diagonal_count)
if prime_ratio < 0.1:
return side_length
def permutationPrimes(string):
permutations = []
primeSet = set()
for i in range(1, len(string) + 1):
left = int(string[0:i])
if isprime(left):
generatePerms(string, i, permutations, [left])
print('print sets')
for permset in permutations:
print(permset)
return permutations
def check(self, f):
# http://cms.dm.uba.ar/academico/materias/2docuat2011/teoria_de_numeros/Irreducible.pdf
# Theorem 1
h = 0
for exp, coeff in poly_non_zero_exps(f):
if exp != f.degree():
h = max(h, abs(coeff / f.LC()))
nmin = int(math.ceil(h + 2))
for n in range(nmin, nmin + 5):
val = f.eval(n)
if sympy.isprime(val) and (not self.max_p or val < self.max_p):
return IRREDUCIBLE, {'n': n, 'p': val}
return UNKNOWN, None
def jamcoin(digits):
jam = 0
jam_list = []
jam_string = ""
for i in range(0, digits):
jam_list += str(random.randint(0, 1))
jam_list[0] = '1'
jam_list[len(jam_list) - 1] = '1'
for i in jam_list:
jam_string += i
jam = int(jam_string)
convert = jam
temp = []
result = 0
divisors = []
for base in range(2, 11):
for i in range(0, len(str(jam))):
convert = int(str(jam)[len(str(jam)) - i - 1])
convert = convert * base**i
temp.insert(0, convert)
for i in temp:
result += i
if (isprime(result)):
return jamcoin(digits) #If test fails try again
for i in range(2, 300000):
if (result % i == 0):
divisors.append(i)
break
if (i == 300000 - 1):
return jamcoin(digits)
#divisors.append(result)
convert = jam
temp = []
result = 0
jam = str(jam)
for i in divisors:
jam += " " + str(i)
return jam #If test succeeds return
def is_prime_check(n: int, primes_checked: Dict[int, bool]):
"""
smart prime check to prevent repeated calculations
:param n: the number to check if prime
:param primes_checked: all of the already checked numbers
:return: True if n is prime
"""
if n in primes_checked:
return primes_checked[n]
if isprime(n):
primes_checked[n] = True
return True
primes_checked[n] = False
return False
def find_coef():
''' Check all valid combinations of coefficients and find number of
consecutive primes produced by each combination '''
max_prime = 0
coef = []
for a in range(-999, 1000):
for b in range(1001):
n = 0
while isprime(n**2 + a * n + b):
n += 1
if n > max_prime:
max_prime = n
coef = [a, b]
return coef
def pi(n):
n = np.floor(n).astype(int)
if isinstance(n,(list,np.ndarray)):
out = []
for cur_num in n:
out.append(sp.primepi(cur_num))
return out
else:
out=0
for x in range(1,n):
if sp.isprime(x):
out+=1
return out
def check_chess_jumpers(t): # table
chess_jumper_moves = [(-1, 2), (1, 2), (2, 1), (2, -1),
(1, -2)] # idę w dół żeby nie robić powtórek
for i in range(len(t)):
for j in range(len(t)):
for x, y in chess_jumper_moves:
if i + x >= 0 and i + x < len(
t) and j + y >= 0 and j + y < len(t):
if isprime(t[i][j] + t[i + x][j + y]):
return True
return False
# print(check_chess_jumpers(t))
def get_nr_primes(what):
""" Calculate and return the number of primes needed """
# if the number is prime, we need just 1 number to represent it
if isprime(what):
return 1
# if the number is even, we need 2 primes thanks to Goldbach's conjecture
if what % 2 == 1:
return 2
# if the number - 2 is prime, return 2
if isprime(what - 2):
return 2
# if the number -3 is prime, return 2 (3 and the prime)
if isprime(what - 3):
return 2
# otherwise return 3 - it is 3 and 2 primes forming $what - 3 thanks to
# Goldbach's conjecture
return 3
def singlePrimes(limit=2*10**9):
print("All numbers <", limit, ":")
TSingle = time.time()
primes = set()
for x in xrange(1, int(limit**.5) + 1, 2):
x2 = x**2
for y in xrange(4, limit, 4):
quad = x2 + 7*y*y
if quad > limit:
break
if quad % 168 in {1, 25, 121}:
if isprime(quad):
primes.add(quad)
print("Single primes:", len(primes), "in", time.time() - TSingle,"seconds")
return primes
def apply(self, n, evaluation):
'PrimeQ[n_]'
n = n.get_int_value()
if n is None:
return Symbol('False')
n = abs(n)
if sympy.isprime(n):
return Symbol('True')
else:
return Symbol('False')
# old variant using gmpy
"""count = 25
