def tests_iterations(permutation_to_loop, number_of_primes_in_family):
# print("tests_iterations ", permutation_to_loop)
if "*" in permutation_to_loop:
totalprimos = 0
total_no_primos = 0
found = None
for i in range(10):
#MIRAR SI ES PRIMO
num = int(permutation_to_loop.replace("*", str(i)))
###### SANITY CHECK: un * a la izquierda no puede ser 0
#
if len(str(num)) == len(permutation_to_loop):
if ef.is_prime(num):
totalprimos += 1
else:
total_no_primos += 1
# print("*****", num, ef.is_prime(num))
###### SANITY CHECK: Si hay mas de 4 no_primos,
# el maximo de primos de la iteracion es de 6
#
if total_no_primos > 10 - number_of_primes_in_family:
# print("Iteracion {} palma con {} primos".format(permutation_to_loop, totalprimos))
break
if totalprimos == number_of_primes_in_family:
# print(" FOUND!!!! iteracion [{}] con {} primos".format(permutation_to_loop, totalprimos))
found = permutation_to_loop
break
return found
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 euler058():
salto = 0
# A=[]
# B=[]
# C=[]
# D=[]
numsTotales = 1
numsPrimos = 0
ratio = 11 # Un numero mayor de 10... no muy elegante
length = 1 # Las longitudes van en impares
while ratio >= 10:
length += 2
salto += 2
a = length**2
d = a - salto
c = d - salto
b = c - salto
# A.append(a)
# D.append(d)
# C.append(c)
# B.append(b)
numsTotales += 4
if ef.is_prime(a):
numsPrimos += 1
if ef.is_prime(b):
numsPrimos += 1
if ef.is_prime(c):
numsPrimos += 1
if ef.is_prime(d):
numsPrimos += 1
# print(A)
# print(D)
# print(C)
# print(B)
ratio = (numsPrimos / numsTotales) * 100
# print("Longitud {}, Ratio {}".format(length, ratio))
return length
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
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