def checkDSparams(q, p, g): warnings.simplefilter('ignore') check = pyprimes.isprime(q) warnings.simplefilter('default') if check == False: return -1 warnings.simplefilter('ignore') check = pyprimes.isprime(p) warnings.simplefilter('default') if check == False: return -2 r = (p - 1) % q if (r != 0): return -3 k = (p - 1) // q x = pow(g, k, p) if (x == 1): return -4 y = pow(g, q, p) if (y != 1): return -4 return 0
def main(): for number in count(start=101, step=2): number = '0' + str(number) zero_digit_cnt = str(number).count('0') if zero_digit_cnt > 0: zero_digit_list = [] for idx, c in enumerate(str(number)): if c == str('0'): zero_digit_list.append(idx) for replace_cnt in range(1, zero_digit_cnt + 1): for zero_idx_comb in combinations(zero_digit_list, replace_cnt): non_family_cnt = 0 translated_num = number for digit in range(0, 10): for idx in zero_idx_comb: translated_num = str(translated_num)[0:idx] + str( digit) + str(translated_num)[idx + 1:] # print('--- before {} after translated {}'.format(number,translated_num)) if not isprime(int(translated_num)): non_family_cnt += 1 if non_family_cnt > 10 - FAMILY_CNT: break if non_family_cnt == 10 - FAMILY_CNT: print('we found eight prime family {}'.format(number)) translated_num = number for digit in range(0, 10): for idx in zero_idx_comb: translated_num = str( translated_num)[0:idx] + str(digit) + str( translated_num)[idx + 1:] if isprime(int(translated_num)): print('the smallest prime of it is {}'.format( translated_num)) return
def fitsAssumption(num): if num-2 == 1 or pyprimes.isprime(num-2): return True for squareNum in squares(num): # print squareNum*2 if pyprimes.isprime(num-2*squareNum): return True return False
def main(): n = 1489 while True: b, c = n + 3330, n + 3330 * 2 if isprime(n) and isprime(b) and isprime(c) \ and is_perm(n, b) and is_perm(b, c): break n += 2 print str(n) + str(b) + str(c)
def prime_group_good(prime_set: FrozenSet[EnumeratedPrime]) -> bool: global BADPAIRS ret = True for prime1, prime2 in itertools.combinations(prime_set, 2): if not (isprime(int(str(prime1.prime) + str(prime2.prime))) and isprime(int(str(prime2.prime) + str(prime1.prime)))): BADPAIRS.add(frozenset((prime1.index, prime2.index))) ret = False print(BADPAIRS) return ret
def main(): n_prime, d, prime_ratio, n = 0, 1, 1, 2 while prime_ratio >= 0.10: n_prime += isprime(d + n) + isprime(d + n*2) + isprime(d + n*3) d += n * 4 n += 2 prime_ratio = float(n_prime) / (2 * n) print n-1
def main(): for i in count(3, 2): if not isprime(i): for j in count(1): twice_square = 2 * j * j if twice_square >= i: print('we found a special number {}'.format(i)) return True else: if isprime(i - twice_square): break
def checkRight(number): number = str(number) while len(number) > 1: if pyprimes.isprime(int(number)) != True: # check to make sure number is still prime return False # return False because number is not still prime, therefore not a truncatable prime else: number = number[:-1] # remove far right digit if pyprimes.isprime(int(number)) == True: return True else: return False
def get_prime_repl_count(p, index_subset): if index_subset == []: if pyprimes.isprime(int(p)): return 1 else: return 0 count = 0 for replacement_digit in ['0','1','2','3','4','5','6','7','8','9']: p_replaced = int(replace_digits(str(p), index_subset, replacement_digit)) if pyprimes.isprime(p_replaced) and (len(str(p_replaced)) == len(str(p))): count += 1 return count
def prime_perms(): for i in range(N): for j in range(i+1, N): a, b = four_primes[i], four_primes[j] c = 2*b - a if set(str(a)) == set(str(b)) == set(str(c)) and pp.isprime(c): print a, b, c
def findEulerTotient(n): if (pyprimes.isprime(n)): return n - 1 et = n for (prime, power) in pyprimes.factorise(n): et *= (1 - 1.0 / prime) return et
def main(): prime_list = list(primes_below(UPPER_LIMIT)) prime_list_len = len(prime_list) consecutive_len = 0 # find the longest possible len, which sum is below 1 million for consecutive_len in count(1): if sum(prime_list[:consecutive_len - 1]) > UPPER_LIMIT: break while consecutive_len > 0: i = 0 sum_now = sum(prime_list[i:i + consecutive_len]) while i + consecutive_len < prime_list_len: if sum_now > UPPER_LIMIT: break else: if isprime(sum_now): print('found max consecutive primes sum {}'.format( \ sum_now \ )) return sum_now = sum_now - prime_list[i] + prime_list[i + consecutive_len] i += 1 consecutive_len -= 1
def DL_Param_Generator(small_bound, large_bound): s = small_bound.bit_length() l = large_bound.bit_length() q = generateLargePrime(s) while q == -1: q = generateLargePrime(s) p = 1 while not (pyprimes.isprime(p) and p.bit_length() == l): r = random.getrandbits(l - s) p = q * r + 1 if p.bit_length() == l - 1: p = q * (r << 1) + 1 elif p.bit_length() == l + 1: p = q * (r >> 1) + 1 h = 2 g = 1 while g == 1: g = pow(h, (p - 1) / q, p) h += 1 #F=open("DSA_params.txt", 'w') #F.write(str(q)+'\n'+str(p)+'\n'+str(g)+'\n') #F.close() return (q, p, g)
def random_prime(bitsize): warnings.simplefilter('ignore') chck = False while chck == False: p = random.randrange(2**(bitsize - 1), 2**bitsize - 1) chck = pyprimes.isprime(p) warnings.simplefilter('default') return p
def main(): primes = [] # circular primes for i in xrange(1, 1000000): if False not in [isprime(x) for x in circular(i)]: primes.append(i) #print primes print len(primes)
def getSumOfSquares(n): sumOfDivisorSquares = 1 if (pyprimes.isprime(n)): sumOfDivisorSquares = 1 + n * n return sumOfDivisorSquares for (prime, power) in pyprimes.factorise(n): sumOfDivisorSquares *= (prime**(2 * power + 2) - 1) / (prime**2 - 1) return sumOfDivisorSquares
def circular_primes(candidate: int): """Return the set of circular primes of i.""" candidates = circular_shifts(candidate) for shift in candidates: if (not isprime(shift)): return empty_set return candidates
def Param_Generator(): n_p = 3072 n_q = 256 while True: q = random.randint(0, 2**n_q) q = q | 1 if pyprimes.isprime(q) == True: break print('q: ', q) while True: k = random.randint(0, 2**(n_p-n_q)) p = q * k + 1 if pyprimes.isprime(p): break print('p: ', p) return (p, q)
def main(): #primes = [x for x in range(3, 501) if isprime(x)] firstGroup = sum([x for x in range(3, 101) if isprime(x)]) secondGroup = 0 for i in range(100, 201): digits = [int(x) for x in str(i) if isprime(i)] if digits: secondGroup += reduce(mul, digits) thirdGroup = sum([((x * secondGroup) - firstGroup) for x in range(200, 301) if isprime(x)]) fourthGroup = sum([thirdGroup - (x ** 2) for x in range(300, 401) if isprime(x)]) fifthGroup = sum([sum([int(x) for x in str(x)]) for x in range(400, 501) if isprime(x)]) print firstGroup, print secondGroup, print thirdGroup, print fourthGroup, print fifthGroup,
def main(): n, primes, total = 12, 8, 13 while primes * 100 / total >= 10 or n % 4 > 0: n += 1 if pyprimes.isprime(1 + sum([8 * (k + 1) for k in xrange(n / 4)]) + n % 4 * 2 *(n / 4 + 1)): primes += 1 total += 1 print 1 + 2 * ((n - 1) / 4 + 1)
def generate_primes(bits=100): generator = secrets.SystemRandom() primes = [] while len(primes) < 2: number = generator.randint(2**bits, 2**(bits + 1) - 1) if isprime(number) and number not in primes: primes.append(number) return primes
def random_prime(bound): warnings.simplefilter('ignore') chck = False while chck == False: p = random.randrange(1, bound) if check_small_primes(p) == 1: chck = pyprimes.isprime(p) warnings.simplefilter('default') return p
def large_DL_Prime(q, bitsize): warnings.simplefilter('ignore') chck = False while chck == False: k = random.randrange(2**(bitsize - 1), 2**bitsize - 1) p = k * q + 1 chck = pyprimes.isprime(p) warnings.simplefilter('default') return p
def quickAnswer(numPrime): start = time.time() counter = 1 numToCheck = 3 while counter != numPrime: if pyprimes.isprime(numToCheck): counter += 1 numToCheck += 1 return '{} is the 10001st prime, found in {} seconds.'.format(numToCheck - 1, time.time() - start)
def main(): pans = pandigital(7) #print pans max_prime = 0 for pan in pans: #print pan if isprime(pan) and max_prime < pan: max_prime = pan print max_prime
def barck_zhishu(): r = random.randint(100, 200) while True: s = int(str(r)[-1]) if s % 2 == 0: r = r + 1 if pyprimes.isprime(r): return r else: r = r + 1
def main(): primes = [] # Truncatable primes cnt = 1 while True: if cnt < 800000: left = left_truncatable(cnt) right = right_truncatable(cnt) #zero = not_zero(cnt) if False not in [isprime(x) for x in left] \ and False not in [isprime(x) for x in right] \ and len(str(cnt)) > 0: primes.append(cnt) cnt += 1 else: break primes = primes[4:] primes = [x for x in primes if not_zero(x) == True] #print primes #print len(primes) print sum(primes)
def main(): prime_cnt = 0 diagonal_cnt = 1 for level in count(1): diagonal_cnt += 4 for number in prime_diagonal_cnt(level): if isprime(number): prime_cnt += 1 if diagonal_cnt > 10*prime_cnt: print(level*2+1) exit(0)
def findCoPrimeNos(n): if (pyprimes.isprime(n)): coPrimeNos = [num for num in xrange(1, n)] return coPrimeNos primeFactors = pyprimes.factors(n) coPrimeNos = [ num for num in xrange(1, n) if (not checkDivisibleAny(num, primeFactors)) ] return coPrimeNos
def is_valid(self): self.d = odict() res = True for base in range(2, 11): kb = self.inbase(base) if pyprimes.isprime(kb): res = False break else: self.d[base] = pyprimes.factorise(kb).next()[0] return res
def __get_prime(self, rank): m = 1 this_rank = -1 while True: L = 4 * m + 1 if pyprimes.isprime(L): this_rank += 1 if this_rank == rank: break m += 1 return L
def Param_Generator(qbound, pbound): while True: q = random.randint(0, qbound) q = q | 1 if pyprimes.isprime(q) == True: break while True: k = random.randint(0, pbound-qbound) p = q * k + 1 if pyprimes.isprime(p): break alpha = random.randint(0, p) while True: g = pow(alpha, (p-1)//q, p) if g != 1: break print('g: ', g) return q, p, g
def check_has_pair(prime): result = [] digits = str(prime) if len(digits) < 2: return None for d in range(len(digits) - 1): p1 = digits[:d + 1] p2 = digits[d + 1:] if p1[0] == '0' or p2[0] == '0': continue if pyprimes.isprime(int(p1)) and pyprimes.isprime( int(p2)) and pyprimes.isprime(int(str(p2) + str(p1))): result.append([int(p1), int(p2)]) return result
def create_sociable_numbers(num): """There are some bags in this function. >>>create_sociable_numbers(5) >>>[]""" if isprime(num): return list() chain = list() chain.append(num) while True: if isprime(num): return list() sum_prodiv = sum_proper_divisors(num) # sum of proper divisors if sum_prodiv not in chain: chain.append(sum_prodiv) #num = sum_prodiv else: break num = sum_prodiv if is_perfect(num): return list() return chain
def generate_number_list(lowerbound=2, upperbound=10): ''' Generate a list of Number objects ''' number_list = [] for value in range(lowerbound, upperbound + 1): if pp.isprime(value) and not include_primes: continue number = Number(value=value) number_list.append(number) return number_list
def main(): prime_pair = dict() existing_set = dict() PAIR_COUNT = 5 for single_prime in primes(): # split prime into char combinations str_prime = str(single_prime) for break_pos in range(1, len(str_prime)): left = int(str_prime[:break_pos]) right = int(str_prime[break_pos:]) if left != 0 and right != 0 and isprime(left) and isprime( right) and left != right: if int(str(right) + str(left)) < single_prime: continue if isprime(int(str(right) + str(left))): # put this two prime pair into cache # and left is definitely smaller than right if left not in existing_set: existing_set[left] = list() existing_set[left].append(list({right})) else: for idx, single_set in enumerate(existing_set[left]): for prime in single_set: if not isprime( int(str(right) + str(prime))) or not isprime( int(str(prime) + str(right))): break else: existing_set[left][idx].append(right) if len(existing_set[left] [idx]) == PAIR_COUNT - 1: existing_set[left][idx].append(left) return existing_set[left][idx] existing_set[left].append(list({right})) if right not in existing_set: existing_set[right] = list() existing_set[right].append(list({left})) else: for idx, single_set in enumerate(existing_set[right]): for prime in single_set: if not isprime( int(str(left) + str(prime))) or not isprime( int(str(prime) + str(left))): break else: existing_set[right][idx].append(left) if len(existing_set[right] [idx]) == PAIR_COUNT - 1: existing_set[right][idx].append(right) return existing_set[right][idx] existing_set[right].append(list({left}))
def main(): greatest_prime = 0 for n in range(9, 1, -1): digit_array = [str(i) for i in range(1, n + 1)] for number in permutations(digit_array, n): number = int(''.join(number)) if isprime(number): if greatest_prime < number: greatest_prime = number if greatest_prime > 0: print 'the largest n-digit prime is {}'.format(greatest_prime) break
def DL_Param_Generator(small_bound, large_bound): #Parameter Generation q = 0 p = 0 while (True): q = bitGenerator(small_bound) warnings.simplefilter('ignore') check = pyprimes.isprime(q) warnings.simplefilter('default') if check == True: break while (True): k = randrange(1, large_bound / small_bound) p = q * k + 1 warnings.simplefilter('ignore') check = pyprimes.isprime(p) warnings.simplefilter('default') if check == True: break g = generateG(p, q) return (q, p, g) #Returns q, p and g.
def __get_prime(self, rank): """ Determine prime of specified rank """ m = 1 this_rank = -1 while True: L = 4*m + 1 if pyprimes.isprime(L): this_rank += 1 if this_rank == rank: break m += 1 return L
def GenerateOrRead(filename): if os.path.isfile(filename): # check if pubparams exist. inputfile = open(filename, 'r') q = int(inputfile.readline()) p = int(inputfile.readline()) g = int(inputfile.readline()) else: small = 1 << 224 big = 1 << 2048 foundq = False foundp = False foundg = False while not foundq: q = random.randint(0, small - 1) # generates 224 bit number if pyprimes.isprime(q): foundq = True while not foundp: p = q * random.randint(0, int( big // small)) + 1 # generates 2048 bit p (q % p-1 = 0 ) if pyprimes.isprime(p): foundp = True while not foundg: alpha = random.randint(0, p - 1) # alpha is a random integer in mod p g = pow(alpha, int((p - 1) // q), p) if g != 1: foundg = True outputfile = open('pubparams.txt', 'w') outputfile.write(str(q) + "\n") outputfile.write(str(p) + "\n") outputfile.write(str(g) + "\n") outputfile.close() return q, p, g
def main(): biggest_prime_now = 10000 while biggest_prime_now > 1000: biggest_prime_now = max(primes_below(biggest_prime_now - 1)) for middle_prime in primes_below(biggest_prime_now - 1): if set(list(str(biggest_prime_now))) == set(list( str(middle_prime))): smallest_prime = 2 * middle_prime - biggest_prime_now if smallest_prime < 1000: continue if isprime(smallest_prime): if set(list(str(smallest_prime))) == set( list(str(middle_prime))): print('we found a arithmetic seq {},{},{}'.format( smallest_prime, middle_prime, biggest_prime_now))
def DL_Param_Generator(small_bound, large_bound): L = 2048 N = 256 seedlen = N q = 4 U = 2 domain_parameter_seed = 0 while not isprime(q): # domain_parameter_seed = number.getPrime(seedlen) domain_parameter_seed = int(random.getrandbits(seedlen)) U = hash(domain_parameter_seed % pow(2, N - 1)) q = pow(2, N - 1) + U + 1 - (U % 2) # print("q:", q) offset = 1 V = list() for counter in range(0, 4 * L - 1): outlen = (U.bit_length()) n = L // outlen - 1 b = L - 1 - (n * outlen) for j in range(0, n): V.append( hash((domain_parameter_seed + offset + j) % pow(2, seedlen))) W = 0 for i in range(0, n - 1): W += V[i] * pow(2, (i) * outlen) W += (V[-1] % pow(2, b)) * pow(2, n * outlen) X = W + pow(2, L - 1) c = X % (2 * q) p = X - (c - 1) if isprime(p): g = subGroupGenerator(p, q) return q, p, g offset += n + 1 return (0, 0, 0)
def main(): sums = [] for prime in pyprimes.primes(): if len(sums) == 0: sums.append(prime) continue if prime + sums[len(sums) - 1] >= 1000000: break sums.append(prime + sums[len(sums) - 1]) maximum_length, maximum_value = 0, 0 for i in xrange(0, len(sums) - 1): for j in xrange(i, len(sums)): if j - i > maximum_length and pyprimes.isprime(sums[j] - sums[i]): maximum_length, maximum_value = j - i, sums[j] - sums[i] print maximum_value
def fast_euler_phi(n, totients): if n == 2: return 1 if n % 2 == 0: if (n / 2) % 2 == 0: return 2 * totients[n / 2] else: return 1 * totients[n / 2] else: if pyprimes.isprime(n): return n-1 else: phi = 1 for (p, a) in pyprimes.factorise(n): phi *= (p ** (a-1)) * (p-1) return phi
def calc_period_old(num): """Return the period of amicable chain >>>calc_period(5) >>>0 Todo: deficient number, abundant number""" if isprime(num): return 0 chain = list() chain.append(num) while True: sum_prodiv = sum_proper_divisors(num) # sum of proper divisors if sum_prodiv not in chain: chain.append(sum_prodiv) num = sum_prodiv else: break return len(chain)
def euler_phi(n): if n == 0: return 0 if n == 1: return 1 if n == 2: return 1 if n % 2 == 0: if (n / 2) % 2 == 0: phi_memo[n] = 2 * euler_phi(n / 2) else: phi_memo[n] = 1 * euler_phi(n / 2) else: if pyprimes.isprime(n): return n - 1 else: phi = 1 for (p, a) in pyprimes.factorise(n): phi *= (p ** (a - 1)) * (p - 1) phi_memo[n] = phi return phi_memo[n]
def main(): listb = list(primes_below(1000)) listb = listb[1:] max_cnt = 0 max_a = 0 max_b = 0 for b in listb: # print b for a in [x for x in xrange(-b / 40 - 40, 1000) if x % 2 != 0]: cnt = 0 # print "(a, b)", (a, b) while isprime(cnt ** 2 + a * cnt + b): cnt += 1 # print cnt if max_cnt < cnt: max_cnt = cnt max_a = a max_b = b # print listb # print "max_cnt", max_cnt, "max_a", max_a, "max_b", max_b print max_a * max_b
def isPrime( n ): '''Uses pyprimes to check for the primality of n.''' return pyprimes.isprime( int( n ) )
def isPrime( arg ): return pyprimes.isprime( int( arg ) )
def concat_still_prime(p1, p2): return (pyprimes.isprime(int(str(p1) + str(p2))) and pyprimes.isprime(int(str(p2) + str(p1))))
def check_prime(num): return isprime(num), num
import pyprimes def cumulativeSum(l): sum = 0 i = 0 for num in l: i+=1 sum += num yield (sum,i) def possibleConsecutiveSums(l): for i in xrange(len(l)): for num in cumulativeSum(l[i:]): yield num primesSmallEnough = [] for num in pyprimes.primes(): if sum(primesSmallEnough) > 10**6: break primesSmallEnough.append(num) print 'done', len(primesSmallEnough) toPrint = [x for x in possibleConsecutiveSums(primesSmallEnough) if x[0]<10**6 and pyprimes.isprime(x[0])] print 'done', len(toPrint) justSecondNums = [x[1] for x in toPrint] print toPrint[justSecondNums.index(max(justSecondNums))]
if testNum % (fact*i) == 0: nonpFactors.add(fact * i) i += 1 nonpFactors.add(1) nonpFactors.add(testNum) if testNum in pFactors: pFactors.remove(testNum) if testNum in nonpFactors: nonpFactors.remove(testNum) return pFactors.union(nonpFactors) def isPandigital(a,b,c): conCatParams = set(str(a) + str(b) + str(c)) return len(conCatParams) == len(str(a)) +len(str(b)) + len(str(c)) and set(str(a) + str(b) + str(c)) == set(['1','2','3','4','5','6','7','8','9']) def hasPandigitalProduct(num): for i in findDivsorsOf(num): if isPandigital(i,num/i,num): return True return False previosSum = 0 PanDigitalProductSum = 0 pandigitals = set([]) for i in xrange(4000, 8000): if(not(pyprimes.isprime(i)) and len(set(str(i))) == len(str(i)) and hasPandigitalProduct(i)): PanDigitalProductSum += i pandigitals.add(i) print sum(pandigitals)
from serial import Serial import sys import pygame from pygame.locals import * from pyprimes import isprime #import math def GetReading(): rawin=[] while len(rawin)<5: while (serialport.inWaiting() > 0) and len(rawin)<5: rawin.append(serialport.read(1)) #Try to make some sanity check on the data if not(ord(rawin[0])==0x00): rawin=[] if len(rawin)>1 and not(ord(rawin[1])==0x00): rawin=[] if len(rawin)>2 and not(ord(rawin[2])==0x00): rawin=[] number=(ord(rawin[3])<<8)+ord(rawin[4]) return number portpath=sys.argv[1] serialport = Serial(port=portpath, baudrate=9600) connected=1 while True: Number=GetReading() print(str(Number)+" Prime= "+ str(isprime(Number)))
def merged_numbers_are_not_prime(first_num, second_num): return False in [isprime(int(str(first_num) + str(second_num))), isprime(int(str(second_num) + str(first_num)))]
def main(): pandigital_prime = 0 for number in itertools.permutations("123456"): if pyprimes.isprime(int("7" + "".join(number))): pandigital_prime = max(pandigital_prime, int("7" + "".join(number))) print pandigital_prime
from utils.math_tools import * import pyprimes step_len, start_num = 2, 1 spiral_prime = [] primes_counter = 0 n_counter = 2 while True: crycle = 4 while crycle: start_num += step_len crycle -= 1 # spiral_prime.append(start_num) if pyprimes.isprime(start_num): primes_counter += 1 n_counter += 2 step_len += 2 # per = per_primes(spiral_prime) per = primes_counter / (2.0 * n_counter) # print("side_length %s, primes %s, per %s" % (2 * n_counter, primes_counter, per)) if per < 0.1: break print(n_counter - 1)
def isRotatingPrime(num): listToFill = rotation(list(str(num))) for numberToTest in listToFill: if not(pyprimes.isprime(toInt(numberToTest))): return False return True
curr_sum = 0 for p in primes: curr_sum += p prefix_sums[p] = curr_sum index = 0 max_len = -1 max_len_subseq = [] for i in xrange(0, len(primes)): for j in xrange(i, len(primes)): index += 1 if index % 1000000 == 0: print 'progress: ', float(index) / UB**2, '% (', float(index), '/', UB**2, ')' print 'time: ', str(datetime.timedelta(seconds=(time.time() - startTime))) sum_to_i = prefix_sums[primes[i]] sum_to_j = prefix_sums[primes[j]] sum_from_i_to_j = sum_to_j - sum_to_i + primes[i] if sum_from_i_to_j < UB and pyprimes.isprime(sum_from_i_to_j): curr_length = len(primes[i:j+1]) if max_len < curr_length: print curr_length, ' : ', print primes[i:j+1] print '' max_len = curr_length max_len_subseq = primes[i:j+1] print '' print '' print max_len_subseq, ' - len ', len(max_len_subseq), ', sum ', sum(max_len_subseq)