def compute(): isprime = eulerlib.list_primality(10000) # Cache for small numbers digits = list(range(1, 10)) def count_prime_sets(startindex, prevnum): if startindex == len(digits): return 1 else: result = 0 for split in range(startindex + 1, len(digits) + 1): num = int("".join(map(str, digits[startindex : split]))) if num > prevnum and is_prime(num): result += count_prime_sets(split, num) return result def is_prime(n): if n < len(isprime): return isprime[n] else: return eulerlib.is_prime(n) ans = 0 while True: ans += count_prime_sets(0, 0) if not next_permutation(digits): break return str(ans)
def compute(): LIMIT = 10**8 ans = 0 isprime = eulerlib.list_primality(LIMIT - 1) # Search all possible x's. Note that a + 1 = x * y * y >= x. Furthermore, a < b, so a + 1 <= b. # Thus if x >= LIMIT, then LIMIT <= a + 1 <= b. With b >= LIMIT, no candidates are possible. for x in range(1, LIMIT): # Search all possible y's. Notice that when y increases, 'a' strictly increases. # So when some y generates an 'a' such that a >= LIMIT, no candidates are possible with higher values of y. for y in itertools.count(1): a = x * y * y - 1 if a >= LIMIT: break if not isprime[a]: continue # Search all valid z's. We require z > y and gcd(y, z) = 1. Notice that when z increases, c strictly increases. # So when some z generates a c such that c >= LIMIT, no candidates are possible with higher values of z. for z in itertools.count(y + 1): if fractions.gcd(y, z) != 1: continue c = x * z * z - 1 if c >= LIMIT: break # Check whether (a, b, c) is a solution b = x * y * z - 1 if isprime[b] and isprime[c]: ans += a + b + c return str(ans)
def compute(): LIMIT = 10**8 ans = 0 isprime = eulerlib.list_primality(LIMIT - 1) # Search all possible x's. We know that c = x * z * z - 1. With the requirement c < LIMIT, we have x * z * z <= LIMIT. # Because z > y > 0, we know z >= 2. So at the very least we require x * 4 <= LIMIT. This implies x <= floor(LIMIT/4). for x in range(1, LIMIT // 4 + 1): # Search all possible y's. Notice that when y increases, 'a' strictly increases. # So when some y generates an 'a' such that a >= LIMIT, no candidates are possible with higher values of y. for y in itertools.count(1): a = x * y * y - 1 if a >= LIMIT: break if not isprime[a]: continue # Search all valid z's. We require z > y and gcd(y, z) = 1. Notice that when z increases, c strictly increases. # So when some z generates a c such that c >= LIMIT, no candidates are possible with higher values of z. for z in itertools.count(y + 1): if fractions.gcd(y, z) != 1: continue c = x * z * z - 1 if c >= LIMIT: break # Check whether (a, b, c) is a solution if isprime[c]: b = x * y * z - 1 if isprime[b]: ans += a + b + c return str(ans)
def compute(): isprime = eulerlib.list_primality(10000) # Cache for small numbers digits = list(range(1, 10)) def count_prime_sets(startindex, prevnum): if startindex == len(digits): return 1 else: result = 0 for split in range(startindex + 1, len(digits) + 1): num = int("".join(map(str, digits[startindex:split]))) if num > prevnum and is_prime(num): result += count_prime_sets(split, num) return result def is_prime(n): if n < len(isprime): return isprime[n] else: return eulerlib.is_prime(n) ans = 0 while True: ans += count_prime_sets(0, 0) if not eulerlib.next_permutation(digits): break return str(ans)
def compute(): START_NUM = 1 END_NUM = 500 CROAK_SEQ = "PPPPNNPPPNPPNPN" NUM_JUMPS = len(CROAK_SEQ) - 1 NUM_TRIALS = 2**NUM_JUMPS globalnumerator = 0 isprime = eulerlib.list_primality(END_NUM) for i in range(START_NUM, END_NUM + 1): for j in range(NUM_TRIALS): pos = i trialnumerator = 1 if isprime[pos] == (CROAK_SEQ[0] == 'P'): trialnumerator *= 2 for k in range(NUM_JUMPS): if pos <= START_NUM: pos += 1 elif pos >= END_NUM: pos -= 1 elif (j >> k) & 1 == 0: pos += 1 else: pos -= 1 if isprime[pos] == (CROAK_SEQ[k + 1] == 'P'): trialnumerator *= 2 globalnumerator += trialnumerator globaldenominator = (END_NUM + 1 - START_NUM) * 2**NUM_JUMPS * 3**len(CROAK_SEQ) ans = fractions.Fraction(globalnumerator, globaldenominator) return str(ans)
def compute(): primes = eulerlib.list_primality(999999) def is_circular_prime(n): s = str(n) return all(primes[int(s[i:] + s[:i])] for i in range(len(s))) return sum(1 for i in range(1000000) if is_circular_prime(i))
def compute(): primes = eulerlib.list_primality(999999) def is_truncatable(num): return all(primes[int(str(num)[:i])] for i in range(1, len(str(num)))) and all( primes[int(str(num)[i:])] for i in range(len(str(num)))) return sum(i for i in range(10, 999999) if is_truncatable(i))
def compute(): isprime = eulerlib.list_primality(999999) def is_circular_prime(n): s = str(n) return all(isprime[int(s[i:] + s[:i])] for i in range(len(s))) ans = sum(1 for i in range(len(isprime)) if is_circular_prime(i)) return str(ans)
def compute(): isprime = eulerlib.list_primality(999999) def is_circular_prime(n): s = str(n) return all(isprime[int(s[i : ] + s[ : i])] for i in range(len(s))) ans = sum(1 for i in range(len(isprime)) if is_circular_prime(i)) return str(ans)
def calc(): isprime = eulerlib.list_primality(999999) def s(n): k = str(n) return all(isprime[int(k[i:] + k[:i])] for i in range(len(k))) a = sum(1 for i in range(len(isprime)) if s(i)) return str(a) print(calc())
def compute(): LIMIT = 10**8 isprime = eulerlib.list_primality(LIMIT + 1) def is_prime_generating(n): return all( n % d != 0 or isprime[d + n // d] for d in range(2, eulerlib.sqrt(n) + 1)) ans = sum(n for n in range(LIMIT + 1) if isprime[n + 1] and is_prime_generating(n)) return str(ans)
def compute(): primes = eulerlib.list_primality(1000000) for i in range(33, 1000000, 2): if primes[i]: continue isOk = True for j in range(1, int(pow(i / 2, 1 / 2)) + 1): if primes[i - j * j * 2]: isOk = False break if isOk: print(i) break
def compute(): LIMIT = 10000 isprime = eulerlib.list_primality(LIMIT - 1) for base in range(1000, LIMIT): if isprime[base]: for step in range(1, LIMIT): a = base + step b = a + step if a < LIMIT and isprime[a] and has_same_digits(a, base) \ and b < LIMIT and isprime[b] and has_same_digits(b, base) \ and (base != 1487 or a != 4817): return str(base) + str(a) + str(b) raise RuntimeError("Not found")
def compute(): isprime = eulerlib.list_primality( 999999) # List of True, False,.... for whether each number is prime. def is_circular_prime(n): s = str(n) # Returns true if all elements pass a test: return all(isprime[int(s[i:] + s[:i])] for i in range(len(s))) # Cycling ans = sum( 1 # Ahhh instead of i for i in .... we're just adding 1 each time for i in range(len(isprime)) if is_circular_prime(i)) return str(ans)
def compute(): primes = eulerlib.list_primality(10000) for i in range(1000, 10000): if not primes[i]: continue changeList = createList(str(i)) for j in changeList: if j <= i: continue if list.__contains__( changeList, i + (j - i) * 2) and primes[j] and primes[i + (j - i) * 2]: print(str(i) + str(j) + str(i + (j - i) * 2)) break
def compute(): LIMIT = 5000 MODULUS = 10**16 # Use dynamic programming. count[i] is the number of subsets of primes with the sum of i, modulo MODULUS. count = [0] * (LIMIT**2 // 2) count[0] = 1 s = 0 # Sum of all primes seen so far, and thus the highest index among nonzero entries in 'count' for p in eulerlib.list_primes(LIMIT): for i in range(s, -1, -1): count[i + p] = (count[i + p] + count[i]) % MODULUS s += p isprime = eulerlib.list_primality(len(count)) ans = sum(count[i] for i in range(len(count)) if isprime[i]) % MODULUS return str(ans)
def compute(): ans = 0 isprime = eulerlib.list_primality(999999) primes = eulerlib.list_primes(999999) consecutive = 0 for i in range(len(primes)): sum = primes[i] consec = 1 for j in range(i + 1, len(primes)): sum += primes[j] consec += 1 if sum >= len(isprime): break if isprime[sum] and consec > consecutive: ans = sum consecutive = consec return str(ans)
def compute(): START_NUM = 1 END_NUM = 500 CROAK_SEQ = "PPPPNNPPPNPPNPN" assert 0 <= START_NUM < END_NUM assert 1 <= len(CROAK_SEQ) NUM_JUMPS = len(CROAK_SEQ) - 1 NUM_TRIALS = 2**NUM_JUMPS globalnumerator = 0 isprime = eulerlib.list_primality(END_NUM) # For each starting square for i in range(START_NUM, END_NUM + 1): # For each sequence of jumps for j in range(NUM_TRIALS): # Set initial position and croak pos = i trialnumerator = 1 if isprime[pos] == (CROAK_SEQ[0] == 'P'): trialnumerator *= 2 # Simulate each jump and croak for k in range(NUM_JUMPS): if pos <= START_NUM: pos += 1 # Forced move elif pos >= END_NUM: pos -= 1 # Forced move elif (j >> k) & 1 == 0: pos += 1 # Chosen move else: pos -= 1 # Chosen move # Multiply the running probability by 2/3 if primeness of current position # matches croak sequence at current index, otherwise multiply by 1/3 if isprime[pos] == (CROAK_SEQ[k + 1] == 'P'): trialnumerator *= 2 globalnumerator += trialnumerator # Calculate final probability fraction globaldenominator = (END_NUM + 1 - START_NUM) * 2**NUM_JUMPS * 3**len(CROAK_SEQ) ans = fractions.Fraction(globalnumerator, globaldenominator) return str(ans)
def compute(): primes = eulerlib.list_primes(1000000) isPrimes = eulerlib.list_primality(1000000) max = 0 maxConsecutive = 0 for i in range(len(primes)): sum = 0 length = 0 for j in range(i, len(primes)): sum += primes[j] length += 1 if sum > 1000000: break if isPrimes[sum]: if length > maxConsecutive: max = sum maxConsecutive = length print(max)
def compute(): primes = eulerlib.list_primality(7071) helo = [False] * (5 * 10**7) for i in range(7071): if primes[i]: for j in range(368): if i**2 + j**3 > len(helo) - 1: break if primes[j]: for k in range(84): if i**2 + j**3 + k**4 > len(helo) - 1: break if primes[k]: helo[i**2 + j**3 + k**4] = True ans = 0 for i in range(len(helo)): if helo[i]: ans += 1 return ans
def compute(): isprime = eulerlib.list_primality(1000000) for i in range(len(isprime)): if not isprime[i]: continue n = [int(c) for c in str(i)] for mask in range(1 << len(n)): digits = do_mask(n, mask) count = 0 for j in range(10): if digits[0] != 0 and isprime[to_number(digits)]: count += 1 digits = add_mask(digits, mask) if count == 8: digits = do_mask(n, mask) for j in range(10): if digits[0] != 0 and isprime[to_number(digits)]: return str(to_number(digits)) digits = add_mask(digits, mask) raise AssertionError("Not found")
def compute(): LIMIT = 10**7 isprime = eulerlib.list_primality(LIMIT) # pathmax[i] = None if i is not prime or i is not connected to 2. # Otherwise, considering all connection paths from 2 to i and for each path computing # the maximum number, pathmax[i] is the minimum number among all these maxima. pathmax = [None] * len(isprime) # Process paths in increasing order of maximum number queue = [(2, 2)] while len(queue) > 0: pmax, n = heapq.heappop(queue) if pathmax[n] is not None and pmax >= pathmax[n]: # This happens if at the time this update was queued, a better # or equally good update was queued ahead but not processed yet continue # Update the target node and explore neighbors pathmax[n] = pmax # Try all replacements of a single digit, including the leading zero. # This generates exactly all (no more, no less) the ways that a number m is connected to n. digits = to_digits(n) tempdigits = list(digits) for i in range(len(tempdigits)): # For each digit position for j in range(10): # For each digit value tempdigits[i] = j m = to_number(tempdigits) nextpmax = max(m, pmax) if m < len(isprime) and isprime[m] and (pathmax[m] is None or nextpmax < pathmax[m]): heapq.heappush(queue, (nextpmax, m)) tempdigits[i] = digits[i] # Restore the digit ans = sum(i for i in range(len(isprime)) if (isprime[i] and (pathmax[i] is None or pathmax[i] > i))) return str(ans)
def compute(): LIMIT = 10**7 isprime = eulerlib.list_primality(LIMIT) # pathmax[i] = None if i is not prime or i is not connected to 2. # Otherwise, considering all connection paths from 2 to i and for each path computing # the maximum number, pathmax[i] is the minimum number among all these maxima. pathmax = [None] * len(isprime) # Process paths in increasing order of maximum number queue = [(2, 2)] while len(queue) > 0: pmax, n = heapq.heappop(queue) if pathmax[n] is not None and pmax >= pathmax[n]: # This happens if at the time this update was queued, a better # or equally good update was queued ahead but not processed yet continue # Update the target node and explore neighbors pathmax[n] = pmax # Try all replacements of a single digit, including the leading zero. # This generates exactly all (no more, no less) the ways that a number m is connected to n. digits = to_digits(n) tempdigits = list(digits) for i in range(len(tempdigits)): # For each digit position for j in range(10): # For each digit value tempdigits[i] = j m = to_number(tempdigits) nextpmax = max(m, pmax) if m < len(isprime) and isprime[m] and (pathmax[m] is None or nextpmax < pathmax[m]): heapq.heappush(queue, (nextpmax, m)) tempdigits[i] = digits[i] # Restore the digit ans = sum(i for i in range(len(isprime)) if isprime[i] and (pathmax[i] is None or pathmax[i] > i)) return str(ans)
def compute(): TARGET = 500500 MODULUS = 500500507 isprime = eulerlib.list_primality(7376507) # 500500th (1-based) prime number queue = [] nextprime = 2 heapq.heappush(queue, nextprime) ans = 1 for _ in range(TARGET): item = heapq.heappop(queue) ans *= item ans %= MODULUS heapq.heappush(queue, item**2) if item == nextprime: nextprime += 1 while not isprime[nextprime]: nextprime += 1 heapq.heappush(queue, nextprime) return str(ans)
import eulerlib, itertools def compute(): ans = max(((a, b) for a in range(-999, 1000) for b in range(2, 1000)), key=count_consecutive_primes) return str(ans[0] * ans[1]) def count_consecutive_primes(ab): a, b = ab for i in itertools.count(): n = i * i + i * a + b if not is_prime(n): return i isprimecache = eulerlib.list_primality(1000) def is_prime(n): if n < 0: return False elif n < len(isprimecache): return isprimecache[n] else: return eulerlib.is_prime(n) if __name__ == "__main__": print(compute())
import eulerlib, itertools def calc(): ans = max(((a, b) for a in range(-999, 1000) for b in range(2, 1000)), key=ppc) return str(ans[0] * ans[1]) def ppc(ab): #счет простых чисел a, b = ab for i in itertools.count(): n = i * i + i * a + b if not is_prime(n): return i main_c = eulerlib.list_primality(1000) #основной кеш def is_prime(n): if n < 0: return False elif n < len(main_c): return main_c[n] else: return eulerlib.is_prime(n) print(calc())
import eulerlib, sys if sys.version_info.major == 2: range = xrange isprime = eulerlib.list_primality(999999) def compute(): ans = sum(1 for i in range(len(isprime)) if is_circular_prime(i)) return str(ans) def is_circular_prime(n): s = str(n) return all(isprime[int(s[i:] + s[:i])] for i in range(len(s))) if __name__ == "__main__": print(compute())
# # Solution to Project Euler problem 35 # by Project Nayuki # # http://www.nayuki.io/page/project-euler-solutions # https://github.com/nayuki/Project-Euler-solutions # import eulerlib, sys if sys.version_info.major == 2: range = xrange isprime = eulerlib.list_primality(999999) def compute(): ans = 0 for i in range(len(isprime)): if is_circular_prime(i): ans += 1 return str(ans) def is_circular_prime(n): s = str(n) for i in range(len(s)): if not isprime[int(s[i : ] + s[ : i])]: return False return True
def compute(): isprime = eulerlib.list_primality(20000000) ans = sum(sam_transitions_minus_max_transitions(i) for (i, p) in enumerate(isprime) if i >= 10000000 and p) return str(ans)
def compute(): isprime = eulerlib.list_primality(20000000) ans = sum( sam_transitions_minus_max_transitions(i) for (i, p) in enumerate(isprime) if i >= 10000000 and p) return str(ans)
def compute(): ans = max(((a, b) for a in range(-999, 1000) for b in range(2, 1000)), key=count_consecutive_primes) return str(ans[0] * ans[1]) def count_consecutive_primes(ab): a, b = ab for i in itertools.count(): n = i * i + i * a + b if not is_prime(n): return i isprimecache = eulerlib.list_primality(1000) def is_prime(n): if n < 0: return False elif n < len(isprimecache): return isprimecache[n] else: return eulerlib.is_prime(n) if __name__ == "__main__": print(compute())