def euler051(number_of_primes_in_family):
## Desde el primer primo de 2 cifras distintas
prime_generator = ef.generate_prime(13)
found = False
while found != True:
prime = next(prime_generator)
# print("#########################")
# print("[{}]".format(prime))
s = set()
for cipher in str(prime):
permutation_to_loop = str(prime).replace(cipher, "*")
###### SANITY CHECK: un * al final como mucho genera 4 primos
#
if permutation_to_loop[len(permutation_to_loop) - 1] != "*":
if permutation_to_loop not in s:
s.add(permutation_to_loop)
# print(permutation_to_loop)
if tests_iterations(permutation_to_loop,
number_of_primes_in_family) != None:
found = True
break
return prime
def euler070(top):
pgen = ef.generate_prime(2)
prime = next(pgen)
"""
Genero primos en principio hasta 10^7 / 2. Pero se que la solucion optima esta
cerca de primos que sean sqrt(10^7) porque la multiplicacion es maxima si ambos valores
valen lo mismo (pero no pueden porque no hay numero n y n-1 que sean permutacion)
Así que calculo primos hasta un poco mas que sqrt(10^7)
"""
P = []
while prime <= 3600:
P.append(prime)
prime = next(pgen)
"""
Dada una lista P= [2,3,5,7,11,13,17,19,23,29] (primos hasta la mitad de tope)
calcula las multiplicaciones 2 a 2 de elementos que no superen un tope
res es una tupla con n buscado y ratio minimo que se va actualizando por cada n y phi(n) permutados
φ(m.n) si m y n son primos es (m-1) . (n-1)
"""
res = 0, 2
for i, prime in enumerate(P):
for j in range(i + 1, len(P)):
n = prime * P[j]
if n > top:
break # este break me evita todas las combinaciones.
else:
phi = (prime - 1) * (P[j] - 1)
if ef.is_permutation(n, phi):
#print('N:{} ({}.{}) φ({})={} Ratio:{}'.format(n, prime, P[j], n, phi, n/phi))
if n / phi < res[1]:
res = n, n / phi
return res
def euler069(top):
maxVal = 0, 0
for n in range(2, top):
# En el diccionario sólo voy a ir guardando los PHIS
# Si N es primo, su phi es n-1 ya que todos los elementos antes que el son coprimos
if ef.is_prime(n):
#print("N:{} prime, φ({})={}".format(n, n, n-1))
PHI_D[n] = n - 1
QUO_D[n] = n / (n - 1)
else:
nAux = n
pgen = ef.generate_prime(2)
while nAux != 1:
prime = next(pgen)
if nAux % prime == 0:
phi = get_phi_mn(prime, int(nAux / prime))
# print("N:{} = {}.{} φ({})={}".format(n, prime, int(nAux/prime), n, phi))
PHI_D[n] = phi
QUO_D[n] = n / phi
if QUO_D[n] > maxVal[1]:
maxVal = n, QUO_D[n]
break
return maxVal
def euler50(top):
found = []
for i in range(2, top + 1):
gen_prime = generate_prime(i)
# print("**",i)
last_prime = 0
list_prime = []
prime_found = 1
while last_prime < top:
prime = next(gen_prime)
# print(prime)
list_prime.append(prime)
if True == is_prime(prime +
last_prime) and prime + last_prime < top:
# prime_found += 1
# print("LAST FOUND {} (+{}) ({}) ".format(prime+last_prime, prime, prime_found))
found.append((prime_found, prime + last_prime))
prime_found += 1
last_prime = prime + last_prime
# print("***************")
return (max(found))
def euler49():
# Genero solo los primos de 4 cifras.
gen = generate_prime(2)
final_list = []
while True:
prime = next(gen)
if len(str(prime)) == 4:
A = permutations(str(prime),4)
perm_dico={}
for permutation in A:
permutationInt = int("".join(permutation))
if is_prime(permutationInt) and len(str(permutationInt)) == 4:
perm_dico[permutationInt] = 1 + perm_dico.get(permutationInt, 0)
#if(len(perm_dico)>2):
# En este punto tengo listas de al menos 3 elementos, compuestas
# por un primo de 4 cifras y sus permutaciones que tb son primos
# pero pueden estar repetidas
# print(prime, " ",sorted(perm_dico))
B = sorted(perm_dico)
if B not in final_list:
# =============================================================================
# # Aqui puedo recorrer B, que es lo que inserto en la lista final.
# Si el procesamiento es bueno, ni siquiera me hace falta final_list
# En total son 174 listas de mas o menos 10 elementos.
# =============================================================================
final_list.append(B)
for i in range(len(B)):
for num in B[1+i:]:
D = (d(num, B[i]))
if B[i] +D in B and B[i] +2*D in B:
print("{}{}{}".format(B[i], B[i]+ D, B[i]+ 2*D))
if len(str(prime)) > 4:
break
import sys
sys.path.append('../')
sys.path.append('../../')
from Euler.EulerUtils import eulerFunctions as ef
from itertools import combinations
def is_concat_prime(m, n):
possible_primeL = int(str(m) + str(n))
possible_primeR = int(str(n) + str(m))
if ef.is_prime(possible_primeL) and ef.is_prime(possible_primeR):
return True
return False
prime_generator = ef.generate_prime(2)
prime_list = []
g2 = []
g3 = []
g4 = []
g5 = []
def euler060():
found = False
while found != True:
# 1 GENERO UN PRIMO
prime = next(prime_generator)