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)