def prime_factor(x):
ans = 0
prime = primes(sqrt(x))
for num in reversed(prime):
if x % num == 0 and num > ans:
ans = num
print ans
def run() -> int:
# Set the upper limit and generate enough primes generate primes
limit = 5e7
pra = primes(limit**.5 + 1)
# We will be saving suitable numbers here
below_limit = set()
# Check all combinations of primes
for i in pra:
for j in pra:
for k in pra:
# Multiply and add the primes in the needed way
sum_value = i**2 + j**3 + k**4
# If the sum exceeds the limit, skip to next j, else save the sum
if sum_value >= limit:
break
else:
below_limit.add(sum_value)
# Break loops sooner if the numbers are getting too big
if i**2 + j**3 + 2**4 >= limit:
break
if i**2 + 2**3 + 2**4 >= limit:
break
return len(below_limit)
def run() -> int:
# Generate squares of primes. Primes up to ten will suffice - we only use factorials up to 51, which means
# numbers in this problem can't be divisible by primes higher than that
pra = [a**2 for a in primes(10)]
# Initialize the set for storing all numbers that appear in the Pascal triangle and then fill the said set
pascal = set()
for i in range(51):
for j in range(i // 2 + 1):
pascal.add(useful.binomial(i, j))
# Check all numbers stored in 'pascal' and store the valid ones into 'valid'
valid = set()
for j in sorted(pascal):
if useful.is_prime(j):
# If the number itself is prime, it cannot be divided by any square of a prime. Add it to the valid ones.
valid.add(j)
else:
# If any of the prime squares divide the number we're currently checking, add that number to 'valid'
if not any(j % k == 0 for k in pra):
valid.add(j)
# Finally, return the sum of the squarefree numbers
return sum(valid)
def foo(): num = 600851475143 is_sq, sqrt = is_square(num) primes_list = primes(sqrt + 1) for x in reversed(primes_list): if num % x == 0: print x return print num
def compute():
isprime = primes(999999)
def is_circular_prime(n):
s = str(n)
return all(is_prime(int(s[i:] + s[:i])) for i in range(len(s)))
ans = sum(1 for i in isprime if is_circular_prime(i))
return str(ans)
def run() -> int:
pra = primes(5e7)
valid = set()
for i in range(len(pra)):
for j in range(i, len(pra)):
product = pra[i] * pra[j]
if product < 1e8:
valid.add(product)
else:
break
return len(valid)
def main():
primes_below_thousand = primes(1000)
primes_below_thousand_copy = primes_below_thousand[:]
n = 0
product_of_coefficients = -1
# Looping through quadratic equation
for b in primes_below_thousand:
for a in primes_below_thousand:
i = 0
# Positive a and b
while True:
quadratic_expression = i**2 + (a * i) + b
if quadratic_expression not in primes_below_thousand_copy:
if is_prime(quadratic_expression):
primes_below_thousand_copy.append(quadratic_expression)
else:
if i - 1 > n:
n = i - 1
product_of_coefficients = a * b
break
i += 1
i = 0
# Negative a and positive b
while True:
quadratic_expression = i**2 - (a * i) + b
if quadratic_expression not in primes_below_thousand_copy:
if is_prime(
quadratic_expression) and quadratic_expression > 0:
primes_below_thousand_copy.append(quadratic_expression)
else:
if i - 1 > n:
n = i - 1
product_of_coefficients = -1 * a * b
break
i += 1
print(product_of_coefficients)
print(primes_below_thousand_copy)
print(time.time() -
start) # Printing total time of execution in milliseconds
def sieve(n):
# n+1 used so zero is included in the array
m = n+1
numbers = [True] * m
numbers[0] = numbers[1] = False
for i in range(2, int(n**0.5)+1):
if numbers[i]:
for j in range(i*i, n+1, i):
numbers[j] = False
return numbers
def compute(n):
total = 0
primes = sieve(n)
for i, val in enumerate(primes):
if val:
total += i
return str(total)
print(compute(2000000))
# A much quicker way
import eulerlib
primes = eulerlib.primes(2000000)
total = 0
for prime in primes:
total += prime
print(total)
def summation_of_primes(x):
list_primes = eulerlib.primes(x)
sum_of_list = sum(list_primes)
return sum_of_list
def sumPrimes():
total = sum(eulerlib.primes(1999999))
return str(total)
Calculate number of primes for n**2 + an + b
Where a, b are integers and n starts from 0
'''
n = 0 # Num of primes
while True:
if not eulerlib.isprime(n**2 + (a * n) + b):
break
n += 1
return n
ma, mb, mprimes = 0, 0, 0
factor = 100
# b must be prime becuase otherwise test fails when n == 0
brange = eulerlib.primes(1000)
nbrange = []
for prime in brange:
nbrange.append(prime * -1)
brange += nbrange # Add neg version of the primes
###
# Search the problem space...
for a in range(-9 * factor, 10 * factor):
for b in brange:
if eulerlib.isprime(a + b + 1): # Cull at n == 1 (probably not needed)
nprimes = nP4Quad(a, b)
if nprimes > mprimes:
ma, mb, mprimes = a, b, nprimes
print("Solution: a = %d, b = %d, nprimes = %d, a*b = %d" %
import eulerlib
primes=eulerlib.primes(1000)
def d(n,p):
count=0
if n<p:
if n==0:
return 1
else:
return 0
elif n==p:
return 1
else:
for i in range(primes.index(p)+1):
count+=d(n-p,primes[i])
return count
def p(n):
count=0
index=0
while n>primes[index]:
count+=d(n,primes[index])
index+=1
return count
i=5
while p(i)<5000:
i+=1
print(i)
#problema 87
import eulerlib, math
primos = eulerlib.primes(math.sqrt(50000000)) #Lista de numeros primos menores que la raiz cuadrada de 50000000
numeros = {0}
for i in range(2,5): #Recorre los posibles exponentes para los primos [2,3,4]
numerosaux = set()
for p in primos:
q = p ** i #Prueba las posibles combinaciones entre exponentes y primos
if q > 50000000:
break
for x in numeros:
if x + q <= 50000000:
numerosaux.add(x + q)
numeros = numerosaux
m = len(numeros)
print m
from eulerlib import primes print(sum(primes(2000000))) #procedual code with out using built-in function will be uploaded soon
def compute2(): ans = sum(primes(1999999)) return str(ans)
from eulerlib import is_square, primes
(is_sq, sqroot) = is_square(600851475143)
p = primes(sqroot + 1)
for i in range(0, len(p) + 1):
j = 0 - i
if 600851475143 % p[j] == 0:
print(p[j])
break
def main():
answer = sum(primes(1999999))
print(answer)
from eulerlib import primes print sum(primes(2000000)) #142913828922
def calc(n):
prime_list = primes(n)
result = 0
for num in prime_list:
result += num
return result
