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()