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