def circular_primes(stop: int) -> Iterable[int]:
primes_stop = max_number(number_digits_count(stop))
primes_set = set(prime_numbers(primes_stop))
def circular(prime_number: int) -> bool:
digits = tuple(number_to_digits(prime_number))
rotated_digits = (rotate(digits, position)
for position in range(len(digits)))
for rotated_prime in map(digits_to_number, rotated_digits):
if rotated_prime not in primes_set:
return False
return True
yield from filter(circular, prime_numbers(stop))
def primes_pairs(stop: int) -> Iterable[Tuple[int, int]]:
prime_numbers_generator = prime_numbers(stop)
# we're skipping 2
# because right concatenation with it
# always gives even (hence non-prime) number
next(prime_numbers_generator)
prime_numbers_set = set(prime_numbers_generator)
numbers_by_digits_count = collect_mapping(
map_tuples(prime_numbers_set, function=number_digits_count))
def primes_paired(prime_number: int, other_prime_number: int) -> bool:
left_concatenation = int(str(prime_number) + str(other_prime_number))
right_concatenation = int(str(other_prime_number) + str(prime_number))
return (left_concatenation in prime_numbers_set
and right_concatenation in prime_numbers_set)
max_digits_count = number_digits_count(max(prime_numbers_set))
for digits_count in range(1, max_digits_count // 2 + 1):
numbers = numbers_by_digits_count[digits_count]
max_candidates_digits_count = max_digits_count - digits_count + 1
for candidates_digits_count in range(digits_count,
max_candidates_digits_count):
candidates = numbers_by_digits_count[candidates_digits_count]
pairs = list(
star_filter(primes_paired, product(numbers, candidates)))
for pair in pairs:
yield pair
# pairing relation is symmetric
yield reversed(pair)
def main():
print "\n\n___ Задание 6: Простые числа " + "_" * 15
max_limit = 10000
print "max limit:", max_limit
prime_numbers_list = prime_numbers(max_limit)
result = ' '.join(prime_numbers_list)
print result
def main():
print "\n\n___ Задание 6: Простые числа " + "_"*15
max_limit = 10000
print "max limit:", max_limit
prime_numbers_list = prime_numbers(max_limit)
result = ' '.join(prime_numbers_list)
print result
def prime_digit_replacements(stop: int) -> Iterable[int]:
numbers = list(prime_numbers(stop))
numbers_digits = map(tuple, map(number_to_digits, numbers))
digits_wildcards = dict()
for number, digits in zip(numbers, numbers_digits):
for wildcard in generate_wildcards(digits):
digits_wildcards.setdefault(wildcard, []).append(number)
return digits_wildcards.values()
def dict_sum_divisors(n):
all_primes = prime_numbers(n)
sum_divisors = {}
for num in range(2, (n + 1)):
if num not in all_primes:
divisors = get_divisors(num, all_primes)
sum_divisors[num] = np.sum(divisors)
return sum_divisors
def prime_permutations(*,
start: int,
stop: int,
increment: int) -> Iterable[Tuple[int, int, int]]:
prime_numbers_set = set(filter(partial(operator.le, start),
prime_numbers(stop)))
for number in filter(partial(operator.ge, 10_000 - increment * 2),
prime_numbers_set):
sorted_digits = sorted(number_to_digits(number))
second_number = number + increment
third_number = second_number + increment
second_number_digits = sorted(number_to_digits(second_number))
third_number_digits = sorted(number_to_digits(third_number))
if sorted_digits == second_number_digits == third_number_digits:
if second_number in prime_numbers_set and third_number in prime_numbers_set:
yield number, second_number, third_number
def consecutive_prime_numbers_decompositions(stop: int
) -> Iterable[List[int]]:
numbers = list(prime_numbers(stop))
# set lookups are faster than list ones
numbers_set = set(numbers)
stop_cube_root = int(stop ** (1 / 3))
for position in range(len(numbers)):
numbers_sublist = numbers[position:]
numbers_sums = filter(partial(operator.ge, stop),
accumulate(numbers_sublist))
sequence_length = 0
for index, numbers_sum in enumerate(numbers_sums,
start=1):
if numbers_sum in numbers_set:
sequence_length = index
# TODO: find explanation for this heuristic
if sequence_length < stop_cube_root:
break
if sequence_length > 1:
yield numbers_sublist[:sequence_length]
Dict)
from utils import (prime_numbers,
digits_to_number,
number_to_digits)
def sub_string_divisible_numbers(*,
digits: Iterable[int],
slicers_by_divisors: Dict[int, slice]
) -> Iterable[int]:
for digits in permutations(digits):
number = digits_to_number(digits)
digits = list(number_to_digits(number))
for divisor, slicer in slicers_by_divisors.items():
digits_slice = digits[slicer]
sliced_number = digits_to_number(digits_slice)
if sliced_number % divisor:
break
else:
yield number
primes_generator = prime_numbers(18)
slicers_by_divisors = {next(primes_generator): slice(start - 1, start + 2)
for start in range(2, 9)}
assert sum(sub_string_divisible_numbers(
digits=range(10),
slicers_by_divisors=slicers_by_divisors)) == 16_695_334_890
def sum_of_primes(stop: int) -> int:
return sum(prime_numbers(stop))
from utils import (prime_numbers, digits_to_number, number_to_digits)
pandigits = {digit: set(range(1, digit + 1)) for digit in range(1, 10)}
def is_pandigital(number: int) -> bool:
digits = list(number_to_digits(number))
digits_set = set(digits)
if len(digits) > len(digits_set):
return False
max_digit = max(digits_set)
return not (pandigits[max_digit] ^ digits_set)
pandigital_primes = filter(
is_pandigital,
# 9-digit pandigital prime doesn't exist
# since
# 1 + 2 + ... + 9 = 45
# => it will be always divided by 3 and 9
prime_numbers(digits_to_number(range(8, 0, -1)), reverse=True))
assert next(pandigital_primes) == 7_652_413
def is_prime_and_twice_square_numbers_sum(odd_number: int) -> bool:
for prime_number in prime_numbers(odd_number):
square = (odd_number - prime_number) // 2
if is_perfect_square(square):
return True
return False
import numpy as np from utils import prime_numbers, get_prime_factors n = 600851475143 prime_list = prime_numbers(int(np.sqrt(n) + 1)) print(np.max(get_prime_factors(n, prime_list)))
from utils import prime_numbers
def is_prime(n):
prime = True
for num in range(2, int(n / 2)):
if n % num == 0:
prime = False
break
return prime
def test_list_prime(prime_numbers):
not_prime = True
ind = 0
while not_prime and ind <= (prime_numbers.shape[0] - 1):
if not is_prime(prime_numbers[ind]):
not_prime = False
print(f'{prime_numbers[ind]} No es primo')
ind += 1
if not_prime:
print('Son primos')
prime_num = prime_numbers(5000)
supp_array = np.concatenate([prime_num, np.array([4600])])
print(prime_num)
test_list_prime(prime_num)
def solve(n):
primes = prime_numbers(int(math.ceil(math.sqrt(n))))
for prime in reversed(primes):
if n % prime == 0:
return prime
def max_consecutive_primes_count_coefficients(stop: int) -> Tuple[int, int]:
formulas_coefficients = product(range(-stop, stop),
prime_numbers(stop + 1))
return max(formulas_coefficients, key=consecutive_quadratic_primes_count)
4. Find disjoint sets in the Graph
Note - Comparison between Union-find and Undirected-graph on large Dataset:
UnionFind - 6m 14s
Undirected Graph - 5m37s
"""
import os
import sys
import math
sys.path.append(os.path.abspath('./src/helpers'))
from utils import prime_numbers
from union_find import UnionFind
f = open(sys.argv[1])
T = int(f.readline().strip())
for cc in range(T):
# integer lists
A, B, P = map(int, f.readline().strip().split(" "))
p_nums = prime_numbers(min(B/2 + 1, B - A)) - set(range(P))
uf = UnionFind()
for i in p_nums:
start = int(i*(math.ceil(A/float(i))))
for j in range(start + i, B+1, i):
uf.union(start, j)
out = (B - A + 1 - uf.number_of_items() + uf.number_of_roots())
print("Case #%d: %s" % (cc+1, str(out)))
f.close()
