def abondant(n):
if n == 1:
return False
elif n == 2:
return False
elif sum(Gene.diviseurs(n)) > n:
return True
else:
return False
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
def lire_matrice():
chaine = Gene.lire("Probleme013")
i = 0
mat = "mat = ["
while i < 50 * 100:
if i % 50 == 0 and not i == 0:
mat += "," + str(int(chaine[i:i + 50]))
else:
mat += str(int(chaine[i:i + 50]))
i += 50
mat += "]"
print(mat)
def lister():
contenu = Gene.lire("Probleme022")
contenu = contenu[1:] + ",\"*\","
virgule = contenu.index(',')
mot = contenu[:virgule - 1]
noms = []
while mot[0] != "*":
noms.append(mot)
contenu = contenu[virgule + 2:]
virgule = contenu.index(',')
mot = contenu[:virgule - 1]
return noms
def lire_matrice():
chaine = Gene.lire("Probleme011")
i = 0
mat = "mat = ["
while i < 20 * 20 * 3:
if (i // 3) % 20 == 0:
mat += "[" + str(int(chaine[i:i + 2]))
elif (i // 3) % 20 == 19 and (i // 3) // 20 == 19:
mat += "," + str(int(chaine[i:i + 2])) + "]]"
elif (i // 3) % 20 == 19:
mat += "," + str(int(chaine[i:i + 2])) + "],"
else:
mat += "," + str(int(chaine[i:i + 2]))
i += 3
print(mat)
def lire_mat():
nombre = Gene.lire("Probleme067")
mat = "mat = ["
i = 0
while i < taille:
if i != 0:
mat += ",["
else:
mat += "["
j = 0
while j <= i:
pos = (i * (i + 1)) // 2 * 3 + j * 3
if j != i:
mat += str(int(nombre[pos:pos + 2])) + ", "
else:
mat += str(int(nombre[pos:pos + 2]))
j += 1
mat += "]"
i += 1
mat += "]"
print(mat)
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)
temps_fin = time.time()
Gene.rep(produit_final[1], temps_fin - temps_debut)
# Réponse : 100 , en : 0.000 s.
if chiffre_a == chiffre_b:
return True
return False
def propriete(n):
for i in range(2, 7):
if not meme_chiffre(n, n * i):
return False
return True
# Résumé : On parcourt les entiers positifs jusqu'à trouver un nombre qui vérifie la propriété.
# Pour tester si deux nombres sont formés des mêmes chiffres,
# on place les chiffres des nombres dans des ensemble, puis on teste l'égalité entre ces deux ensembles.
if __name__ == '__main__':
temps_debut = time.time()
trouve = False
i = 0
while not trouve:
i += 1
if propriete(i):
trouve = True
temps_fin = time.time()
Gene.rep(i, temps_fin - temps_debut)
# Réponse : 142857 , en : 0.778 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.
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.
while i < 12:
if debut == 0:
nb += 1
if i == 1 and bissex:
debut += mois[12]
else:
debut += mois[i]
debut %= 7
i += 1
return nb, debut
# Résumé : On teste si tous les premiers du mois du XXe sciècle étaient un dimanche
# par bonds du nombre de jours dans un mois.
# Les jours de la semaines sont numérotés de 0 (dimanche) à 6 (samedi).
if __name__ == '__main__':
temps_debut = time.time()
nb = 0
jour = 2 # le premier janvier 1901 était un mardi
for annee in range(1901, 2001):
bissex = est_bissexile(annee)
ajout, jour = nombre(jour, bissex)
nb += ajout
temps_fin = time.time()
Gene.rep(nb, temps_fin - temps_debut)
# Réponse : 171 , en : 0.000 s.
import time
from Utilitaire import Gene
# Résumé : La classe du dernier problème du dernier package de problème sert de modèle.
if __name__ == '__main__':
temps_debut = time.time()
# CODE ICI
temps_fin = time.time()
Gene.rep(-1, temps_fin - temps_debut)
# Réponse : -1 , en : -1 s.
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 ""
# Résumé : On parcourt les nombres en tentant de les décomposer en palindromes.
if __name__ == '__main__':
temps_debut = time.time()
pandigitals = set()
trouve = False
for i in range(1, 10000):
pan_tempo = propriete(i)
if pan_tempo != "":
pandigitals.add(pan_tempo)
max = max(pandigitals)
temps_fin = time.time()
Gene.rep(max, temps_fin - temps_debut)
# Réponse : 932718654 , en : 0.033 s.
from Utilitaire import Gene
def longueur_cycle(nb):
reste = 10
i = 0
# Calcule les décimales tant que le reste n'est pas égal à 10
while reste != 10 or i < 1:
reste = (reste % nb) * 10
i += 1
return i
# Résumé : Résolution très mathématique, la page Wikipédia "Développement décimal périodique" aide beaucoup.
# On calcule chaque cycle en ajoutant des dizaines au reste jusqu'à retomber sur un reste de 0
if __name__ == '__main__':
temps_debut = time.time()
max = 0
for i in range(3, 1000, 2):
if i % 5 != 0:
taille = longueur_cycle(i)
if max < taille:
max = taille
max_nb_cycle = i
temps_fin = time.time()
Gene.rep(max_nb_cycle, temps_fin - temps_debut)
# Réponse : 983 , en : 0.012 s.
if __name__ == '__main__':
temps_debut = time.time()
# lire_mat()
mat = [[75], [95, 64], [17, 47, 82], [18, 35, 87, 10], [20, 4, 82, 47, 65],
[19, 1, 23, 75, 3, 34], [88, 2, 77, 73, 7, 63, 67],
[99, 65, 4, 28, 6, 16, 70, 92],
[41, 41, 26, 56, 83, 40, 80, 70, 33],
[41, 48, 72, 33, 47, 32, 37, 16, 94, 29],
[53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14],
[70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57],
[91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48],
[63, 66, 4, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31],
[4, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 4, 23]]
ligne = taille - 1
while ligne > 0:
colonne = 0
while colonne < ligne:
if mat[ligne][colonne] > mat[ligne][
colonne + 1]: # si le nombre de gauche est le plus grand
mat[ligne - 1][colonne] += mat[ligne][colonne]
else: # si le nombre de droite est le plus grand
mat[ligne - 1][colonne] += mat[ligne][colonne + 1]
colonne += 1
ligne -= 1
temps_fin = time.time()
Gene.rep(mat[0][0], temps_fin - temps_debut)
# Réponse : 1074 , en : 0.000 s.
62184073572399794223406235393808339651327408011116,
66627891981488087797941876876144230030984490851411,
60661826293682836764744779239180335110989069790714,
85786944089552990653640447425576083659976645795096,
66024396409905389607120198219976047599490197230297,
64913982680032973156037120041377903785566085089252,
16730939319872750275468906903707539413042652315011,
94809377245048795150954100921645863754710598436791,
78639167021187492431995700641917969777599028300699,
15368713711936614952811305876380278410754449733078,
40789923115535562561142322423255033685442488917353,
44889911501440648020369068063960672322193204149535,
41503128880339536053299340368006977710650566631954,
81234880673210146739058568557934581403627822703280,
82616570773948327592232845941706525094512325230608,
22918802058777319719839450180888072429661980811197,
77158542502016545090413245809786882778948721859617,
72107838435069186155435662884062257473692284509516,
20849603980134001723930671666823555245252804609722,
53503534226472524250874054075591789781264330331690
]
somme = 0
for i in range(0, 100):
somme += int(
(str(mat[i]))[0:12]
) # on coupe la partie inutile du nombre pour calculer la somme
temps_fin = time.time()
Gene.rep((str(somme)[0:10]), temps_fin - temps_debut)
# Réponse : 5537376230 , en : 0.000 s.
import time
from Utilitaire import Gene
# Résumé : On parcourt toutes les valeurs possibles en testant si la combinaison dépasse le million.
if __name__ == '__main__':
temps_debut = time.time()
cmpt = 0
for n in range(23, 101): # 23 est le premier n permettant de dépasser le million
for r in range(4, n): # 4 est le premier r permettant de dépasser le million
if Gene.combinaison(n, r) > 1000000:
cmpt += 1
temps_fin = time.time()
Gene.rep(cmpt, temps_fin - temps_debut)
# Réponse : 4075 , en : 0.023 s.
import time
from Utilitaire import Gene
# Résumé : Parcours la chaine de caratères en incrémentant la multiplication de 13 nombres
# à la fois en conservant le plus grand produit. Si l'itérateur arrive sur un 0,
# il passe tous les produits possibles contenant ce dernier.
if __name__ == '__main__':
temps_debut = time.time()
taille_produit = 13
chaine_nombre = Gene.lire("Probleme008")
produit_max = 0
i = 0
while i < len(chaine_nombre) - (taille_produit - 1):
produit_temporaire = 1
j = 0
presence_zero = False
while j < taille_produit and not presence_zero:
if produit_temporaire == 0:
presence_zero = True # sort de la boucle si croise un 0
i += 2 * taille_produit - 2 # passe la section où il y a un 0
else:
produit_temporaire *= int(chaine_nombre[i + j]) # sinon continue sa recherche de 0
j += 1
if produit_max < produit_temporaire:
produit_max = produit_temporaire # si trouve un plus grand produit
import time
from Utilitaire import Gene
# Résumé : On passe de nombre triangulaire en nombre triangulaire
# en testant à chaque fois s'il ont plus de 500 diviseurs.
if __name__ == '__main__':
temps_debut = time.time()
objectif_diviseurs = 500
nb_tri = 0
nb_diviseurs = 0
n = 0
while nb_diviseurs < objectif_diviseurs:
n += 1
nb_tri += n
nb_diviseurs = len(Gene.diviseurs(nb_tri))
temps_fin = time.time()
Gene.rep(nb_tri, temps_fin - temps_debut)
# Réponse : 76576500 , en : 13.648 s.
# Résumé : On force la solution en testant toutes les possibilités.
# Notons qu'il n'y a pas de boucle pour le 1, on l'isole dans l'équation
# pour trouver sa valeur. J'aurais aimé trouver un algorithme plus optimisé
# (sûrement récursif) pour ce problème. Je m'y remettrai quand je pourrai.
if __name__ == '__main__':
temps_debut = time.time()
cmp = 0
total = 200
for a in range(0, total + 1, 200):
total = 200 - a
for b in range(0, total + 1, 100):
total = 200 - a - b
for c in range(0, total + 1, 50):
total = 200 - a - b - c
for d in range(0, total + 1, 20):
total = 200 - a - b - c - d
for e in range(0, total + 1, 10):
total = 200 - a - b - c - d - e
for f in range(0, total + 1, 5):
total = 200 - a - b - c - d - e - f
for g in range(0, total + 1, 2):
h = 200 - a - b - c - d - e - f - g
if h >= 0:
cmp += 1
temps_fin = time.time()
Gene.rep(cmp, temps_fin - temps_debut)
# Réponse : 73682 , en : 0.067 s.
import time
from Utilitaire import Gene
# Résumé : On parcourt les deux boucles en ajoutant les nouvelles puissances dans l'ensemble.
# Ensuit, on évalue la cadinalité de cet ensemble
if __name__ == '__main__':
temps_debut = time.time()
combinaisons = set()
for a in range(2, 101):
for b in range(2, 101):
combinaisons.add(a ** b)
temps_fin = time.time()
Gene.rep(len(combinaisons), temps_fin - temps_debut)
# Réponse : 9183 , en : 0.000 s.
somme = 0
for i in range(0, len(mot)):
somme += correspondance(mot[i])
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()
import time
from Utilitaire import Gene
# Résumé : Grace à la fonction "combinaison",
# on calcule possibilité de choisir 20 chemins vers le bas parmi les (20 * 2 =) 40 possibilités.
# Une fois les chemins vers le bas choisis, les chemins vers la droites sont à chaque fois les chemins non choisis.
if __name__ == '__main__':
temps_debut = time.time()
nb = 20
reponse = Gene.combinaison(20 * 2, 20)
temps_fin = time.time()
Gene.rep(reponse, temps_fin - temps_debut)
# Réponse : 137846528820 , en : 0.000 s.
[
88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32,
63, 93, 53, 69
],
[
4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32,
40, 62, 76, 36
],
[
20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85,
74, 4, 36, 16
],
[
20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16,
23, 57, 5, 54
],
[
1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1,
89, 19, 67, 48
]]
array = [
horizontale(mat),
verticale(mat),
diagonale_un(mat),
diagonale_deux(mat)
]
temps_fin = time.time()
Gene.rep(max(array), temps_fin - temps_debut)
# Réponse : 70600674 , en : 0.000 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.
for b in range(a, somme_max - 1):
c = math.sqrt(a**2 + b**2)
if c % 1 == 0:
somme = a + b + int(c)
liste.append(somme)
return liste
# Résumé : On commence par mettre dans une liste la somme de tous les triplets pytahoricients
# sont la somme est plue petite ou égale à 1000. Ensuite, on parcours cette liste en comptant
# le nombre de fois ou est chaque nombre de 12 à 1000.
if __name__ == '__main__':
temps_debut = time.time()
liste = triplets(1000)
max = 0
min = 3 + 4 + 5 # somme du plus petit triplet
for i in range(min, 1001, 2):
tempo = 0
for element in liste:
if element == i:
tempo += 1
if tempo > max:
max = tempo
somme_max = i
temps_fin = time.time()
Gene.rep(somme_max, temps_fin - temps_debut)
# Réponse : 840 , en : 0.926 s.
import time
from Utilitaire import Gene
# Résumé : On parcourt la suite en incrémentant chaque terme.
# Ensuite, on conserve uniquement les 10 derniers chiffres de la série.
# Le calcul de Sn de la suite n ^ n nous mènerait à une solution constante de O(1),
# mais je ne sais pas si une telle formule existe.
if __name__ == '__main__':
temps_debut = time.time()
somme = 0
for i in range(1, 1000):
somme += i ** i
somme = str(somme)
somme = somme[len(somme) - 10:]
temps_fin = time.time()
Gene.rep(somme, temps_fin - temps_debut)
# Réponse : 9110846700 , en : 0.041 s.
import time
from Utilitaire import Gene
# Résumé: On trouve le PPCM des nombres de 2 à 20.
# Pour se faire, on décompose les nombres composés (non premier) en multiples de premiers.
# Exemple : 6 n'est pas présent, car 2 et 3 le sont (6 = 2 * 3).
if __name__ == '__main__':
temps_debut = time.time()
multiples = 2**4 * 3**2 * 5 * 7 * 11 * 13 * 17 * 19 # PPCM des nombres de 2 à 20
temps_fin = time.time()
Gene.rep(multiples, temps_fin - temps_debut)
# Réponse : 232792560 , en : 0.000 s.
import time
from Utilitaire import Gene
# Résumé : On effectue la somme des carrés puis le carré de la somme,
# puis on calcule la différence entre le deuxième et le premier.
if __name__ == '__main__':
temps_debut = time.time()
fin = 100
somme_carre = fin * (fin + 1) * (2 * fin + 1) // 6
carre_somme = (fin * (fin + 1) / 2)**2
rep = int(carre_somme - somme_carre)
temps_fin = time.time()
Gene.rep(rep, temps_fin - temps_debut)
# Réponse : 25164150 , en : 0.000 s.
def sequence(n):
global valeurs
if n in valeurs:
return valeurs[n]
if n % 2 == 0:
valeurs[n] = 1 + sequence(n // 2)
else:
valeurs[n] = 2 + sequence((3 * n + 1) // 2)
return valeurs[n]
# Résumé : On passe à travers les nombres de 500K à 1M-1 inclusivement
# (ces nombres passeront forcément par les nombres de 1 à 500k-1, ils n'ont donc pas besoin d'être testés en plus).
# Aussi, on stock les longueur de Collatz qu'on obtient pour éviter de les comter deux fois.
# En plus, on effectue deux opérations d'un coup losqu'on tombe sur un nombre impaire
# étant donné qu'après la première opération on tombera forcément sur un nombre pair.
if __name__ == '__main__':
temps_debut = time.time()
max = 0
for i in range(1000000 // 2, 1000000):
tempo = sequence(i)
if max < tempo:
max = tempo
reponse = i
temps_fin = time.time()
Gene.rep(reponse, temps_fin - temps_debut)
# Réponse : 837799 , en : 1.748 s.
