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