def get_number_divisors(n, primelist):
half_n = int(float(n) / 2) + 1
if primelist is None:
primelist = prime_sieve(n, output=[])
prod = 1
for p in primelist:
counter = 0
while n % p == 0:
n /= p
counter += 1
if counter > 0:
prod *= (counter + 1)
if n == 1:
return prod
if p > half_n:
return prod + 1
def get_prime_factors(n, primelist):
own_num = n
half_n = int(float(n)/2) + 1
if primelist is None:
primelist = prime_sieve(n, output=[])
fs = []
for p in primelist:
count = 0
while n % p == 0:
n /= p
count += 1
if count > 1:
return False
if n == 1:
return True
if p > half_n:
fs.append((own_num, 1))
return True
from find_prime_factorization import prime_sieve
import time
prime_list = prime_sieve(10**6, [])
print prime_list.index(21059)
def calc_rem(n):
p = prime_list[n - 1]
return ((p + 1)**n + (p - 1)**n) % (p**2)
t = time.time()
for j in range(22000):
if j % 10**3 == 0:
print j
if calc_rem(j) > 10**10:
print j
print time.time() - t
exit()
print time.time() - t
from find_prime_factorization import prime_sieve
import time
t = time.time()
prime_list = prime_sieve(5 * 10**7, [])
prime_list2 = prime_sieve(10**4, [])
count = 0
for idx, val in enumerate(prime_list2):
if val == 101:
prime_list = prime_sieve(10**6, [])
if val == 1009:
prime_list = prime_sieve(10**5, [])
print val
for val2 in prime_list[idx:]:
if val * val2 < 10**8:
count += 1
else:
break
print count
print time.time() - t
from find_prime_factorization import is_prime
from find_prime_factorization import prime_sieve
primes = prime_sieve(1000000, [])
truncatable_primes = []
def trunc_right(n):
return int(str(n)[:len(str(n)) - 1])
def trunc_left(n):
return int(str(n)[1:])
for i in primes[4:]:
setting = True
n = i
while len(str(n)) > 1:
if not is_prime(trunc_right(n)):
setting = False
break
else:
n = trunc_right(n)
n = i
while len(str(n)) > 1:
if not is_prime(trunc_left(n)):
setting = False
break
else:
n = trunc_left(n)
import time
def find_counter(a, b):
factor = 0
for i in range(len(str(a))):
for k in range(10):
if ((factor + 10**i * k) * b) % 10**(i + 1) == a % 10**(i + 1):
factor = factor + 10**i * k
break
return factor
t = time.time()
prime_list = prime_sieve(10**6 + 10**4, [])
prime_list = prime_list[2:]
sols2 = []
for o in range(len(prime_list) - 1):
if prime_list[o] > 10**6:
break
p1 = prime_list[o]
p2 = prime_list[o + 1]
counter = find_counter(p1, p2)
sols2.append(counter * p2)
print sum(sols2)
print time.time() - t
import time
from find_prime_factorization import prime_sieve
def largest_idempotent(n):
maxi = 0
for i in range(n):
if (i**2) % n == i:
maxi = i
return maxi
t = time.time()
N = 10000
prime_list = prime_sieve(N, [])
to_check_list = [i for i in range(1, N + 1) if i not in prime_list]
print to_check_list
S = 0
for i in to_check_list:
S += largest_idempotent(i)
S += len(prime_list)
print S
print time.time() - t
#check out https://math.stackexchange.com/questions/175963/idempotents-in-mathbb-z-n
def number_rotations(n):
rotations = []
for i in range(len(str(n))):
temp_string = ''
for j in range(len(str(n))):
temp_string = temp_string + str(n)[(i + j) % len(str(n))]
rotations.append(int(temp_string))
i += 1
return rotations
t = time.time()
circular_primes = []
check_primes = prime_sieve(int(math.sqrt(1000000)), [])
primes = prime_sieve(1000000, [])
for i in primes:
state = True
for j in number_rotations(i):
if not is_prime(j, check_primes):
state = False
if state is True:
circular_primes.append(i)
print circular_primes
print len(circular_primes)
print time.time() - t
number = 0
for o, val in enumerate(temp):
number += val * 10**(len(temp) - (o + 1))
if number in primes:
# if is_prime(number, primes):
count += 1
if count > 7:
print j
print number
return True
return False
t = time.time()
primes = set(prime_sieve(1000000, []))
if __name__ == "__main__":
p = Pool(7)
L = p.map(check_number, range(1, 1000000))
print L.index(1) + 1
#results = []
#for i in range(100000):
# if check_number(i):
# results.append(i)
#print 'RESULTS'
#print results
print time.time() - t
while n % p == 0:
n /= p
count += 1
if count > 1:
return False
if n == 1:
return True
if p > half_n:
fs.append((own_num, 1))
return True
t = time.time()
numbers = []
for i in range(51):
for j in range(i/2 + 1):
temp = choose(i,j)
if temp not in numbers:
numbers.append(choose(i,j))
prime_list = prime_sieve(10**8)
S = 0
for i in numbers:
if get_prime_factors(i, prime_list):
S += i
print S
print time.time() - t
prod = 1
for p in primelist:
counter = 0
while n % p == 0:
n /= p
counter += 1
if counter > 0:
prod *= (counter + 1)
if n == 1:
return prod
if p > half_n:
return prod + 1
t = time.time()
N = 10**7
count = 0
prime_list = prime_sieve(N / 2 + 1, [])
temp2 = 2
for i in range(2, N):
if i % 1000 == 0:
print i
temp1 = temp2
temp2 = get_number_divisors(i + 1, prime_list)
if temp1 == temp2:
count += 1
print count
print time.time() - t
from find_prime_factorization import prime_sieve
from find_prime_factorization import is_prime
import time
import numpy as np
#def concat(a):
# if not is_prime(int(str(a[0]) + str(a[1]))) or not is_prime(int(str(a[1]) + str(a[0]))):
# return False
# else:
# return True
primes_check = prime_sieve(10**5, [])
def concat(a):
for i in a:
temp = list(a)
temp.remove(i)
for j in temp:
if not is_prime(int(str(i) + str(j)), primes_check):
return False
return True
def append_check(a):
for i in a[:-1]:
if not is_prime(int(str(i) + str(a[-1]))):
return False
if not is_prime(int(str(a[-1]) + str(i))):
return False
return True
starting_harshad = range(1, 10)
total_harshad = [starting_harshad]
while True:
temp_harshad = []
for i in total_harshad[-1]:
for k in range(10):
temp = add_one(i, k)
if check_harshad(temp):
temp_harshad = temp_harshad + [temp]
total_harshad.append(temp_harshad)
if len(str(total_harshad[-1][0])) >= 13:
break
total_strong_harshad = []
for i in total_harshad:
prime_list = prime_sieve(10**(int(math.ceil(len(str(i[0])) / 2))), [])
for j in i:
S = 0
for k in str(j):
S += int(k)
if is_prime(j / S, prime_list):
total_strong_harshad.append(j)
total_strong_harshad_primes = []
S = 0
j = 0
for i in total_strong_harshad:
print i
if len(str(i)) != j:
prime_list = prime_sieve(10**(int(math.ceil((len(str(i)) + 2) / 2))),
[])
from find_prime_factorization import prime_sieve
from find_prime_factorization import is_prime
import time
t = time.time()
primes_list = prime_sieve(10**5, [])
b_primes = prime_sieve(10**3, [])
maxi = 0
for a in range(-1000, 1000):
for b in b_primes:
count = 0
n = 0
while True:
val = n**2 + a * n + b
if val > 1 and is_prime(val, primes_list):
count += 1
n += 1
else:
if count > maxi:
maxi = count
params = (a, b)
break
#print list_of_n
print params, maxi
print params[0] * params[1]
print time.time() - t
from find_prime_factorization import prime_sieve
from PEprob41 import is_prime
from find_prime_factorization import is_prime
import math
import time
t = time.time()
n = 10000
primes = prime_sieve(n, [])
def gen_composite_numbers(n):
primes = prime_sieve(n, [])
for i in range(4, n):
if i not in primes and i % 2 != 0:
yield i
def squares(n):
square_list = []
for i in range(1, int(math.sqrt(n))):
square_list.append(i**2)
return square_list
square_list = squares(n)
for i in gen_composite_numbers(n):
setting = False
for j in primes:
for k in square_list:
import time
from find_prime_factorization import prime_sieve
prime_list = prime_sieve(5, [])
print prime_list
def find_number(n):
if n > 10**8:
return
else:
global count
count += 1
for p in prime_list:
find_number(n * p)
count = 0
for i in prime_list:
print i
find_number(i)
print count
def gen_composite_numbers(n):
primes = prime_sieve(n, [])
for i in range(4, n):
if i not in primes and i % 2 != 0:
yield i
import time
from find_prime_factorization import get_prime_factors
from find_prime_factorization import prime_sieve
def number_of_poss_sols(n):
prime_factors = get_prime_factors(n, prime_list)
p = 1
for i in prime_factors:
p *= i[1] * 2 + 1
if n % 2 == 0:
number_of_sols = (p + 1) / 2
else:
number_of_sols = p / 2
return number_of_sols
t = time.time()
prime_list = prime_sieve(1000, [])[:15]
print prime_list
p = 1260
print number_of_poss_sols(p)
print time.time() - t
from find_prime_factorization import prime_sieve
from find_prime_factorization import is_prime
import time
t = time.time()
prime_list = prime_sieve(10**5, [])
number_count = 1
prime_count = 0
i = 1
j = 2
spiral_length = 1
while True:
for dummy in range(4):
i += j
if is_prime(i, prime_list):
prime_count += 1
number_count += 1
spiral_length += 2
if float(prime_count) / number_count < 0.1:
print spiral_length
break
j += 2
print time.time() - t
tempthree = (p - 1) / 2
while True:
if tempthree % 3 == 0:
pfour = (-tempthree / 3) % p
tempfour = pfour % p
break
else:
tempthree += p
while True:
if tempfour % 4 == 0:
pfive = (-tempfour / 4) % p
break
else:
tempfour += p
return (pthree + pfour + pfive) % p
t_start = time.time()
prime_list = prime_sieve(10**8, [])[2:]
t1 = time.time()
final = 0
for p in prime_list:
final += test_final(p)
print final
print time.time() - t1, time.time() - t_start
