import time
from Utilitaire import Gene
from Utilitaire import Nb
# Résumé : D'abord, on trouve la valeur des nouveaux nombres grâce à leur position relative
# à la diagonale inférieure droite. Ensuite, s'ils sont premiers, on les ajoute au compteur de nombres premiers.
# Après chaque itération, on calcule si le taux est sous 10%.
if __name__ == '__main__':
temps_debut = time.time()
taux = 1
taille_cote = 1
tot = 1 # compteur de nombres sur les diagonales
prem = 0 # compteur de nombres premiers sur les diagonales
while taux > 0.1:
taille_cote += 2
tot += 4
inf_droit = taille_cote**2
bond = taille_cote - 1
for no in range(1, 4): # test des nombres aux trois autres coins
if Nb.premier(inf_droit - (no * bond)):
prem += 1
taux = prem / tot # calcul du taux afin de savoir si on est sous les 10%
temps_fin = time.time()
Gene.rep(taille_cote, temps_fin - temps_debut)
# Réponse : 26241 , en : 9.326 s.
import numpy as np
from Utilitaire import Gene
from Utilitaire import Nb
# Résumé : Les problèmes 31, 76 et 77 sont presque les mêmes, voir problème 31 pour une meilleure explication.
if __name__ == '__main__':
temps_debut = time.time()
trouve = False
pieces = []
somme = 2
while not trouve:
if Nb.premier(
somme
): # si l'on rencontre un nombre premier, on l'ajoute à la liste
pieces.append(somme)
somme += 1 # puis on roule l'équivalent du problème 76 pour le nombre suivant
cmpt = np.zeros(somme + 1)
cmpt[0] = 1
for i in range(0, len(pieces)):
for j in range(pieces[i], somme + 1):
cmpt[j] += cmpt[j - pieces[i]]
if int(cmpt[-1]) > 5000:
trouve = True
temps_fin = time.time()
Gene.rep(somme, temps_fin - temps_debut)
import time
from Utilitaire import Nb, Gene
# Résumé : On passe à travers les nombres en comptant à l'aide d'un compteur chaque fois qu'on en trouve un premier.
# La recherche se fait par bonds de deux à partir d'un nombre impair (3) et le compteur commence à 1 à cause du seul
# nombre premier pair (2).
if __name__ == '__main__':
temps_debut = time.time()
compteur_premier = 2
nombre_teste = 3
dernier_premier = 10001
while compteur_premier != dernier_premier:
nombre_teste += 2
if Nb.premier(nombre_teste):
compteur_premier += 1
temps_fin = time.time()
Gene.rep(nombre_teste, temps_fin - temps_debut)
# Réponse : 104743 , en : 0.243 s.
# Résumé : On passe dans deux boucles en faisant varier a et b.
# Notons que le premier entier trouvé doit être premier losque le compteur est à 0.
# Quand n = 0 la fonction vaut 0 ^ 2 + a * 0 + b donc b. b ne peut donc pas être négatif.
if __name__ == '__main__':
temps_debut = time.time()
max = 0
produit = 0
for a in range(-1000, 1000):
for b in range(
3, 1001, 2
): # min b = 3 parce que le permier nombre premier doit être impair
cmpt = 1 # le premier entier 2 est déjà trouvé
suite_premier = True
while suite_premier:
if Nb.premier(fonction(a, b, cmpt)):
cmpt += 1
else:
if max < cmpt:
max = cmpt
produit = a * b
suite_premier = False
temps_fin = time.time()
Gene.rep(produit, temps_fin - temps_debut)
# Réponse : -59231 , en : 3.139 s.
b //= valeur
else:
i += 1
valeur = premiers[i]
return a, b
# Résumé : On parcourt tous les couples possibles en testant s'ils respectent la propriété.
# Si c'est le cas, on multiplie cette fraction au produit principal. On finit par
# réduire le produit principal et obtenir la valeur de son dénominateur.
if __name__ == '__main__':
temps_debut = time.time()
premiers = [2]
for i in range(3, 100, 2):
if Nb.premier(i):
premiers.append(i)
max = 0
produit_a = 1
produit_b = 1
for i in range(10,
100 // 2): # le nombre doit être composé de deux chiffres
for j in range(100 // 2,
100): # on évite de tester deux fois le même couple
if propriete(str(i), str(j)):
tempo = reduire(i, j, premiers)
produit_a *= tempo[0]
produit_b *= tempo[1]
produit_final = tempo = reduire(produit_a, produit_b, premiers)
# Résumé : Tant qu'on n'a pas trouvé les 11 premiers, on décompose les nombres premiers
# trouvés en testant si l'ensemble de leur décomposition est aussi premier.
if __name__ == '__main__':
temps_debut = time.time()
trouve = False
i = 11
premiers = [2, 3, 5, 7]
somme = 0
cmpt = 0
while cmpt < 11:
if Nb.premier(i):
premiers.append(
i) # on conserve les nombres premiers quand on les trouve
premiers_tronque = decompose(i)
bon = True
for element in premiers_tronque: # ajout beak a la main
if not Nb.premier(int(element)):
bon = False
if bon:
cmpt += 1
somme += i
i += 2
temps_fin = time.time()
Gene.rep(somme, temps_fin - temps_debut)
# Résumé : En partant de notre nombre de départ
# dès qu'on trouve un de ses facteurs premier,
# on le divise par celui-ci et on le garde en mémoire
# s'il est le plus grand trouvé. On recommence le
# même processus jusqu'à ce que le nombre restant
# soit premier ou qu'il soit plus petit que le plus
# grand facteur premier trouvé.
if __name__ == '__main__':
temps_debut = time.time()
nombre = 600851475143
recherche_facteur = 3 # car 2 ne fait pas partie de ses facteur premiers
trouve_facteur_premier = False
while not Nb.premier(
nombre): # tant qu'on a pas réduit le nombre à un facteur premier
while not trouve_facteur_premier and recherche_facteur <= math.sqrt(
nombre):
if nombre % recherche_facteur == 0:
trouve_facteur_premier = True
else:
recherche_facteur += 2
# après avoir trouvé un facteur premier,
# on divise le nombre par un de ses facteurs premier
nombre = nombre // recherche_facteur
trouve_facteur_premier = False
temps_fin = time.time()
def converstion_tuple(tup):
chaine = ''.join(tup)
return chaine
# Résumé : En partant des pandigitals de rend n, on diminue jusqu'à trouver un nombre premier.
# Pour chaque nombre de taille n, on parcourt toutes les permutations en ordre croissant en
# testant si elles sont éléments des nombres premiers.
if __name__ == '__main__':
temps_debut = time.time()
chaine = "123456789*"
perm = permutations(chaine)
max = 0
while max == 0: # tant qu'on a pas trouvé
chaine = chaine[:len(chaine) - 1]
perm = permutations(chaine)
max = 0
for i in perm: # parcours toutes les permutations de pandigitals
i = int(converstion_tuple(i))
if Nb.premier(
i
): # la liste étant en ordre croissant, le dernier trouvé est forcément le plus grand
max = i
temps_fin = time.time()
Gene.rep(max, temps_fin - temps_debut)
# Réponse : 7652413 , en : 0.691 s.
def lister_premiers(max):
liste = ["2"]
for i in range(3, max, 2):
if Nb.premier(i) and pas_pair(str(i)):
liste.append(str(i))
return liste
premiers = lister_premiers(1000000)
cmpt = 0
element = 0
while element < len(premiers): # On teste chaque premier
cercle = rotation(premiers[element]
) # cercle contient toutes les rotations possibles
premier_circulaire = True
nombre = 0
while nombre < len(cercle) and premier_circulaire:
derive = cercle[nombre]
if not Nb.premier(derive):
premier_circulaire = False # Dès qu'on trouve un nombre de cercle non premier on sort de la boucle
elif derive in premiers:
premiers.remove(
derive
) # On enlève chaque premier circulaire trouvé de la liste
nombre += 1
if premier_circulaire: # Si à cette étape premier_circulaire est toujours vrai, le test est positif
cmpt += 1
element += 1
temps_fin = time.time()
Gene.rep(cmpt, temps_fin - temps_debut)
# Réponse : 55 , en : 8.188 s.