def propriete(n):
deux = str(n) + str(2 * n)
if Nb.pandigital(deux):
return deux
trois = str(n) + str(2 * n) + str(3 * n)
if Nb.pandigital(trois):
return trois
return ""
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)
import time
from Utilitaire import Nb, Gene
# Résumé : On teste à chaque fois qui le nombre est un palindrome en base 10.
# Si c'est le cas, on teste s'il l'est en binaire.
# Si c'est aussi le cas, on incrémente le nombre à la somme.
if __name__ == '__main__':
temps_debut = time.time()
somme = 0
for i in range(0, 1000000):
if Nb.palindrome(i):
if Nb.palindrome(str(bin(i))[2:]):
somme += i
temps_fin = time.time()
Gene.rep(somme, temps_fin - temps_debut)
# Réponse : 872187 , en : 1.643 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.
# Résumé : On parcours une boucle de nombre impair en nombre impair.
# S'ils sont composés, on tente de les écrire comme la somme d'un premier et du double d'un carré.
# Une fois que a est déterminé, on isole b dans la formule pour trouver sa valeur,
# ça évite un passage inutile dans une boucle. i = premiers[a] + 2 * b ^ 2 <=> b = math.sqrt((i - premiers[a]) / 2)
if __name__ == '__main__':
temps_debut = time.time()
trouve = False
i = 7
premiers = [2, 3, 5, 7]
while not trouve:
i += 2 # nombre forcément impair
bon = False
if Nb.compose(i): # nombre composé
a = 0
while a < len(
premiers
) and not bon: # teste les valeurs de a qui sont premiers
b = math.sqrt((i - premiers[a]) / 2) # isole b
if b % 1 == 0 and i == premiers[a] + 2 * (
b**2): # si b est un entier et que l'égalité est vrai
bon = True
a += 1
else:
bon = True # si le nombre n'est pas composé, la conjecture n'est pas invalidée
if not bon:
trouve = True
# Résumé : Dans une liste, on ajoute les nombres pentagonaux par incrément.
# À chaque ajout, on teste si cette valeur peut se combiner avec un autre
# nombre de la liste pour que leur somme et leur différence soient un nombre pentagonale.
if __name__ == '__main__':
temps_debut = time.time()
n = 1
nb_penta = list()
nb_penta.append(penta(n))
n += 1
nb_penta.append(penta(n))
n += 1
trouve = False
while not trouve:
tempo = penta(n)
n += 1
for i in nb_penta:
if Nb.pentagonal(tempo - i) and Nb.pentagonal(tempo + i):
d = tempo - i
trouve = True
nb_penta.append(tempo)
temps_fin = time.time()
Gene.rep(d, temps_fin - temps_debut)
# Réponse : 5482660 , en : 4.044 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
from Utilitaire import Nb, Gene
def est_somme_abon(somme, liste):
i = 0
while i != len(liste) // 2:
terme = liste[i]
complement = somme - terme
if Gene.binary_search(liste, i, len(liste), complement) != -1:
return True
i += 1
return False
# Résumé : On liste tous les nombres abondants inférieurs à 28123 dans une liste.
# Puis, si un nombre entre 1 et 28123 ne peut être écrit comme la somme de cette liste, l'incrémenter à la somme.
if __name__ == '__main__':
temps_debut = time.time()
abon = [i for i in range(2, 28123) if Nb.abondant(i)]
somme = 0
for i in range(1, 28123):
if not est_somme_abon(i, abon):
somme += i
temps_fin = time.time()
Gene.rep(somme, temps_fin - temps_debut)
# Réponse : 4179871 , en : 71.007 s.
# 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()
# 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)
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 decomposition_facteur_possible(nb):
decomposable = False
j = 999
while j > 99 and not decomposable:
if nb % j == 0:
if len(str((nb // j))) == 3: # ou pas entiere
decomposable = True
j -= 1
return decomposable
# Résumé : En partant du plus gros nombre possible,
# on cherche un nombre qui est à la fois et palindrome
# et décomposable en deux facteurs composés de trois chiffres.
if __name__ == '__main__':
temps_debut = time.time()
trouve = False
i = 999 * 999 + 1
while not trouve:
i -= 1
if Nb.palindrome(i):
if decomposition_facteur_possible(i):
trouve = True
temps_fin = time.time()
Gene.rep(i, temps_fin - temps_debut)
# Réponse : 906609 , en : 0.129 s.
import time
from Utilitaire import Nb, Gene
def H(n):
return n * (2 * n - 1)
# Résumé : "Ainsi, les nombres hexagonaux sont simplement les nombres triangulaires d'indices impairs." - Wikipédia
# On cherche un nombre issu de l'intersection entre les nombres triangulaires, pentagonaux et hexagonaux.
# Les nombres hexagonaux sont un sous-ensemble des nombres triangulaires,
# nous n'avons donc qu'à trouver l'intersection entre les nombres hexagonaux et pentagonaux.
# On parcourt donc les nombres hexagonaux grâce à leur indice en testant
# à chaque fois grâce à un test simple s'ils sont aussi élément des nombres pentagonaux.
if __name__ == '__main__':
temps_debut = time.time()
trouve = False
i = 143
while not trouve:
i += 1
hexa = H(i)
if Nb.pentagonal(hexa):
trouve = True
temps_fin = time.time()
Gene.rep(hexa, temps_fin - temps_debut)
# Réponse : 1533776805 , en : 0.035 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)
return somme
def correspondance(char):
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
return alphabet.index(char) + 1
# Résumé : On parcourt tous les mots, s'ils sont triangulaires, on ajoute 1 au compteur.
if __name__ == '__main__':
temps_debut = time.time()
contenu = Gene.lire("Probleme042")
contenu = contenu[1:] + ",\"*\","
cmpt = 0
virgule = contenu.index(',')
mot = contenu[:virgule - 1]
while mot[0] != "*":
if Nb.triangulaire(nombre_mot(mot)):
cmpt += 1
contenu = contenu[virgule + 2:]
virgule = contenu.index(',')
mot = contenu[:virgule - 1]
temps_fin = time.time()
Gene.rep(cmpt, temps_fin - temps_debut)
# Réponse : 162 , en : 0.006 s.
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.
import time
from Utilitaire import Nb, Gene
# Résumé : On passe à travers les nombres de 2 à 10000
# exclu en charchant si chaque nombre à un nombre ami.
if __name__ == '__main__':
temps_debut = time.time()
somme = 0
a = 2
while a < 10000:
if Nb.amical(a):
somme += a
a += 1
temps_fin = time.time()
Gene.rep(somme, temps_fin - temps_debut)
# Réponse : 31626 , en : 0.244 s.
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.
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.