Algorithme d’Euclide python

Voici une implémentation python de l’algorithme d’euclide

Je l’ai trouvée sur https://github.com/Krycthus/Euclide/blob/master/euclide.py

###source = https://github.com/Krycthus/Euclide/blob/master/euclide.py

import sys
import math
import time 
from datetime import timedelta

#Cacule du PGCD
def pgcd(dividende, diviser) :
    quotien = sys.maxsize
    while (quotien != 0):
        tab = euclide(dividende, diviser)
        dividende = tab[2]
        diviser = tab[0]
        quotien = tab[3]

        if(tab[0] == 1):
            return tab[0]
            break

    return tab[0]

 
#Calcule de quotien et le reste, Méthode euclidienne
def euclide(dividende, diviser):
    quotient = 0
    reste = dividende
    
    while reste > diviser:
        reste = reste - diviser
        quotient+=1 
        
    return [reste, dividende, diviser, quotient]

#Calcule de bezout
def bezout(a,b):
    r, u, v = a, 1, 0
    rp, up, vp = b, 0, 1
    while rp != 0:
        q = r//rp
        rs, us, vs = r, u, v
        r, u, v = rp, up, vp
        rp, up, vp = (rs - q*rp), (us - q*up), (vs - q*vp)
    print('u = ',v)
    print('v = ',u)

def main(argv):
    #Message d'accueil
    print("\n####################################### \n|BIENVENUE DANS LE PROGRAMME D'EUCLIDE| \n#######################################")

    #Déclarations des variables
    try:
        dividende = int(input('\nEntrer le dividende: '))
        diviser = int(input('Entrer le diviser: '))
    except ValueError:
        print("\nCe nombre n'est pas valide. Arrêt du programme... ")
        sys.exit(1)

    if(pgcd(dividende, diviser) == 1):
        print('premier entre eux')
        bezout(dividende, diviser)
    else:
        print('nope')

if __name__ == '__main__':
    main(sys.argv)

## source = https://github.com/Krycthus/Euclide/blob/master/euclide.py

Algorithme de tri et algorithme d’Euclide

Un algorithme de tri est l’endroit où une liste d’éléments comptés peut en contenir un certain nombre. Cet algorithme de tri suppose qu’une longueur totale d’éléments d’une collection est d’au moins une liste. Si tous les éléments sont totaux, cela suppose qu’ils doivent faire partie de l’ensemble des éléments totaux, c’est donc la limite de ce qu’un algorithme peut connaître et estimer. C’est l’algorithme de tri pour un ensemble. Notez qu’à titre d’exemple, si vous souhaitez rechercher une certaine liste de choses, vous n’obtiendrez que les résultats de l’algorithme de tri. Les deux règles sont expliquées plus en détail ci-dessous. Un exemple d’algorithme de tri que vous voudrez peut-être rechercher est l’utilisation d’un algorithme qui a une longueur maximale.

Algorithme d'Euclide python

A propos

Cet algorithme n’a pas de longueur maximale. Il a exactement un compte de la liste (car il est le plus grand) jusqu’à ce qu’il atteigne la limite spécifiée. Étant donné que le nombre de comptages est faible, une séquence aléatoire d’éléments de comptage ne peut être utilisée que pour déterminer la longueur maximale d’un élément. Si vous voulez savoir combien d’entrées mettre dans cette vérification, envisagez simplement de définir maximum_length de l’élément maximum. Le nombre aléatoire n’est pas défini dans l’algorithme comme la liste des choses qui peuvent ou non compter dans la liste des choses qui sont comptées. Un exemple d’algorithme qui peut nécessiter une entrée supplémentaire pour faire une estimation: En utilisant l’entrée numérique de l’algorithme, il est possible d’exécuter le programme.

Liens externes

https://fr.wikipedia.org/wiki/Tri_fusion

https://graal.hypotheses.org/tag/algorithme-de-wagner-fischer

https://fr.wikipedia.org/wiki/Algorithme_de_Wagner-Fischer

https://fr.wikipedia.org/wiki/Distance_de_Levenshtein

Liens internes

https://128mots.com/index.php/2021/03/15/tri-a-bulles-bubble-sort-en-python/

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.