def main():
"""Main program."""
answer = 0
start_time = time.time()
if len(sys.argv) > 1:
lim = int(sys.argv[1])
else:
lim = 5000
n = 10
c = 0
while c < lim:
S = list(primerange(0, n))
m = len(S)
c = count_partitions(S, m, n)
n = n + 1
answer = n - 1 # subtract off the last increment of n
end_time = time.time()
print("The answer is %d" % answer)
print("%f seconds elapsed." % (end_time - start_time))
import pyperclip
pyperclip.copy(str(answer))
print("The answer has been placed in the clipboard.")
def main(n):
import sympy
import itertools
p_list = list(sympy.primerange(1, n + 1))
lucky_set = {2}
for i in p_list:
if i in lucky_set:
continue
local_list = [i]
digits = str(i)
n_order = len(digits)
for j in digits[:]:
if int(j) % 2 == 0:
break
else:
for k in range(0, n_order):
s = digits[k:] + digits[:k]
tmp_int = int(s)
if tmp_int in p_list:
local_list.append(tmp_int)
else:
break
else:
for m in local_list:
lucky_set.add(m)
print(sorted(lucky_set))
print(len(lucky_set))
def ep10(): primes = list(primerange(1,2000000)) total = 0 for p in primes: total += p return total
def main():
cities = pd.read_csv("./data/cities.csv")
tour = pd.read_csv("./data/best2.csv")
ids = cities["CityId"]
primes = [p for p in sympy.primerange(0, len(ids))]
arr = dict()
all_x = cities["X"]
all_y = cities["Y"]
for i, id in enumerate(cities["CityId"]):
arr[id] = (all_x[i], all_y[i])
score = 0.0
s = tour["Path"].values
with open("./data/tour_distances3.csv", "w") as tour_dist:
tour_dist.write("Path, dist, is_prime, needs_to_be_prime\n")
tour_dist.write("0, 0, 0, 0\n")
for i in range(0, len(s) - 1):
p1 = arr[s[i]]
p2 = arr[s[i + 1]]
stepSize = math.sqrt((p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]))
if s[i + 1] in primes:
r = "1"
else:
r = "0"
if ((i + 1) % 10 == 0) and (s[i] not in primes):
stepSize *= 1.1
tour_dist.write(str(s[i + 1]) + "," + str(stepSize) + "," + r + ",1\n")
elif ((i + 1) % 10 == 0) and (s[i] in primes):
tour_dist.write(str(s[i + 1]) + "," + str(stepSize) + "," + r + ",1\n")
else:
tour_dist.write(str(s[i + 1]) + "," + str(stepSize) + "," + r + ",0\n")
# print(stepSize)
score += stepSize
print(score)
def function_find_out_on_prime_number_vol_4(number):
# Генерируем список , который уже содержит простые числа из заданного диапазона !!
prime_number = list(sympy.primerange(0, 1000))
if number in prime_number:
result = True
else :
result = False
return result
def expansion_fn(state):
primes_below = np.array(list(sympy.primerange(0, state + 1)))
possible_child_states = state / primes_below
child_states = [s for s in possible_child_states if s == s // 1]
step_costs = np.ones_like(child_states)
return child_states, step_costs
def score_tour(tour, cities):
df = cities.reindex(tour + [0]).reset_index()
primes = list(sympy.primerange(0, len(cities)))
df['prime'] = df.CityId.isin(primes).astype(int)
df['dist'] = np.hypot(df.X - df.X.shift(-1), df.Y - df.Y.shift(-1))
df['penalty'] = df['dist'][9::10] * (1 - df['prime'][9::10]) * 0.1
print(df.dist.sum(), df.penalty.sum())
return df.dist.sum() + df.penalty.sum()
def conjecture(n):
cota = int(m.sqrt((n - 2.0) / 2.0)) + 1
primos = list(sp.primerange(2, n))
assert n % 2 == 1 and not n in primos, 'n no cumple las hipotesis'
for p in primos:
for x in range(1, cota):
if n == p + 2 * x**2:
return (p, x)
def conjecture(n):
cota = int(m.sqrt((n-2.0)/2.0)) + 1
primos = list(sp.primerange(2, n))
assert n%2==1 and not n in primos, 'n no cumple las hipotesis'
for p in primos:
for x in range(1, cota):
if n == p + 2*x**2:
return (p, x)
def DpList(n):
D = []
for p in sy.primerange(1, n + 3):
m = 1
while (sy.primepi(p - m) == sy.primepi(p + m) - 1):
m = m + 1
D.append(m - 1)
return D
def check(self, f, min_p=2, max_p=30):
# checking through few small primes to see if it is perhaps
# either irreducible in one of those, or the degrees of irreducible factors
# are imcompatible
from sympy.polys.galoistools import gf_factor
from sympy.polys.domains import ZZ
from sympy import primerange
irreduc_factors_degrees = {}
irreduc_primes = []
for p in primerange(min_p, max_p + 1):
try:
irreduc_factors = gf_factor(f.all_coeffs(), p, ZZ)
degrees = []
for x in irreduc_factors[1]:
pol = x[0]
e = x[1]
degrees += e * [(len(pol) - 1)]
if len(degrees) == 1:
# irreducible by p...
irreduc_primes.append(p)
# store irreducibility factors degrees for later
irreduc_factors_degrees[p] = degrees
except sympy.polys.polyerrors.NotInvertible:
pass
res = {}
if irreduc_primes:
res["p"] = irreduc_primes
# check if the degrees are compatible, first for degrees in Fp[x], we calculate by summing
# all possible degrees of irreducible factors in Z[x]
sums = {}
trivial = set(range(1, f.degree() + 1))
for p in irreduc_factors_degrees:
sums_p = subsets_sums(irreduc_factors_degrees[p])
if sums_p != trivial:
sums[p] = sums_p
if not sums:
return UNKNOWN, None
# then if intersection of these is empty or {deg(f)}, then lesser degree factor is impossible
# thus polynomial will have to be irreducible
inter = set.intersection(*list(sums.values()))
if f.degree() in inter:
inter.remove(f.degree())
if not inter:
# intersection is empty, imcompatible factors!
res["degrees"] = sums
if res:
return IRREDUCIBLE, res
return UNKNOWN, None
def calculate_factorization(number1): #Funtion for geting factor
dictionary = {}
for prime in sympy.primerange(2, number1):
if number1 % prime == 0:
check_power = calculate_power(number1, prime)
dictionary[prime] = check_power
number1 /= pow(prime, check_power)
if number1 == 1:
return dictionary
def __generateE(self):
print "generate e"
# 17 257 65537
result = 3
for num in sympy.primerange(2, self.f):
if gcd(num, self.f) == 1:
result = num
break
return result
def candidats_CA_CB(M=10, m=1):
# Premiers entre m et M (compris), ie. P inter [|m, ..., M|]
C_A = list(primerange(m, M + 1))
# Nombres pairs
if m % 2 == 0:
C_B = list(range(m, M - 1, 2))
else:
C_B = list(range(m + 1, M - 1, 2))
return C_A, C_B
def find_factors_of_j():
small_primes = sympy.primerange(1, 2**16)
factors = []
for sp in small_primes:
if j % sp == 0:
factors.append(sp)
return factors
def candidats_CA_CB(M=10, m=1):
# Premiers entre m et M (compris), ie. P inter [|m, ..., M|]
C_A = list(primerange(m, M + 1))
# Nombres pairs
if m % 2 == 0:
C_B = list(range(m, M - 1, 2))
else:
C_B = list(range(m + 1, M - 1, 2))
return C_A, C_B
def find_goldbach(n: int) -> Union[List, None]:
odd_primes = [prime for prime in primerange(0, n) if prime % 2 != 0]
shuffle(odd_primes)
solution_space = product(odd_primes[:], odd_primes[:], odd_primes[:])
for possible_solution in solution_space:
if sum(possible_solution) == n:
return possible_solution
return None
def main():
primes = primerange(1000, 10000)
for p in primes:
if p != 1487:
a = p + 3330
b = p + 6660
if isprime(a) and isprime(b) and set(str(p)) == set(str(a)) == set(
str(b)):
return str(p) + str(a) + str(b)
def n_first_primes(n):
"""
Return first n prime numbers.
"""
nth_prime = sympy.prime(n)
primes_gen = sympy.primerange(1, nth_prime + 1)
primes_lst = [num for num in primes_gen]
return primes_lst
def tiny_q():
priv_key = None
for prime in sympy.primerange(2, 100000):
if n % prime == 0:
q = prime
p = n // q
priv_key = PrivateKey(int(p), int(q), int(e), int(n))
print(priv_key)
return priv_key
def public_key(phi_of_n, p, q):
# Generates prime numbers from range 2 to phi_of_n
li = list(sympy.primerange(2, phi_of_n))
# Generates the list possible public keys such that public key and phi_of_n are coprime.
li1 = []
for i in li:
x = coprime(i, phi_of_n)
if x == 1 and (i != p and i != q):
li1.append(i)
return li1
def main(n=20):
primes = list(primerange(1, n))
i, ans = 0, 1
while primes[i] < sqrt(n):
e = floor(log(n) / log(primes[i]))
ans *= (primes[i])**e
i += 1
for p in primes[i:]:
ans *= p
return ans
def __init__(self, head=None):
self._primes_iter = sp.primerange(0, 2 ** 500)
head = ([2] if head is None else head)
self._primes = list(head)
self._primes_set = set(head)
self._primes_set.add(None)
self._order = {}
for idx, v in enumerate(self._primes):
self._order[v] = idx
def get_prime(l):
P = functools.reduce(mul, sympy.primerange(2, 30))
q = random.randint(2**(l - 1), 2**l)
while True:
if sympy.gcd(q, P) == 1:
break
q += 1
while not isprime(q):
q += P
return q
def S(n):
"""return sum of triplet primes in the row"""
ret = 0
#yields the primes and their coordinates
start = (2 - n + n * n) / 2
for pr in primerange(start, start + n):
#coordinates of the prime are (pr - start, n)
if is_prime_triplet(pr - start, n):
ret += pr
return ret
def primes_gen(*args):
"""
Prime number generator
Possible usages:
primes_gen(): infinite generator
primes_gen(a): generate all primes below a
primes_gen(a, b): generate all primes below a and b
"""
if len(args) == 1:
for x in primerange(2, args[0]):
yield x
elif len(args) == 2:
for x in primerange(*args):
yield x
elif len(args) == 0:
x = 1
while 1:
x = nextprime(x)
yield x
def factorize(n):
if isprime(n):
return []
res = []
for i in primerange(0, math.sqrt(n)+1):
if n % i == 0:
res.append(i)
n /= i
if isprime(n):
res.append(n)
break
return res
def sum_primes():
# establishing a zero count to add primes to
count = 0
# looping through all primes in range to 2 million
for i in sympy.primerange(1, 2000000):
count += i
# printing the count of the primes
print(count)
def primeperms():
primes = list(sympy.primerange(START, STOP))
for prime1 in primes:
for prime2 in filter(lambda x: x > prime1, primes):
for prime3 in filter(lambda x: x > prime2, primes):
# check for a constant increment
if prime1 + INCREMENT == prime2:
if prime2 + INCREMENT == prime3:
# and that these are permutations
if ispermutation(prime1, prime2):
if ispermutation(prime2, prime3):
return prime1, prime2, prime3
def main():
import sympy as sp
plist = list(sp.primerange(999, 10000))
for i in plist:
for j in plist[plist.index(i)+1:]:
k = 2 * j - i
if k in plist:
digi_set_i = set(str(i))
digi_set_j = set(str(j))
digi_set_k = set(str(k))
if digi_set_i == digi_set_j == digi_set_k :
print(i, j, k, sep='')
def smallp(self):
# Try an attack where q < 100,000, from BKPCTF2016 - sourcekris
for prime in list(primerange(0, 100000)):
if self.pub_key['n'] % prime == 0:
q = prime
p = self.pub_key['n'] / q
self.priv_key = PrivateKey({
'p': int(p),
'q': int(q),
'e': self.pub_key['e'],
'n': self.pub_key['n']
})
return self.priv_key
def primeCheckDynamic(maxNumber, currentArray):
if len(currentArray) < 5:
for p in primerange(currentArray[-1] + 1, maxNumber):
if isGood(currentArray,
p): # Move until a number can be added to the array
copyArray = currentArray[:]
copyArray.append(p)
result = primeCheckDynamic(maxNumber, copyArray)
if result[0]:
return result
return [False, -1]
else:
return [True, sum(currentArray)]
def main():
start = time.perf_counter()
tableauchiffres = [6, 2, 5, 5, 4, 5, 6, 4, 7, 6]
tableaumax = ["01111101", "01010000", "00110111", "01010111", "01011010", "01001111", "01101111", "01011001",
"01111111", "01011111"]
p = sympy.primerange(10 ** 7, 2 * 10 ** 7)
resultat = 0
for u in p:
resultat += test(u, tableauchiffres, tableaumax)
print(resultat)
print('temps d execution', time.perf_counter() - start, 'sec')
def main(N=8400):
res = []
primes = list(primerange(3,N))
index = 0
for p in primes:
index += 1
for i in primes[index:]:
if is_pair_prime(p,i):
res.append((p,i))
G = nx.Graph()
G.add_edges_from(res)
ans = [clique for clique in find_cliques(G) if len(clique)==5]
return min(map(sum,ans))
def amicable_numbers(n):
primes = list(primerange(0, n + 1))
numbers = set()
for i in range(2, n):
s1 = sum(divisors(factorize(i, primes))[:-1])
if i == s1: #skip perfect number like 6
continue
s2 = sum(divisors(factorize(s1, primes))[:-1])
if s2 == i:
numbers.add(i)
numbers.add(s1)
print(numbers)
print(sum(numbers))
def decompose(n):
if isprime(n):
return False
factors = {}
for i in primerange(2, math.sqrt(n)):
if n % i == 0:
n //= i
factors[i] = factors.get(i, 0) + 1
if isprime(n):
factors[n] = factors.get(n, 0) + 1
if len(factors) > 4:
break
return len(factors)
def main():
start = time.perf_counter()
tableauchiffres = [6, 2, 5, 5, 4, 5, 6, 4, 7, 6]
tableaumax = ["01111101", "01010000", "00110111", "01010111", "01011010", "01001111", "01101111", "01011001",
"01111111", "01011111"]
p = sympy.primerange(10 ** 7, 2 * 10 ** 7)
resultat = 0
for u in p:
resultat += test(u, tableauchiffres, tableaumax)
print(resultat)
print('temps d\'exécution', time.perf_counter() - start, 'sec')
def find_primes_sextuplet(sum_limit):
import sympy
for prime in sympy.primerange(0, sum_limit):
primelist = [
prime, prime + 4, prime + 6, prime + 10, prime + 12, prime + 16
]
primesum = 0
for element in primelist:
primesum += element
if not sympy.isprime(element):
break
if primesum > sum_limit:
return primelist
class Tour:
cities = read_cities()
coords = (cities.X + 1j * cities.Y).values
penalized = ~cities.index.isin(sympy.primerange(0, len(cities)))
def __init__(self, data):
"""Initializes from a list/iterable of indexes or a filename of tour in csv/tsplib/linkern format."""
if type(data) is str:
data = self._read(data)
elif type(data) is not np.ndarray or data.dtype != np.int32:
data = np.array(data, dtype=np.int32)
self.data = data
if (self.data[0] != 0 or self.data[-1] != 0 or len(self.data) != len(self.cities) + 1):
raise Exception('Invalid tour')
@classmethod
def _read(cls, filename):
data = open(filename, 'r').read()
if data.startswith('Path'): # csv
return pd.read_csv(io.StringIO(data)).Path.values
offs = data.find('TOUR_SECTION\n')
if offs != -1: # TSPLIB/LKH
data = np.fromstring(data[offs+13:], sep='\n', dtype=np.int32)
data[-1] = 1
return data - 1
else: # linkern
data = data.replace('\n', ' ')
data = np.fromstring(data, sep=' ', dtype=np.int32)
if len(data) != data[0] + 1:
raise Exception('Unrecognized format in %s' % filename)
return np.concatenate((data[1:], [0]))
def info(self):
dist = np.abs(np.diff(self.coords[self.data]))
penalty = 0.1 * np.sum(dist[9::10] * self.penalized[self.data[9:-1:10]])
dist = np.sum(dist)
return { 'score': dist + penalty, 'dist': dist, 'penalty': penalty }
def dist(self):
return self.info()['dist']
def score(self):
return self.info()['score']
def __repr__(self):
return 'Tour: %s' % str(self.info())
def to_csv(self, filename):
pd.DataFrame({'Path': self.data}).to_csv(filename, index=False)
def primeFactors(n):
factors = []
primes = sympy.primerange(3, n/2)
print("Prime Generator Ready...")
for f in primes:
while isFactor(n, f):
factors.append(f)
n = n/f
if(n==1):
return factors
return factors
def euler111_brute_force():
digit_counts = defaultdict(int)
for pr in primerange(10 ** (10 - 1), 10 ** (10 - 1 + 1)):
cnts = Counter(str(pr))
for x in cnts.most_common():
if x[1] < 2:
break
digit_counts[x] += pr
Sd = defaultdict(list)
for digit_cnt, s in sorted(digit_counts.items()):
Sd[digit_cnt[0]].append(s)
return sum(a[-1] for a in Sd.values())
def consecutive_prime_sum(max_n):
primes = list(primerange(2,max_n))
prime_set = set(primes)
prime_len = len(primes)
max_prime = (0,-1)
for i in range(prime_len):
max_p = get_largest_consecutive(primes, prime_set,i)
if max_p[0]> max_prime[0]:
max_prime = max_p
if max_prime[0]> prime_len -i +1:
break
return max_prime[1]
def prime_digit_replacements_of(number_of_primes,n):
primes = primerange(10**(n-1), 10**n)
rep_dict = {}
for p in primes:
p_str = str(p)
for perm in get_star_perms(p_str):
if perm not in rep_dict:
rep_dict[perm] = [p,1]
else:
rep_dict[perm][1]+=1
num_filter = (v for v in rep_dict.values() if v[1] == number_of_primes)
nums = sorted(num_filter)
if len(nums):
return nums[0][0]
else:
return None
def main():
import sympy as sp
pl1 = list(sp.primerange(3, 10000))
pl11 = [i for i in pl1 if i % 3 == 1 or i % 3 == 0]
pl12 = [i for i in pl1 if i % 3 == 2 or i % 3 == 0]
plen = len(pl1)
best = 1111111111110
for a in pl1:
print(a)
p_loc_a = []
for b in pl1:
if b < a:
continue
if ccc(a, b):
p_loc_a.append(b)
for b in p_loc_a:
p_loc_b = []
for c in p_loc_a:
if c < b:
continue
if ccc(b, c):
p_loc_b.append(c)
for c in p_loc_b:
p_loc_c = []
for d in p_loc_b:
if d < c:
continue
if ccc(c, d):
p_loc_c.append(d)
for d in p_loc_c:
for e in p_loc_c:
if e < d:
continue
if ccc(d, e):
print(a, b, c, d, e)
s = a + b + c + d + e
print(s)
if s < best:
best = s
print("best is ", best)
def main():
import sympy as sp
plist = list(sp.primerange(1, 1000000))
s, t = 0, 0
l = 0
best_l = 1
best = 1
best_s = 0
for i in range(1, len(plist)):
p = plist[i]
tmp = 0
for s in range(0, best_l):
tmp = tmp + plist[s]
if tmp > p:
continue
for s in range(0, i-1):
if plist[s] > p // best_l:
break
local_sum = 0
for t in range(s, i):
local_sum = local_sum + plist[t]
if local_sum > p:
l = t - s + 1
break
if local_sum == p:
l = t - s + 1
print(p, l, s)
if l > best_l:
best_l = l
best = p
best_s = s
break
if l <= best_l and local_sum > p:
break
if local_sum == p:
break
print("The longest one:", best, best_l)
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# A number consisting entirely of ones is called a repunit. We shall define R(k) to be a repunit of length k.
# For example, R(10) = 1111111111 = 11×41×271×9091, and the sum of these prime factors is 9414.
# Find the sum of the first forty prime factors of R(10^9).
# https://en.wikipedia.org/wiki/Repunit adresinden de görülebileceği gibi bu sayılar R(n)=10^n-1 şeklinde yazılabiliyor.
# n asal sayısının (10^(10^9) - 1)'i bölmesi gerektiğini biliyoruz. Bu nedenle python'un pow fonksiyonunu kullanarak sonucu bulmak çok kolay oluyor.
# pow kullanmak yerine 10**L%n yazmayı denediğinizde işlemlerin süresinin karşılaştırılamayacak kadar uzun sürdüğünü görebilirsiniz.
from sympy import primerange
primes = primerange(5,1000000)
bolen = []
L = 10**9
for n in primes:
if(pow(10, L, n) == 1):
bolen.append(n)
if(len(bolen)==40):
break
print(sum(bolen))
This is the longest sum of consecutive primes that adds to a prime
below one-hundred.
The longest sum of consecutive primes below one-thousand that adds to a
prime, contains 21 terms, and is equal to 953.
Which prime, below one-million, can be written as the sum of the most
consecutive primes?
"""
from time import time
import numpy as np
from sympy import primerange, isprime
start_time = time()
# I found 7 below by trial and error. Wrong answer starting with 2, 3, 5 ...
primes = np.array(list(primerange(7, 4000)))
cs = np.cumsum(primes)
ip = np.vectorize(isprime)
smalls = cs[cs <= 1000000][::-1] # Ordered descending
bools = ip(smalls)
ans = smalls[bools][0]
print("The answer is: %i") % (ans)
running_time = time()
elapsed_time = running_time - start_time
"""
Created Nov 15, 2012
Author: Spencer Lyon
Project Euler Problem 26
I got the idea for how to do this from the following website:
http://primes.utm.edu/glossary/xpage/PeriodOfADecimal.html
"""
import sympy as sym
import numpy as np
# The number must be prime and I am guessing it is big so start with highest.
primes = np.asarray(list(sym.primerange(1, 1000)))[::-1][:-3]
periods = np.asarray([sym.ntheory.n_order(10, i) for i in primes])
the_max = np.argmax(periods)
ans = primes[the_max]
print "The answer is: ", ans
def test_G1():
assert list(primerange(999983, 1000004)) == [999983, 1000003]
def qnwequi(n, a, b, kind="N", equidist_pp=None):
"""
Generates equidistributed sequences with property that averages
value of integrable function evaluated over the sequence converges
to the integral as n goes to infinity.
Parameters
----------
n : int
Number of sequence points
a : scalar or array_like(float)
A length-d iterable of lower endpoints. If a scalar is given,
that constant is repeated d times, where d is the number of
dimensions
b : scalar or array_like(float)
A length-d iterable of upper endpoints. If a scalar is given,
that constant is repeated d times, where d is the number of
dimensions
kind : string, optional(default="N")
One of the following:
- N - Neiderreiter (default)
- W - Weyl
- H - Haber
- R - pseudo Random
equidist_pp : array_like, optional(default=None)
TODO: I don't know what this does
Returns
-------
nodes : np.ndarray(dtype=float)
Quadrature nodes
weights : np.ndarray(dtype=float)
Weights for quadrature nodes
Notes
-----
Based of original function ``qnwequi`` in CompEcon toolbox by
Miranda and Fackler
References
----------
Miranda, Mario J, and Paul L Fackler. Applied Computational
Economics and Finance, MIT Press, 2002.
"""
if equidist_pp is None:
equidist_pp = np.sqrt(np.array(list(sym.primerange(0, 7920))))
n, a, b = list(map(np.atleast_1d, list(map(np.asarray, [n, a, b]))))
d = max(list(map(len, [n, a, b])))
n = np.prod(n)
if a.size == 1:
a = np.repeat(a, d)
if b.size == 1:
b = np.repeat(b, d)
i = np.arange(1, n + 1)
if kind.upper() == "N": # Neiderreiter
j = 2.0 ** (np.arange(1, d+1) / (d+1))
nodes = np.outer(i, j)
nodes = (nodes - np.fix(nodes)).squeeze()
elif kind.upper() == "W": # Weyl
j = equidist_pp[:d]
nodes = np.outer(i, j)
nodes = (nodes - np.fix(nodes)).squeeze()
elif kind.upper() == "H": # Haber
j = equidist_pp[:d]
nodes = np.outer(i * (i+1) / 2, j)
nodes = (nodes - np.fix(nodes)).squeeze()
elif kind.upper() == "R": # pseudo-random
nodes = np.random.rand(n, d).squeeze()
else:
raise ValueError("Unknown sequence requested")
# compute nodes and weights
r = b - a
nodes = a + nodes * r
weights = (np.prod(r) / n) * np.ones(n)
return nodes, weights
#!/usr/bin/env python3
from sympy import primerange
from itertools import combinations
limit = 1000000
sieve = list(primerange(2, limit))
set_sieve = set(sieve)
for p in sieve:
p_str = str(p)
for i in range(1, len(p_str)+1):
for x in combinations(range(len(p_str)), i):
ok, ukupno, z = False, 1, p_str[x[0]]
for k in x:
if p_str[k] != z: ok = True
if ok: continue
for j in range(10):
p_str = str(p)
for k in x: p_str = p_str[:k] + str(j) + p_str[k+1:]
novi = int(p_str)
if novi > p and novi in set_sieve: ukupno +=1
if ukupno == 8: print(p)
def main():
for p in syp.primerange(1, 20):
print(p, primitive_root(p))
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# The primes 3, 7, 109, and 673, are quite remarkable. By taking any two primes and concatenating them in any order the result will always be prime. For example, taking 7 and 109, both 7109 and 1097 are prime. The sum of these four primes, 792, represents the lowest sum for a set of four primes with this property.
# Find the lowest sum for a set of five primes for which any two primes concatenate to produce another prime.
from sympy import primerange
from sympy import isprime
from itertools import permutations
primestest = list(primerange(3,10000))
toplam = 30000
sonuc = False
for n in primestest:
for m in primestest[primestest.index(n)+1:]:
if(isprime(int(str(n)+str(m)))==0 or isprime(int(str(m)+str(n)))==0):
continue
for p in primestest[primestest.index(m)+1:]:
if(isprime(int(str(p)+str(m)))==0 or isprime(int(str(m)+str(p)))==0):
continue
for q in primestest[primestest.index(p)+1:]:
if(n+m+p+q>toplam):
break
if(isprime(int(str(p)+str(q)))==0 or isprime(int(str(q)+str(p)))==0):
continue
for r in primestest[primestest.index(q)+1:]:
if(n+m+p+q+r>toplam):
break
if(isprime(int(str(r)+str(q)))==0 or isprime(int(str(q)+str(r)))==0):
continue
grup = permutations([n,m,p,q,r],2)
for i in grup:
""" Created August 22, 2012 Author: Spencer Lyon Project Euler #10 """ from sympy import primerange from time import time start_time = time() ans = sum(list(primerange(0, 2e6))) end_time = time() elapsed_time = end_time - start_time print "total time elapsed is ", elapsed_time, " seconds" print ans
one another.
There are no arithmetic sequences made up of three 1-, 2-, or 3-digit
primes, exhibiting this property, but there is one other 4-digit
increasing sequence.
What 12-digit number do you form by concatenating the three terms in
this sequence?
"""
from time import time
from sympy import primerange
from itertools import permutations
start_time = time()
nums = list(primerange(1000, 10000))
num_set = set(nums)
def is_perm(x, y):
sx = str(x)
sy = str(y)
test_set = set(tuple(permutations(sy, len(sy))))
test_tup = tuple(sx)
return test_tup in test_set
set1 = 0
for num in nums:
a = num
b = num + 3330
def main(n):
import sympy as sp
for i in sp.primerange(100000, 1000000):
digi_last = i % 10
s = str(i//10)
# if len(set(s)) > 3:
# continue
for c in range(0, 2):
if s.count(str(c)) == 3:
count = 0
local_list = []
for d in range(c, 10):
new_s = s.replace(str(c), str(d))
new_digi = int(new_s) * 10 + digi_last
if p37.is_prime(new_digi):
count = count + 1
local_list.append(new_digi)
if count == n:
print("the lucky one:", i)
print(local_list)
return
print(local_list)
if s.count(str(c)) == 4:
count = 0 # Replace the last one
local_list = []
for d in range(c, 10):
new_s = s.replace(str(c), str(d), 3)
new_digi = int(new_s) * 10 + digi_last
if p37.is_prime(new_digi):
count = count + 1
local_list.append(new_digi)
if count == n:
print("the lucky one:", i)
print(local_list)
return
print(local_list)
count = 0 # Replace the second one
local_list = []
for d in range(c, 10):
new_s = s.replace(str(c), str(d), 1)
new_s = new_s.replace(str(c), 'a', 1)
new_s = new_s.replace(str(c), str(d), 2)
new_s = new_s.replace('a', str(c), 1)
new_digi = int(new_s) * 10 + digi_last
if p37.is_prime(new_digi):
count = count + 1
local_list.append(new_digi)
if count == n:
print("the lucky one:", i)
print(local_list)
return
print(local_list)
count = 0 # Replace the third one
local_list = []
for d in range(c, 10):
new_s = s.replace(str(c), str(d), 2)
new_s = new_s.replace(str(c), 'a', 1)
new_s = new_s.replace(str(c), str(d), 1)
new_s = new_s.replace('a', str(c), 1)
new_digi = int(new_s) * 10 + digi_last
if p37.is_prime(new_digi):
count = count + 1
local_list.append(new_digi)
if count == n:
print("the lucky one:", i)
print(local_list)
return
print(local_list)
count = 0 # Replace the third one
local_list = []
for d in range(c, 10):
new_s = s.replace(str(c), 'a', 1)
new_s = new_s.replace(str(c), str(d), 3)
new_s = new_s.replace('a', str(c), 1)
new_digi = int(new_s) * 10 + digi_last
if p37.is_prime(new_digi):
count = count + 1
local_list.append(new_digi)
if count == n:
print("the lucky one:", i)
print(local_list)
return
print(local_list)
else:
continue
#!/usr/bin/env python3
from sympy import isprime, primerange
from itertools import permutations
def is_good_prime_pair(a, b):
return isprime(int(str(a) + str(b))) and isprime(int(str(b) + str(a)))
primes_1 = set(primerange(1, 10000))
primes_2 = set((a, b) for a, b in permutations(primes_1, 2)
if is_good_prime_pair(a, b))
prime_dict_1 = dict()
prime_dict_2 = dict()
prime_dict_3 = dict()
prime_dict_4 = dict()
for a, b in primes_2:
if a not in prime_dict_1:
prime_dict_1[a] = set()
prime_dict_1[a].add(b)
for a, prime_set in prime_dict_1.items():
for b in prime_set:
prime_dict_2[a, b] = prime_set.intersection(prime_dict_1[b])
for (a, b), prime_set in prime_dict_2.items():
for c in prime_set:
prime_dict_3[a, b, c] = prime_set.intersection(prime_dict_1[c])
def GetSetOfPrimesInRange(e):
primeSet = set()
for p in primerange(10**e,10**(e+1)):
if (str(p)[-1] in ('1','3','7')):
primeSet.add(p)
return primeSet
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# A number consisting entirely of ones is called a repunit. We shall define R(k) to be a repunit of length k; for example, R(6) = 111111.
# Let us consider repunits of the form R(10^n).
# Although R(10), R(100), or R(1000) are not divisible by 17, R(10000) is divisible by 17. Yet there is no value of n for which R(10^n) will divide by 19. In fact, it is remarkable that 11, 17, 41, and 73 are the only four primes below one-hundred that can be a factor of R(10^n).
# Find the sum of all the primes below one-hundred thousand that will never be a factor of R(10^n).
# https://en.wikipedia.org/wiki/Repunit adresinden de görülebileceği gibi bu sayılar R(n)=10^n-1 şeklinde yazılabiliyor.
from sympy import primerange
primes = primerange(2,100000)
bolen = 3
L = 10**20
for n in primes:
if(pow(10, L, n) != 1):
bolen += n
print(bolen)
