def solve(start, end, required_results): primes = primesieve.generate_n_primes(0x10000) results = [] x = start # 0b10000000000000000000000000000001 while x < end: # 0b100000000000000000000000000000000: deviders = [] str_x = bin(x)[2:] for b in range(2, 11): x_in_base = int(str_x, b) half_x = x_in_base >> 1 devider = 1 for p in primes: if p > half_x: break if 0 == x_in_base % p: devider = p break if 1 == devider: break deviders.append(devider) else: results.append( "%s %s" % (str_x, ' '.join([str(devider) for devider in deviders]).strip())) if len(results) >= required_results: break x += 2 return results
def largest_factor(num, number_of_spokes = 3): spokes = generate_n_primes(n) wheel = reduce(lambda x, y: x * y, spokes) composites = [] for i in range(1, wheel): if all( i % k != 0 for k in spokes): composites.append(i) for factor in spokes: if num % factor == 0 and n > factor: num //= factor while num % factor == 0: num //= factor if num == 1: return factor multiple = 0 limit = num**0.5 while factor < limit: for step in composites: factor = multiple + step if num % factor == 0 and factor > 1: num //= factor while num % factor == 0: num //= factor if num == 1: return factor limit = num**0.5 multiple += wheel return num
def solve(k, modulus=None): """Calculate the smallest number with 2**k divisors.""" n = 1 costs = primesieve.generate_n_primes(k) # more than necessary for i in range(k): cost = heapq.heappop(costs) heapq.heappush(costs, cost**2) n *= cost if modulus: n %= modulus return n
def compute_provisional_chunks(self, start_value, nvalues, nchunks, save_opts): logger.info("computing provisional chunks, starting from {}".format(start_value)) next_prime = primesieve.generate_n_primes(1, start_value) logger.info("next_prime for start_value={} is {}".format(start_value, next_prime)) m6_start = next_prime[0] % 6 logger.info("m6_start is {}".format(m6_start)) if m6_start == 1: logger.info("m6_start is {}, so using start_pos = 0".format(m6_start)) prime_start_pos = 0 else: logger.info("m6_start is {}, so using start_pos = 5".format(m6_start)) prime_start_pos = 5 linkedValues = HexValues(1, prime_start_pos, 1, 0) # magic starting "previous" values end_value = start_value + nvalues hfile = compute_hex_positions(start_value, end_value, linkedValues, save_opts) logger.info("save info: {}".format(save_opts)) self.compute_next_chunks(hfile, nvalues, nchunks - 1, save_opts)
def test_generate_n_primes(): assert primesieve.generate_n_primes(7) == [2, 3, 5, 7, 11, 13, 17]
def test_generate_n_primes(): assert primesieve.generate_n_primes(7) == [2,3,5,7,11,13,17] assert primesieve.generate_n_primes(5, 100) == [101,103,107,109,113]
def test_generate_n_primes(): assert primesieve.generate_n_primes(7) == [2,3,5,7,11,13,17]
def is_prime(num): if primesieve.generate_n_primes(1, num)[0] == num: pass else : return False return True
def is_prime(num): if primesieve.generate_n_primes(1, num)[0] == num: pass else: return False return True