Пример #1
0
def abondant(n):
    if n == 1:
        return False
    elif n == 2:
        return False
    elif sum(Gene.diviseurs(n)) > n:
        return True
    else:
        return False
Пример #2
0
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
Пример #3
0
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)
Пример #4
0
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
Пример #5
0
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)
Пример #6
0
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)
Пример #7
0
    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.
Пример #8
0
    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.
Пример #9
0

# 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.
Пример #10
0
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.
Пример #11
0
    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.
Пример #12
0
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.
Пример #13
0
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.
Пример #14
0
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.
Пример #15
0
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.
Пример #16
0
        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.
Пример #17
0
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.
Пример #18
0
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
Пример #19
0
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.
Пример #20
0
# 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.
Пример #21
0
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.
Пример #22
0
    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()
Пример #23
0
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.
Пример #24
0
           [
               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.
Пример #25
0
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.
Пример #26
0
        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.
Пример #27
0
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.
Пример #28
0
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.
Пример #29
0
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.
Пример #30
0
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.