IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Programme pour trouver la langue d'un texte en comptant ses lettres


Sujet :

Python

  1. #1
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2020
    Messages
    14
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2020
    Messages : 14
    Points : 13
    Points
    13
    Par défaut Programme pour trouver la langue d'un texte en comptant ses lettres
    Bien le bonjour,

    Depuis hier soir j'ai un problème sur un programme que j'essaye de faire, à l'intérieur il y a plusieurs fonctions :
    - Une fonction qui répertorient les lettres d'un mot dans un dictionnaire
    - Une fonction qui répertories les mots d'un texte dans un dictionnaire
    - Une fonction qui utilise les 2 fonctions précédentes pour répertorier les lettres d'un texte
    - La fonction trouveLangue qui détermine la langue d'un texte
    - Une fonction optionnel qui demande de rentrer un texte et exécute la fonction trouveLangue
    Je n'arrive pas à faire la fonction trouveLangue, voici le code entier : (j'ai marqué la fonction en question)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    formatListe = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'à', 'â', 'á', 'å', 'ä', 'ã', 'a', 'æ', 'œ', 'ç', 'c', 'c', 'c', 'd', 'ð', 'è', 'é', 'ê', 'ë', 'e', 'e', 'g', 'g', 'h', 'î', 'ì', 'í', 'ï', 'i', 'j', 'l', 'ñ', 'n', 'n', 'ò', 'ö', 'ô', 'ó', 'õ', 'ø', 'r', 's', 's', 's', 'š', 'ß', 't', 'þ', 'ù', 'ú', 'û', 'u', 'ü', 'u', 'ý', 'z', 'z', 'ž']
    pourcentagesLettres = {'Anglais': [8.167, 1.492, 2.782, 4.253, 12.702, 2.228, 2.015, 6.094, 6.966, 0.153, 0.772, 4.025, 2.406, 6.749, 7.507, 1.929, 0.095, 5.987, 6.327, 9.056, 2.758, 0.978, 2.360, 0.150, 1.974, 0.074, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
     'Français': [7.636, 0.901, 3.260, 3.669, 14.715, 1.066, 0.866, 0.737, 7.529, 0.613, 0.074, 5.456, 2.968, 7.095, 5.796, 2.521, 1.362, 6.693, 7.948, 7.244, 6.311, 1.838, 0.049, 0.427, 0.128, 0.326, 0.486, 0.051, 0, 0, 0, 0, 0, 0, 0.018, 0.085, 0, 0, 0, 0, 0, 0.271, 1.504, 0.218, 0.008, 0, 0, 0, 0, 0, 0.045, 0, 0, 0.005, 0, 0, 0, 0, 0, 0, 0, 0, 0.023, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.058, 0, 0.060, 0, 0, 0, 0, 0, 0, 0], 
     'Allemand': [6.516, 1.886, 2.732, 5.076, 16.396, 1.656, 3.009, 4.577, 6.550, 0.268, 1.417, 3.437, 2.534, 9.776, 2.594, 0.670, 0.018, 7.003, 7.270, 6.154, 4.166, 0.846, 1.921, 0.034, 0.039, 1.134, 0, 0, 0, 0, 0.578, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.443, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.307, 0, 0, 0, 0, 0, 0, 0.995, 0, 0, 0, 0, 0], 
     'Espagnol': [11.525, 2.215, 4.019, 5.010, 12.181, 0.692, 1.768, 0.703, 6.247, 0.493, 0.011, 4.967, 3.157, 6.712, 8.683, 2.510, 0.877, 6.871, 7.977, 4.632, 2.927, 1.138, 0.017, 0.215, 1.008, 0.467, 0, 0, 0.502, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.433, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.725, 0, 0, 0, 0, 0.311, 0, 0, 0, 0, 0, 0.827, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.168, 0, 0, 0.012, 0, 0, 0, 0, 0], 
     'Portuguais': [14.634, 1.043, 3.882, 4.992, 12.570, 1.023, 1.303, 0.781, 6.186, 0.397, 0.015, 2.779, 4.738, 4.446, 9.735, 2.523, 1.204, 6.530, 6.805, 4.336, 3.639, 1.575, 0.037, 0.253, 0.006, 0.470, 0.072, 0.562, 0.118, 0, 0, 0.733, 0, 0, 0, 0.530, 0, 0, 0, 0, 0, 0, 0.337, 0.450, 0, 0, 0, 0, 0, 0, 0, 0, 0.132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.635, 0.296, 0.040, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.207, 0, 0, 0.026, 0, 0, 0, 0, 0], 
     'Espéranto': [12.117, 0.980, 0.776, 3.044, 8.995, 1.037, 1.171, 0.384, 10.012, 3.501, 4.163, 6.104, 2.994, 7.955, 8.779, 2.755, 0, 5.914, 6.092, 5.276, 3.183, 1.904, 0, 0, 0, 0.494, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.657, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.691, 0, 0.022, 0, 0, 0, 0, 0, 0.055, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.385, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.520, 0, 0, 0, 0, 0, 0], 
     'Italien': [11.745, 0.927, 4.501, 3.736, 11.792, 1.153, 1.644, 0.636, 10.143, 0.011, 0.009, 6.510, 2.512, 6.883, 9.832, 3.056, 0.505, 6.367, 4.981, 5.623, 3.011, 2.097, 0.033, 0.003, 0.020, 1.181, 0.635, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.030, 0.030, 0, 0, 0, 0, 0, 0, 0, 0.002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (0.166), 0.166, 0, 0, 0, 0, 0, 0, 0, 0], 
     'Turc': [11.920, 2.844, 0.963, 4.706, 8.912, 0.461, 1.253, 1.212, 8.600, 0.034, 4.683, 5.922, 3.752, 7.487, 2.476, 0.886, 0, 6.722, 3.014, 3.314, 3.235, 0.959, 0, 0, 3.336, 1.500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.125, 0, 0, 0, 0, 0, 5.114, 0, 0, 0, 0, 0, 0, 0.777, 0, 0, 0, 0, 0, 0, 1.780, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.854, 0, 0, 0, 0, 0], 
     'Suédois': [9.383, 1.535, 1.486, 4.702, 10.149, 2.027, 2.862, 2.090, 5.817, 0.614, 3.140, 5.275, 3.471, 8.542, 4.482, 1.839, 0.020, 8.431, 6.590, 7.691, 1.919, 2.415, 0.142, 0.159, 0.708, 0.070, 0, 0, 0, 1.338, 1.797, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.305, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
     'Polonais': [8.910, 1.470, 3.960, 3.250, 7.660, 0.300, 1.420, 1.080, 8.210, 2.280, 3.510, 2.100, 2.800, 5.520, 7.750, 3.130, 0.140, 4.690, 4.320, 3.980, 2.500, 0.040, 4.650, 0.020, 3.760, 5.640, 0, 0, 0, 0, 0, 0, 0.990, 0, 0, 0, 0, 0.400, 0, 0, 0, 0, 0, 0, 0, 1.110, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.820, 0, 0.200, 0, 0, 0, 0, 0.850, 0, 0, 0, 0, 0, 0.660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.060, 0.830, 0], 
     'Néerlandais': [7.486, 1.584, 1.242, 5.933, 18.91, 0.805, 3.403, 2.380, 6.499, 1.46, 2.248, 3.568, 2.213, 10.032, 6.063, 1.57, 0.009, 6.411, 3.73, 6.79, 1.99, 2.85, 1.52, 0.036, 0.035, 1.39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
     'Danois': [6.025, 2.000, 0.565, 5.858, 15.453, 2.406, 4.077, 1.621, 6.000, 0.730, 3.395, 5.229, 3.237, 7.240, 4.636, 1.756, 0.007, 8.956, 5.805, 6.862, 1.979, 2.332, 0.069, 0.028, 0.698, 0.034, 0, 0, 0, 1.190, 0, 0, 0, 0.872, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.939, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
     'Islandais': [10.110, 1.043, 0, 1.575, 6.418, 3.013, 4.241, 1.871, 7.578, 1.144, 3.314, 4.532, 4.041, 7.711, 2.166, 0.789, 0, 8.581, 5.630, 4.953, 4.562, 2.437, 0, 0.046, 0.900, 0, 0, 0, 1.799, 0, 0, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 4.393, 0, 0.647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.570, 0, 0, 0, 0, 0, 0, 0, 0, 0.777, 0, 0.994, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.455, 0, 0.613, 0, 0, 0, 0, 0.228, 0, 0, 0], 
     'Finlandais': [12.217, 0.281, 0.281, 1.043, 7.968, 0.194, 0.392, 1.851, 10.817, 2.042, 4.973, 5.761, 3.202, 8.826, 5.614, 1.842, 0.013, 2.872, 7.862, 8.750, 5.008, 2.250, 0.094, 0.031, 1.745, 0.051, 0, 0, 0, 0.003, 3.577, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.444, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
     'Tchèque': [8.421, 0.822, 0.740, 3.475, 7.562, 0.084, 0.092, 1.356, 6.073, 1.433, 2.894, 3.802, 2.446, 6.468, 6.695, 1.906, 0.001, 4.799, 5.212, 5.727, 2.160, 5.344, 0.016, 0.027, 1.043, 1.599, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.462, 0.015, 0, 0, 0.633, 0, 0, 0, 1.222, 0, 0, 0, 0, 0, 1.643, 0, 0, 0, 0, 0, 0, 0.007, 0, 0, 0, 0.024, 0, 0, 0.380, 0, 0, 0, 0.688, 0, 0.006, 0, 0, 0.045, 0, 0, 0, 0.204, 0.995, 0, 0, 0.721]}
     
    def lettre_dans_mot(mot): # Trouve les lettres dans un mot
        global dictlettre
        dictlettre = {}
        for lettre in mot: # Pour chaque lettres dans le mot
            if lettre in dictlettre: # Si la lettre est déjà dans le dictio
                dictlettre[lettre] += 1 # Indenter 1 le nombre de lettre trouver
            else: # Sinon
                dictlettre[lettre] = 1 # Ajouter la lettre au dictio et mettre à 1 la valeur trouver
        return(dictlettre) # retourne le dictionnaire de lettre
     
    def mot_dans_txt(txt): # Trouve les mots dans un texte
        global dictmot
        dictmot = {}
        ponctu = ["-", ",", ":", "'", "’", ".", "!", "?", "(", ")", "/", "\n", "\\"] # Liste des ponctuations a supprimer lors de la séparation des mots
        for i in ponctu: # Pour tout les éléments de la ponctuation
            txt = txt.replace(i, " ") # Supprimer cet élément
        txt = txt.lower() # Convertit les majuscules en minuscules 
        txt = txt.split() # sépare les mots entre les espaces
        for mot in txt: # pour chaque mot dans le texte
            if mot in dictmot: # Si le mot est déjà dans le dictio
                dictmot[mot] +=1 # indenter 1 le nombre de mot trouver
            else: # sinon
                dictmot[mot] = 1 # ajouter le mot au dictio et mettre à 1 la valeur trouver
        return(dictmot) # retourne le dictionnaire de mots
     
    def lettre_dans_txt(txt): # repertorie l'ensemble des lettres d'un texte
        global dictlettres
        dictlettres = {}
        for mot in mot_dans_txt(txt): # pour chaque mot trouvé dans le dictionnaire
            for lettre in lettre_dans_mot(mot): # pour chaque lettre trouvé dans le dictionnaire
                if lettre in dictlettres: # Si la lettre est déjà dans le dictio
                    dictlettres[lettre] += 1 # Indenter 1 le nombre de lettre trouver
                else: # Sinon
                    dictlettres[lettre] = 1 # Ajouter la lettre au dictio et mettre à 1 la valeur trouver
        return(dictlettres)
     
    """THE PROBLEM IS HERE ============================================================"""
    def trouveLangue(txt): # Essaye de déterminer la langue par le nombre de lettres et en fonction des accents
        resultatsPourcentage = {'Anglais': 0, 'Français': 0, 'Allemand': 0, 'Espagnol': 0, 'Portuguais': 0, 'Espéranto': 0, 'Italien': 0, 'Turc': 0, 'Suédois': 0, 'Polonais': 0, 'Néerlandais': 0, 'Danois': 0, 'Islandais': 0, 'Finlandais': 0, 'Tchèque': 0}          
     
    """============================================================"""
        print(resultatsPourcentage)
     
    def startIt():
        global texte
        choice = str(input("""* Bienvenue dans le script trouveLangue, un programme qui vous permet de déterminer la langue de votre texte parmis celles ci :
            - Anglais
            - Français
            - Allemand
            - Espagnol
            - Portuguais
            - Espéranto
            - Italien
            - Turc
            - Suédois
            - Polonais
            - Néerlandais
            - Danois
            - Islandais
            - Finlandais
            - Tchèque
        Voulez entrer votre texte via Python où l'importer via un fichier texte ?
            [1] Entrée manuelle
            [2] Importer un fichier\n"""))
        if choice == '1': # Choix 1 écrire le texte dans python
            texte = str(input("Entrez votre texte :\n====================\n"))
            print(texte)
        elif choice == '2': # Choix 2 importer un fichier possédant un texte
            file = str(input("Entrez le nom du fichier texte contenant votre texte (avec l'extension) :\n=========================================================================\n"))
            with open(file, "r", encoding='utf-8') as file:
                texte = file.read()
            print(texte)
        trouveLangue(texte) # Début de la fonction trouveLangue
     
    startIt()
    J'ai essayé plein de trucs foireux mais rien ne fonctionne pour l'instant en voici un extrait (inutile)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
     
        for k in pourcentagesLettres.values(): # pour chaque liste du dico de pourcentages
            for l in resultatsPourcentage.values(): # pour chaque valeur du dico final
                for i,j in lettre_dans_txt(txt).items(): # pour clé/valeur de la liste de lettre
                    locationIt = formatListe.index(i) # trouver la localisation de la lettre
                    print(i,j,k[locationIt])
                    l = float(j * (k[locationIt]))
                    print(l)
     
        for i,j in lettre_dans_txt(txt).items(): # pour clé/valeur de la liste de lettre
            locationIt = formatListe.index(i) # trouver la localisation de la lettre
            for k in pourcentagesLettres.values(): # pour chaque liste du dico de pourcentages
                for l in resultatsPourcentage.values():
                    print(i,j,k[locationIt])
                    l = float(1 * j) * (k[locationIt])
                    print(l)       
     
     
        for k in pourcentagesLettres.values(): # Pour chaque liste dans dans le dico
            for i, j in lettre_dans_txt(txt).items(): # pour chaque clé/valeur trouvé dans le dictionnaire
                findIt = formatListe.index(i) # Trouve l'emplacement de la lettre dans le dico de liste 
                for l in resultatsPourcentage.values():
                    l = 1
                    print(l,j,k[findIt],k)
                    l *= j * k[findIt]
                    print(l)
    En gros ce que je dois réussir à faire c'est utiliser les pourcentages de lettres au début du programme, et de calculer le pourcentage des lettres (pourcentage * nombre de lettres / 100) en fonction de chaque langue, et d'ainsi avec les prochaines fusionner les résultats pour en faire une moyenne pour le dictionnaire resultatsPourcentage pour chaque langue. Je ne sais pas si je m'explique bien pour tout vous dire je suis un peu fatigué
    Peut-être est ce quelque chose de facile mais je suis toujours un gros débutant dans python :p Si quelqu'un a le courage de m'aider et de me donner des conseils, quelles boucles à utiliser, je le remercie d'avance.

    Bonne journée !

  2. #2
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 282
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 282
    Points : 25 604
    Points
    25 604
    Billets dans le blog
    1
    Par défaut
    Bonjour
    Citation Envoyé par teddyfresnes Voir le message
    Je n'arrive pas à faire la fonction trouveLangue. J'ai essayé plein de trucs foireux mais rien ne fonctionne pour l'instant. Peut-être est ce quelque chose de facile mais je suis toujours un gros débutant dans python
    Alors avant de penser à Python, il faut déjà savoir si tu arrives à trouver ton résultat avec un simple papier et un crayon. Par exemple d'après ta liste, en français il y a 7,636% de "a" et 0,901% de "b" et en allemand il y a 6.516% de "a" et 1.886% de "b". Mais que se passe-t-il si tu trouves un texte avec 7,6% de "a" et 1,8% de "b" ? Ou pire 7,0% de "a" et 1,3% de "b" ???
    Une fois que tu auras trouvé l'algorithme qui répond à ce genre de question, tu pourras le coder en Python et en plus ça te semblera même assez "naturel" même si tu débutes et que ton code reste encore très "académique" parce que tu n'as pas encore certains réflexes Python. Par exemple au lieu de regarder si la lettre est dans le dico si oui incrémenter la valeur sinon mettre 1 tu peux utiliser setdefaut...
    Code python : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    for lettre in mot:
            dictlettre[lettre]=dictlettre.setdefault(lettre, 0) + 1
    ... mais ça ce n'est pas le plus important (ça viendra tout seul).

    Sinon c'est bien d'offrir l'entrée sur saisie ou sur fichier, mais ensuite il vaut mieux dédier des fonctions spécialement faites pour ce type de saisie et appeler la fonction associée au choix de l'utilisateur. Ca te permettra demain de faire évoluer facilement ton code (rajouter par exemple un texte provenant d'une bdd, ...)
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  3. #3
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2020
    Messages
    14
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2020
    Messages : 14
    Points : 13
    Points
    13
    Par défaut
    Hey,

    Je ne connaissais pas .setdefault() je viens de regarder c'est vrai que c'est beaucoup plus optimisé, je suis preneur pour ce genre de conseil, après c'est parce que je ne connaissais pas trop la syntaxe

    Concernant la fonction startIt je la modifierais mais ce n'est pas urgent, je ne compte pas améliorer ce programme (c'est un exercice).

    J'ai voulu écrire l'algorithme à utiliser sur papier mais comme je l'ai dit je m'avoue un peu perdue de comment procéder, après je ne comprend pas le problème que tu me dis, le nombre de lettres trouvé dans le texte ne sera pas un pourcentage, en fait imaginons que j'ai 27 "a", alors le programme calculera un ratio à partir de ceux contenu dans la variable pourcentagesLettres, ainsi pour l'anglais ce serait 27*8.167/100 = 2.20, puis le ratio de b si il y en 3 sera 3*0.901/100 = 0.02703, il faudra alors combiner a et b (et les prochaines lettres) en faisant 2.20 * 0.2703 * ratio de c * ratio de d ect ect.

    Lorsque toutes les langues auront un ratio total calculé, j'aurais voulu prendre la moyenne de toutes ses valeurs et les mettre en pourcentage afin de faire un classement de probabilités des langues les plus récurrentes.

  4. #4
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 282
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 282
    Points : 25 604
    Points
    25 604
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par teddyfresnes Voir le message
    après je ne comprend pas le problème que tu me dis, le nombre de lettres trouvé dans le texte ne sera pas un pourcentage, en fait imaginons que j'ai 27 "a", alors le programme calculera un ratio à partir de ceux contenu dans la variable pourcentagesLettres, ainsi pour l'anglais ce serait 27*8.167/100 = 2.20, puis le ratio de b si il y en 3 sera 3*0.901/100 = 0.02703
    Ben d'après ton premier post, ton but est de trouver la langue d'un texte. Cela signifie que tu as un texte mais tu ne connais pas sa langue. Donc tu ne peux pas appliquer le pourcentage "français" puisque tu ne sais pas encore si le texte est français.

    Donc comment tu fais pour savoir si le texte est français ? Evidemment si dans ton texte tu as 7.36% de "a" et 0.901 de "b" ça va bien car ça correspond pile poil aux pourcentages de "a" et de "b" en français. Si tu as 7.34% de "a" et 0.88% de "b" ça va encore car c'est toujours super proche des pourcentages officiels. Mais si tu as 7.6% de "a" (proche de la valeur française des "a") et 1.8% de "b" (proche de la valeur allemande des "b") comment tu choisis entre français ou allemand ?

    Ou alors (prenons ta façon de voir) tu as 27 "a" et 3 "b". Tu vas alors calculer selon les pourcentages français (7.636 * 27 / 100 = 2.06 "a" ; 0.901 * 3 / 100 = 0.027 "b") puis selon les pourcentages allemands (6.516 * 27 / 100 = 1.76 "a" ; 1.886 * 3 / 100 = 0.057 "b"). Et après ? Que veulent dire ces chiffres et comment vont-ils t'aider à choisir entre français ou allemand ???

    Donc voici comment je procèderais
    1. je commence par ranger les lettres dans l'ordre décroissant de chaque langue. Cela forme un mot de 26 lettres qui change selon la langue. En français, c'est "esantiruloc". En allemand c'est (exemple) "abehrt" et etc etc.
    2. je range les lettres du texte dans l'ordre décroissant de leur fréquence. Cela forme aussi un mot de 26 lettres
    3. je calcule la distance de Hamming entre le mot du texte et chaque mot de toutes les langues. La distance de Hamming entre deux mots de même longueur est le nombre d'endroits où les lettres sont différentes. La langue qui aura la distance la moins longue sera la langue probable du texte
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  5. #5
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2020
    Messages
    14
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2020
    Messages : 14
    Points : 13
    Points
    13
    Par défaut
    Citation Envoyé par Sve@r Voir le message
    Donc comment tu fais pour savoir si le texte est français ?
    Je m'explique mal, comme tu peux le voir dans mon script il y a un dictionnaire

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    resultatsPourcentage = {'Anglais': 0, 'Français': 0, 'Allemand': 0, 'Espagnol': 0, 'Portuguais': 0, 'Espéranto': 0, 'Italien': 0, 'Turc': 0, 'Suédois': 0, 'Polonais': 0, 'Néerlandais': 0, 'Danois': 0, 'Islandais': 0, 'Finlandais': 0, 'Tchèque': 0}
    qui répertorie le ratio de chaque langue

    L'objectif serait d'utiliser la méthode que j'ai écrit en haut pour avoir un ratio pour chaque langues, pour simplifier imaginons qu'on entre ce texte dans la fonction langue :

    "aaaaabaaaaaaabaaaaaaabaaaaaaa"

    On aurait seulement les lettres a = 27 et b = 3 et pour simplifier aussi, faisons comme si nous avions que les pourcentages des langues anglais, français, et allemand dans le dictionnaire pourcentagesLettres, jusque là leurs ratios serait : (nombre de lettres * pourcentage de la lettre dans la langue / 100)

    anglais : a = 27*8.167/100 = 2.20 b = 3*1.492/100 = 0.04476 produits des ratios des lettres = 2.20*0.04476 = 0.098472
    français : a = 27*7.636/100 = 2.06172 b = 3*0.901/100 = 0.02703 produits des ratios des lettres = 2.06172*0.02703 = 0.055728
    allemand : a = 27*6.516/100 = 1.75932 b = 3*1.886/100 = 0.05658 produits des ratios des lettres = 1.75932*0.05658 = 0.099542

    Citation Envoyé par Sve@r Voir le message
    Et après ? Que veulent dire ces chiffres et comment vont-ils t'aider à choisir entre français ou allemand ???
    On a calculer pour chacun des langages le ratio d'apparition des lettres de la langue en fonction du nombre de lettres dans le texte

    Si on convertit ces ratios totales en pourcentage :

    0.098472 + 0.055728 + 0.099542 = 0.253742

    anglais = 0.098472 / 0.254812 = 0.3880
    français = 0.055728 / 0.254812 = 0.2187
    allemand = 0.099542 / 0.254812 = 0.3906

    Il y aurait donc 38,8% chance que le texte soit anglais, 21,87% que le texte soit français et 39.06% que le texte soit allemand !

    Bien sur avec cet exemple ça ne sert à rien mais avec des vrais mots, un vrai texte le programme serait capable de déterminer la langue.

    Peut-être que les opérations que j'ai fait ne sont pas exactes et ne veulent rien dire si c'est le cas je suis totalement perdu, sinon le problème reste le même je trouve ça compliqué et je n'arrive pas à créer l'algorithme qui fera le calcul avec toutes les langues et n'importe quel lettres présente dans la variable liste formatListe

    J'espère que tu as compris ma méthodologie (pas forcément judicieuse)

    PS : Je viens de LEGEREMENT comprendre ce que tu me m'as proposer c'est badasse comme technique, je pourrais aussi essayer

  6. #6
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 282
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 282
    Points : 25 604
    Points
    25 604
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par teddyfresnes Voir le message
    On aurait seulement les lettres a = 27 et b = 3 et pour simplifier aussi, faisons comme si nous avions que les pourcentages des langues anglais, français, et allemand dans le dictionnaire pourcentagesLettres, jusque là leurs ratios serait : (nombre de lettres * pourcentage de la lettre dans la langue / 100)

    anglais : a = 27*8.167/100 = 2.20 b = 3*1.492/100 = 0.04476 produits des ratios des lettres = 2.20*0.04476 = 0.098472
    français : a = 27*7.636/100 = 2.06172 b = 3*0.901/100 = 0.02703 produits des ratios des lettres = 2.06172*0.02703 = 0.055728
    allemand : a = 27*6.516/100 = 1.75932 b = 3*1.886/100 = 0.05658 produits des ratios des lettres = 1.75932*0.05658 = 0.099542

    On a calculer pour chacun des langages le ratio d'apparition des lettres de la langue en fonction du nombre de lettres dans le texte
    Mouais. Je pige le calcul mais je suis dubitatif sur la pertinence du résulat final. Tu as juste multiplié le nb de "a" par son pourcentage dans une langue X, et multiplié ce résultat par la même chose pour "b". Bref tu ne fais que des multiplications en série quoi.

    Citation Envoyé par teddyfresnes Voir le message
    Si on convertit ces ratios totales en pourcentage :
    0.098472 + 0.055728 + 0.099542 = 0.253742
    Donc là tu additionnes le total français+anglais+allemand...

    Citation Envoyé par teddyfresnes Voir le message
    anglais = 0.098472 / 0.254812 = 0.3880
    français = 0.055728 / 0.254812 = 0.2187
    allemand = 0.099542 / 0.254812 = 0.3906
    Il y aurait donc 38,8% chance que le texte soit anglais, 21,87% que le texte soit français et 39.06% que le texte soit allemand !
    Il me semble que tu as allègrement multiplié des pommes et des poires pour trouver le prix au kg de la compote.

    Essayons tes calculs avec un vrai (simué) texte français. Ce texte contiendra 120 "e", 110 "s" et 2 "z" (la proportion du français est "e" puis "s" et "z" vient probablement très loin derrière). D'ailleurs on va dire pour l'exemple que la proportion générale française est de 42% "e", 39% "s" et 1% "z".
    Et opposons-le au serbe où les proportions seront de 12% "e", 14% "s" et 44% "z".

    Français: 120 * 42/100 * 110 * 39/100 * 2 * 1 / 100 = 43,24
    Serbe: 120 * 12/100 * 110 * 14 / 100 * 2 * 44 / 100 = 195.15

    Déjà ça sent pas bon car le total serbe est plus élevé que le total français. Mais continuons... Donc ensuite on les additionne: 43.24+195.15 = 238.39
    Puis le français: 43.24 / 238.39 = 18%
    Et le serbe: 195.15 / 238.39 = 82%
    Et donc un texte français a 18% de chances de d'être français face à 82% de chances d'être serbe...

    Citation Envoyé par teddyfresnes Voir le message
    Peut-être que les opérations que j'ai fait ne sont pas exactes et ne veulent rien dire
    Ben à un moment donné, je pense qu'il faut faire intervenir le nombre de chaque lettre par rapport au nombre total de lettres, choses que tu n'as jamais faite. Dans mon exemple, avec 120 "e", 110 "s" et 2 "z", la proportion est de 51,72% de "e" ce qui est plus proche des 42% de "e" en français que du 12% de "e" en serbe...

    Citation Envoyé par teddyfresnes Voir le message
    Je viens de LEGEREMENT comprendre ce que tu me m'as proposer c'est badasse comme technique, je pourrais aussi essayer
    En plus je pensais qu'il allait falloir se taper la recherche des lettres mais non, on peut utiliser les pourcentages pour "générer" les mots.
    Exemple
    Code python : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    pourcentagesLettres = {
    	'Anglais': (8.167, 1.492, 2.782, 4.253, 12.702, 2.228, 2.015, 6.094, 6.966, 0.153, 0.772, 4.025, 2.406, 6.749, 7.507, 1.929, 0.095, 5.987, 6.327, 9.056, 2.758, 0.978, 2.360, 0.150, 1.974, 0.074, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
    	'Français': (7.636, 0.901, 3.260, 3.669, 14.715, 1.066, 0.866, 0.737, 7.529, 0.613, 0.074, 5.456, 2.968, 7.095, 5.796, 2.521, 1.362, 6.693, 7.948, 7.244, 6.311, 1.838, 0.049, 0.427, 0.128, 0.326, 0.486, 0.051, 0, 0, 0, 0, 0, 0, 0.018, 0.085, 0, 0, 0, 0, 0, 0.271, 1.504, 0.218, 0.008, 0, 0, 0, 0, 0, 0.045, 0, 0, 0.005, 0, 0, 0, 0, 0, 0, 0, 0, 0.023, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.058, 0, 0.060, 0, 0, 0, 0, 0, 0, 0), 
    	'Allemand': (6.516, 1.886, 2.732, 5.076, 16.396, 1.656, 3.009, 4.577, 6.550, 0.268, 1.417, 3.437, 2.534, 9.776, 2.594, 0.670, 0.018, 7.003, 7.270, 6.154, 4.166, 0.846, 1.921, 0.034, 0.039, 1.134, 0, 0, 0, 0, 0.578, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.443, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.307, 0, 0, 0, 0, 0, 0, 0.995, 0, 0, 0, 0, 0), 
    	'Espagnol': (11.525, 2.215, 4.019, 5.010, 12.181, 0.692, 1.768, 0.703, 6.247, 0.493, 0.011, 4.967, 3.157, 6.712, 8.683, 2.510, 0.877, 6.871, 7.977, 4.632, 2.927, 1.138, 0.017, 0.215, 1.008, 0.467, 0, 0, 0.502, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.433, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.725, 0, 0, 0, 0, 0.311, 0, 0, 0, 0, 0, 0.827, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.168, 0, 0, 0.012, 0, 0, 0, 0, 0), 
    	'Portuguais': (14.634, 1.043, 3.882, 4.992, 12.570, 1.023, 1.303, 0.781, 6.186, 0.397, 0.015, 2.779, 4.738, 4.446, 9.735, 2.523, 1.204, 6.530, 6.805, 4.336, 3.639, 1.575, 0.037, 0.253, 0.006, 0.470, 0.072, 0.562, 0.118, 0, 0, 0.733, 0, 0, 0, 0.530, 0, 0, 0, 0, 0, 0, 0.337, 0.450, 0, 0, 0, 0, 0, 0, 0, 0, 0.132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.635, 0.296, 0.040, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.207, 0, 0, 0.026, 0, 0, 0, 0, 0), 
    	'Espéranto': (12.117, 0.980, 0.776, 3.044, 8.995, 1.037, 1.171, 0.384, 10.012, 3.501, 4.163, 6.104, 2.994, 7.955, 8.779, 2.755, 0, 5.914, 6.092, 5.276, 3.183, 1.904, 0, 0, 0, 0.494, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.657, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.691, 0, 0.022, 0, 0, 0, 0, 0, 0.055, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.385, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.520, 0, 0, 0, 0, 0, 0), 
    	'Italien': (11.745, 0.927, 4.501, 3.736, 11.792, 1.153, 1.644, 0.636, 10.143, 0.011, 0.009, 6.510, 2.512, 6.883, 9.832, 3.056, 0.505, 6.367, 4.981, 5.623, 3.011, 2.097, 0.033, 0.003, 0.020, 1.181, 0.635, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.030, 0.030, 0, 0, 0, 0, 0, 0, 0, 0.002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (0.166), 0.166, 0, 0, 0, 0, 0, 0, 0, 0), 
    	'Turc': (11.920, 2.844, 0.963, 4.706, 8.912, 0.461, 1.253, 1.212, 8.600, 0.034, 4.683, 5.922, 3.752, 7.487, 2.476, 0.886, 0, 6.722, 3.014, 3.314, 3.235, 0.959, 0, 0, 3.336, 1.500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.125, 0, 0, 0, 0, 0, 5.114, 0, 0, 0, 0, 0, 0, 0.777, 0, 0, 0, 0, 0, 0, 1.780, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.854, 0, 0, 0, 0, 0), 
    	'Suédois': (9.383, 1.535, 1.486, 4.702, 10.149, 2.027, 2.862, 2.090, 5.817, 0.614, 3.140, 5.275, 3.471, 8.542, 4.482, 1.839, 0.020, 8.431, 6.590, 7.691, 1.919, 2.415, 0.142, 0.159, 0.708, 0.070, 0, 0, 0, 1.338, 1.797, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.305, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
    	'Polonais': (8.910, 1.470, 3.960, 3.250, 7.660, 0.300, 1.420, 1.080, 8.210, 2.280, 3.510, 2.100, 2.800, 5.520, 7.750, 3.130, 0.140, 4.690, 4.320, 3.980, 2.500, 0.040, 4.650, 0.020, 3.760, 5.640, 0, 0, 0, 0, 0, 0, 0.990, 0, 0, 0, 0, 0.400, 0, 0, 0, 0, 0, 0, 0, 1.110, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.820, 0, 0.200, 0, 0, 0, 0, 0.850, 0, 0, 0, 0, 0, 0.660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.060, 0.830, 0), 
    	'Néerlandais': (7.486, 1.584, 1.242, 5.933, 18.91, 0.805, 3.403, 2.380, 6.499, 1.46, 2.248, 3.568, 2.213, 10.032, 6.063, 1.57, 0.009, 6.411, 3.73, 6.79, 1.99, 2.85, 1.52, 0.036, 0.035, 1.39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
    	'Danois': (6.025, 2.000, 0.565, 5.858, 15.453, 2.406, 4.077, 1.621, 6.000, 0.730, 3.395, 5.229, 3.237, 7.240, 4.636, 1.756, 0.007, 8.956, 5.805, 6.862, 1.979, 2.332, 0.069, 0.028, 0.698, 0.034, 0, 0, 0, 1.190, 0, 0, 0, 0.872, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.939, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
    	'Islandais': (10.110, 1.043, 0, 1.575, 6.418, 3.013, 4.241, 1.871, 7.578, 1.144, 3.314, 4.532, 4.041, 7.711, 2.166, 0.789, 0, 8.581, 5.630, 4.953, 4.562, 2.437, 0, 0.046, 0.900, 0, 0, 0, 1.799, 0, 0, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 4.393, 0, 0.647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.570, 0, 0, 0, 0, 0, 0, 0, 0, 0.777, 0, 0.994, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.455, 0, 0.613, 0, 0, 0, 0, 0.228, 0, 0, 0), 
    	'Finlandais': (12.217, 0.281, 0.281, 1.043, 7.968, 0.194, 0.392, 1.851, 10.817, 2.042, 4.973, 5.761, 3.202, 8.826, 5.614, 1.842, 0.013, 2.872, 7.862, 8.750, 5.008, 2.250, 0.094, 0.031, 1.745, 0.051, 0, 0, 0, 0.003, 3.577, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.444, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
    	'Tchèque': (8.421, 0.822, 0.740, 3.475, 7.562, 0.084, 0.092, 1.356, 6.073, 1.433, 2.894, 3.802, 2.446, 6.468, 6.695, 1.906, 0.001, 4.799, 5.212, 5.727, 2.160, 5.344, 0.016, 0.027, 1.043, 1.599, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.462, 0.015, 0, 0, 0.633, 0, 0, 0, 1.222, 0, 0, 0, 0, 0, 1.643, 0, 0, 0, 0, 0, 0, 0.007, 0, 0, 0, 0.024, 0, 0, 0.380, 0, 0, 0, 0.688, 0, 0.006, 0, 0, 0.045, 0, 0, 0, 0.204, 0.995, 0, 0, 0.721),
    }
     
    # Génération en utilisant une liste en intension (méthodologie avancée Python)
    mots_langue=dict(
    	(
    		k,
    		"".join(
    			x for (x, y) in sorted(
    				zip("abcdefghijklmnopqrstuvwxyz", v),
    				key=lambda elem: elem[1],
    				reverse=True,
    			)
    		),
    	) for (k, v) in pourcentagesLettres.items()
    )
     
    # La même chose en utilisant un algo plus classique
    mots_langue=dict()
    for (k, v) in pourcentagesLettres.items():
    	mots_langue[k]="".join(
    		x for (x, y) in sorted(
    			zip("abcdefghijklmnopqrstuvwxyz", v),
    			key=lambda elem: elem[1],
    			reverse=True,
    		)
    	)
    # for
     
    print(mots_langue)
    Bon, c'est assez difficile à piger de prime abord. Pour simplifier, sur chaque langue, je génère "à la volée" une association des lettres et de leurs fréquences (zip("abc...yz", v)) et je trie cette association selon la valeur de la fréquence (l'élément[1] de l'association) puis je ne récupère du résultat que les lettres triées (le "x") que je recompose en un mot unique ("".join(...)) et je stocke ce mot dans la langue d'où la fréquence a été sortie.

    Enfin on s'en fout un peu, l'important c'est que "mots_langue" contienne pour chaque langue ses lettres dans l'ordre d'apparition. Et pour calculer une distance de Hamming entre 2 mots:
    Code python : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    def hamming(s1, s2):
    	assert len(s1) == len(s2)
    	return sum(c1 != c2 for c1, c2 in zip(s1, s2))
    Comme tu peux le voir, Python offre des outils bien sympa pour agréger des listes de valeurs dans un sens ou dans l'autre. Ne reste qu'à compter tes lettres, les trier et regarder pour chaque mot de "mots_langue" la langue pour laquelle la distance de Hamming est la plus faible.
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  7. #7
    Membre averti
    Homme Profil pro
    occupé
    Inscrit en
    juin 2018
    Messages
    297
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Pyrénées Orientales (Languedoc Roussillon)

    Informations professionnelles :
    Activité : occupé

    Informations forums :
    Inscription : juin 2018
    Messages : 297
    Points : 417
    Points
    417
    Par défaut
    Bonjour,
    Pour déterminer la langue d'un texte, j'utiliserai une expression rationnelle qui chercherai la présence d' articles spécifiques à une langue...
    Pour voir si un text est ecrit en Français nous pourrions utiliser comme pattern :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    pattern = r" (le|la|les|un|une|de|des|je|tu|il|elle|nous|vous|ils|elles|est|et|ai|mon|ton|son)+ "
    Nous pourions aussi regarder du coté des accentuations spécifiques à une langue...

  8. #8
    Expert confirmé
    Avatar de jurassic pork
    Homme Profil pro
    Bidouilleur
    Inscrit en
    décembre 2008
    Messages
    2 171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Bidouilleur
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2008
    Messages : 2 171
    Points : 5 456
    Points
    5 456
    Par défaut
    hello,
    sinon il y a la méthode de la distance de Levenshtein
    voir ici :
    Determine the Language of a Document from the Letter Frequency — using Levenshtein Distance between sequences

    Ami calmant, J.P
    Jurassic computer : Sinclair ZX81 - Zilog Z80A à 3,25 MHz - RAM 1 Ko - ROM 8 Ko

  9. #9
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 282
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 282
    Points : 25 604
    Points
    25 604
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par jurassic pork Voir le message
    sinon il y a la méthode de la distance de Levenshtein
    Oui, il semble que ce soit un équivalent amélioré d'une distance de Hamming. La distance de Hamming suppose des mots de même longueur tandis que la distance de Levenshtein accepte des mots de taille différente (exemple avec "bright" et "freight" qui donne 2).
    C'est effectivement plus intéressant surtout si on prend en compte aussi les variations de chaque langue (àâéèêîïç etc...)
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  10. #10
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2020
    Messages
    14
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2020
    Messages : 14
    Points : 13
    Points
    13
    Par défaut
    Bonsoir à tous,

    Je n'ai pas trop eu le temps de répondre car j'ai été très occupé. Je vous remercie de vos réponses.

    Je me souviens avoir essayé dans un code assez brut la méthode de distance de hamming malheureusement à ma grande déception les résultats était trop vagues et les langues françaises et anglaises par exemple, avait un résultat très proche, selon le texte utilisé, pour la majorité des résultats erronés.

    Je ne sais plus si j'avais fait une erreur dans mon programme enfin bref c'est oublié

  11. #11
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 282
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 282
    Points : 25 604
    Points
    25 604
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par teddyfresnes Voir le message
    Je me souviens avoir essayé dans un code assez brut la méthode de distance de hamming malheureusement à ma grande déception les résultats était trop vagues et les langues françaises et anglaises par exemple, avait un résultat très proche, selon le texte utilisé, pour la majorité des résultats erronés.
    Sympa d'être revenu. J'avais oublié ce post. Ca m'a donné l'idée de m'essayer aussi au truc
    Code python : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    #!/usr/bin/env python3
    # coding: utf-8
     
    import string
     
    # Génération de l'alphabet trié par ordre d'apparition des lettres dans le texte
    def genereAlphabet(txt):
    	d=dict((c, txt.lower().count(c)) for c in string.ascii_lowercase)
    	return "".join(
    		x[0] for x in sorted(
    			((k, v) for (k, v) in d.items()),
    			key=lambda x: x[1],
    			reverse=True,
    		)
    	)
    # genereAlphabet()
     
    # Distance entre deux mots de même longueur (méthode de Hamming)
    def distanceHamming(m1, m2):
    	return sum(x != y for (x, y) in zip(m1, m2))
     
    # Distance entre deux mots pouvant être de longueur inégale (méthode nommée "distance d'édition")
    def distanceEdition(m1, m2):
    	dist={(-1, -1) : 0}
    	for i in range(len(m1)): dist[i, -1]=i
    	for i in range(len(m2)): dist[-1, i]=i
     
    	for (i, c) in enumerate(m1):
    		for (j, d) in enumerate(m2):
    			d1=dist[i-1, j] + 1 # insertion
    			d2=dist[i, j-1] + 1 # suppression
    			d3=dist[i-1, j-1] + (0 if c == d else 1)
    			dist[i, j]=min(d1, d2, d3)
    		# for
    	# for
    	return dist[len(m1)-1, len(m2)-1]
    # distanceEdition
     
    # Recherche de la langue d'un texte
    def chercheLangue(txt):
    	# Génération de l'alphabet du texte
    	alphaTxt=genereAlphabet(txt)
     
    	# Génération des alphabets dans chaque langue selon leur pourcentage d'apparition de lettres
    	pourcentagesLettres={
    		'Anglais' : (8.167, 1.492, 2.782, 4.253, 12.702, 2.228, 2.015, 6.094, 6.966, 0.153, 0.772, 4.025, 2.406, 6.749, 7.507, 1.929, 0.095, 5.987, 6.327, 9.056, 2.758, 0.978, 2.360, 0.150, 1.974, 0.074, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
    		'Français' : (7.636, 0.901, 3.260, 3.669, 14.715, 1.066, 0.866, 0.737, 7.529, 0.613, 0.074, 5.456, 2.968, 7.095, 5.796, 2.521, 1.362, 6.693, 7.948, 7.244, 6.311, 1.838, 0.049, 0.427, 0.128, 0.326, 0.486, 0.051, 0, 0, 0, 0, 0, 0, 0.018, 0.085, 0, 0, 0, 0, 0, 0.271, 1.504, 0.218, 0.008, 0, 0, 0, 0, 0, 0.045, 0, 0, 0.005, 0, 0, 0, 0, 0, 0, 0, 0, 0.023, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.058, 0, 0.060, 0, 0, 0, 0, 0, 0, 0), 
    		'Allemand' : (6.516, 1.886, 2.732, 5.076, 16.396, 1.656, 3.009, 4.577, 6.550, 0.268, 1.417, 3.437, 2.534, 9.776, 2.594, 0.670, 0.018, 7.003, 7.270, 6.154, 4.166, 0.846, 1.921, 0.034, 0.039, 1.134, 0, 0, 0, 0, 0.578, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.443, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.307, 0, 0, 0, 0, 0, 0, 0.995, 0, 0, 0, 0, 0), 
    		'Espagnol' : (11.525, 2.215, 4.019, 5.010, 12.181, 0.692, 1.768, 0.703, 6.247, 0.493, 0.011, 4.967, 3.157, 6.712, 8.683, 2.510, 0.877, 6.871, 7.977, 4.632, 2.927, 1.138, 0.017, 0.215, 1.008, 0.467, 0, 0, 0.502, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.433, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.725, 0, 0, 0, 0, 0.311, 0, 0, 0, 0, 0, 0.827, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.168, 0, 0, 0.012, 0, 0, 0, 0, 0), 
    		'Portuguais' : (14.634, 1.043, 3.882, 4.992, 12.570, 1.023, 1.303, 0.781, 6.186, 0.397, 0.015, 2.779, 4.738, 4.446, 9.735, 2.523, 1.204, 6.530, 6.805, 4.336, 3.639, 1.575, 0.037, 0.253, 0.006, 0.470, 0.072, 0.562, 0.118, 0, 0, 0.733, 0, 0, 0, 0.530, 0, 0, 0, 0, 0, 0, 0.337, 0.450, 0, 0, 0, 0, 0, 0, 0, 0, 0.132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.635, 0.296, 0.040, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.207, 0, 0, 0.026, 0, 0, 0, 0, 0), 
    		'Espéranto' : (12.117, 0.980, 0.776, 3.044, 8.995, 1.037, 1.171, 0.384, 10.012, 3.501, 4.163, 6.104, 2.994, 7.955, 8.779, 2.755, 0, 5.914, 6.092, 5.276, 3.183, 1.904, 0, 0, 0, 0.494, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.657, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.691, 0, 0.022, 0, 0, 0, 0, 0, 0.055, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.385, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.520, 0, 0, 0, 0, 0, 0), 
    		'Italien' : (11.745, 0.927, 4.501, 3.736, 11.792, 1.153, 1.644, 0.636, 10.143, 0.011, 0.009, 6.510, 2.512, 6.883, 9.832, 3.056, 0.505, 6.367, 4.981, 5.623, 3.011, 2.097, 0.033, 0.003, 0.020, 1.181, 0.635, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.030, 0.030, 0, 0, 0, 0, 0, 0, 0, 0.002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (0.166), 0.166, 0, 0, 0, 0, 0, 0, 0, 0), 
    		'Turc' : (11.920, 2.844, 0.963, 4.706, 8.912, 0.461, 1.253, 1.212, 8.600, 0.034, 4.683, 5.922, 3.752, 7.487, 2.476, 0.886, 0, 6.722, 3.014, 3.314, 3.235, 0.959, 0, 0, 3.336, 1.500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.125, 0, 0, 0, 0, 0, 5.114, 0, 0, 0, 0, 0, 0, 0.777, 0, 0, 0, 0, 0, 0, 1.780, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.854, 0, 0, 0, 0, 0), 
    		'Suédois' : (9.383, 1.535, 1.486, 4.702, 10.149, 2.027, 2.862, 2.090, 5.817, 0.614, 3.140, 5.275, 3.471, 8.542, 4.482, 1.839, 0.020, 8.431, 6.590, 7.691, 1.919, 2.415, 0.142, 0.159, 0.708, 0.070, 0, 0, 0, 1.338, 1.797, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.305, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
    		'Polonais' : (8.910, 1.470, 3.960, 3.250, 7.660, 0.300, 1.420, 1.080, 8.210, 2.280, 3.510, 2.100, 2.800, 5.520, 7.750, 3.130, 0.140, 4.690, 4.320, 3.980, 2.500, 0.040, 4.650, 0.020, 3.760, 5.640, 0, 0, 0, 0, 0, 0, 0.990, 0, 0, 0, 0, 0.400, 0, 0, 0, 0, 0, 0, 0, 1.110, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.820, 0, 0.200, 0, 0, 0, 0, 0.850, 0, 0, 0, 0, 0, 0.660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.060, 0.830, 0), 
    		'Néerlandais' : (7.486, 1.584, 1.242, 5.933, 18.91, 0.805, 3.403, 2.380, 6.499, 1.46, 2.248, 3.568, 2.213, 10.032, 6.063, 1.57, 0.009, 6.411, 3.73, 6.79, 1.99, 2.85, 1.52, 0.036, 0.035, 1.39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
    		'Danois' : (6.025, 2.000, 0.565, 5.858, 15.453, 2.406, 4.077, 1.621, 6.000, 0.730, 3.395, 5.229, 3.237, 7.240, 4.636, 1.756, 0.007, 8.956, 5.805, 6.862, 1.979, 2.332, 0.069, 0.028, 0.698, 0.034, 0, 0, 0, 1.190, 0, 0, 0, 0.872, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.939, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
    		'Islandais' : (10.110, 1.043, 0, 1.575, 6.418, 3.013, 4.241, 1.871, 7.578, 1.144, 3.314, 4.532, 4.041, 7.711, 2.166, 0.789, 0, 8.581, 5.630, 4.953, 4.562, 2.437, 0, 0.046, 0.900, 0, 0, 0, 1.799, 0, 0, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 4.393, 0, 0.647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.570, 0, 0, 0, 0, 0, 0, 0, 0, 0.777, 0, 0.994, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.455, 0, 0.613, 0, 0, 0, 0, 0.228, 0, 0, 0), 
    		'Finlandais' : (12.217, 0.281, 0.281, 1.043, 7.968, 0.194, 0.392, 1.851, 10.817, 2.042, 4.973, 5.761, 3.202, 8.826, 5.614, 1.842, 0.013, 2.872, 7.862, 8.750, 5.008, 2.250, 0.094, 0.031, 1.745, 0.051, 0, 0, 0, 0.003, 3.577, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.444, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
    		'Tchèque' : (8.421, 0.822, 0.740, 3.475, 7.562, 0.084, 0.092, 1.356, 6.073, 1.433, 2.894, 3.802, 2.446, 6.468, 6.695, 1.906, 0.001, 4.799, 5.212, 5.727, 2.160, 5.344, 0.016, 0.027, 1.043, 1.599, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.462, 0.015, 0, 0, 0.633, 0, 0, 0, 1.222, 0, 0, 0, 0, 0, 1.643, 0, 0, 0, 0, 0, 0, 0.007, 0, 0, 0, 0.024, 0, 0, 0.380, 0, 0, 0, 0.688, 0, 0.006, 0, 0, 0.045, 0, 0, 0, 0.204, 0.995, 0, 0, 0.721),
    	}
    	alphaLangue=dict(
    		(
    			k,
    			"".join(
    				x for (x, y) in sorted(
    					zip(string.ascii_lowercase, v),
    					key=lambda elem: elem[1],
    					reverse=True,
    				)
    			),
    		) for (k, v) in pourcentagesLettres.items()
    	)
     
    	# Calcul des distances entre le mot du texte et chaque mot de la langue en pourcentage par rapport à 26
    	l=len(string.ascii_lowercase)
    	calcul={"texte": alphaTxt, "result": dict()}
    	for (k, v) in alphaLangue.items():
    		calcul["result"][k]={"texte" : v, "result" : dict()}
    		for (methode, fct) in (
    			("Hamming", distanceHamming),
    			("Edition", distanceEdition),
    		):
    			calcul["result"][k]["result"][methode]=100 - fct(alphaTxt, v)/l * 100
    	# for
    	return calcul
    # chercheLangue()
     
    # Analyse d'un fichier
    def analyse(fic):
    	with open(fic, "r") as fp: r=chercheLangue(fp.read())
    	print("Mot de base de %s: %s" % (fic, r["texte"]))
    	for x in sorted(
    		((k, v) for (k, v) in r["result"].items()),
    		key=lambda x: sum(x[1]["result"].values()) / len(x[1]["result"]),
    		reverse=True,
    	):
    		print(
    			"%s (%s): %s (moyenne=%.02f%%)" % (
    				x[0],
    				x[1]["texte"],
    				", ".join("%s: %.02f%%" % (k, v) for (k, v) in x[1]["result"].items()),
    				sum(x[1]["result"].values()) / len(x[1]["result"]),
    			)
    		)
    	# for
    # analyse()
     
    # Programme principal
    if __name__ == "__main__":
    	import sys
    	for arg in sys.argv[1:]: analyse(arg)
    # if
    On lance le programme en lui passant un fichier contenant un texte, et il ressort pour chaque langue la probabilité en pourcentage de lui appartenir triée par probabilité totale.

    L'avantage c'est qu'on peut lui rajouter facilement d'autres méthodes de calcul (j'ai trouvé l'algorithme de distance entre deux mots nommé "distance d'édition" ici => http://www.xavierdupre.fr/app/ensae_...7_edition.html). Si par dessus jurassic pork veut implémenter la distance de Levenshtein, il lui suffit de rajouter la fonction "distanceLevenshtein" et de l'inclure dans la boucle
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    for (methode, fct) in (
    	("Hamming", distanceHamming),
    	("Edition", distanceEdition),
    	("Levenshtein", distanceLevenshtein),
    )
    et tout le reste s'y adapte.

    L'inconvénient c'est que j'ai tenté d'analyser le texte de cette page, texte à priori on ne peut plus français, et que j'ai eu ce résultat
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    Mot de base de b: earnsitluocdmphfvgbqkyxjwz
    Suédois (eanrtsildomkgvhfupbcyjxwzq): Hamming: 30.77%, Edition: 42.31% (moyenne=36.54%)
    Espagnol (eaosrnidltcmupbgvyqhfjzxwk): Hamming: 23.08%, Edition: 30.77% (moyenne=26.92%)
    Italien (eaionlrtscdpumvgzfbhqwyjkx): Hamming: 15.38%, Edition: 34.62% (moyenne=25.00%)
    Islandais (arniestulgmkfvohdjbypxcqwz): Hamming: 15.38%, Edition: 34.62% (moyenne=25.00%)
    Anglais (etaoinshrdlcumwfgypbvkjxqz): Hamming: 11.54%, Edition: 30.77% (moyenne=21.15%)
    Français (esaitnruoldcmpvqfbghjxzykw): Hamming: 11.54%, Edition: 30.77% (moyenne=21.15%)
    Portuguais (aeosridmntculpvgqbfhzjxwky): Hamming: 15.38%, Edition: 26.92% (moyenne=21.15%)
    Danois (erntaidslogkmfvbuphjycwzxq): Hamming: 15.38%, Edition: 26.92% (moyenne=21.15%)
    Tchèque (aeonitvsrldkmupzjhybcgfxwq): Hamming: 11.54%, Edition: 30.77% (moyenne=21.15%)
    Allemand (ensriatdhulgcomwbfkzvpjyxq): Hamming: 7.69%, Edition: 26.92% (moyenne=17.31%)
    Espéranto (aieonlsrtkjudmpvgfbczhqwxy): Hamming: 3.85%, Edition: 26.92% (moyenne=15.38%)
    Finlandais (aintesloukmrvjhpydgbcfwzxq): Hamming: 7.69%, Edition: 23.08% (moyenne=15.38%)
    Turc (aeinrldkmytusbozghcvpfjqwx): Hamming: 7.69%, Edition: 15.38% (moyenne=11.54%)
    Polonais (aioeznrwstcykdpmujlbghfqvx): Hamming: 3.85%, Edition: 15.38% (moyenne=9.62%)
    Néerlandais (enatirodslgvhkmubpwjzcfxyq): Hamming: 3.85%, Edition: 11.54% (moyenne=7.69%)
    Il semble donc que mon texte ait le plus de probabilités d'être du suédois
    Après est-ce la faute aux valeurs des pourcentages de fréquences d'apparition ou de la méthode d'analyse...

    Enfin c'était sympa à programmer
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  12. #12
    Expert confirmé
    Avatar de jurassic pork
    Homme Profil pro
    Bidouilleur
    Inscrit en
    décembre 2008
    Messages
    2 171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Bidouilleur
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2008
    Messages : 2 171
    Points : 5 456
    Points
    5 456
    Par défaut
    hello,
    Citation Envoyé par Sve@r Voir le message
    . Si par dessus jurassic pork veut implémenter la distance de Levenshtein, il lui suffit de rajouter la fonction "distanceLevenshtein" et de l'inclure dans la boucle
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    for (methode, fct) in (
        ("Hamming", distanceHamming),
        ("Edition", distanceEdition),
        ("Levenshtein", distanceLevenshtein),
    )
    et tout le reste s'y adapte.
    voici un code python que j'ai trouvé sur le net pour implémenter la fonction distanceLevenshtein :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    def distanceLevenshtein(str1, str2, ):
        counter = {"+": 0, "-": 0}
        distance = 0
        for edit_code, *_ in ndiff(str1, str2):
            if edit_code == " ":
                distance += max(counter.values())
                counter = {"+": 0, "-": 0}
            else: 
                counter[edit_code] += 1
        distance += max(counter.values())
        return distance
    Sve@r je ne sais pas ce que tu as pris dans ta page wikipédia pour faire le test (tout le texte html ?) mais avec le contenu du fichier hitchcock.txt en pièce jointe (début de l'article Hitchcock en mode texte) voici ce que j'obtiens avec la fonction distanceLevenshtein ajoutée à ton programme :
    >>> Mot de base de hitchcock.txt: esnartiulocdmphqfgvbykxjwz
    Français (esaitnruoldcmpvqfbghjxzykw): Hamming: 26.92%, Edition: 38.46%, Levenshtein: 30.77% (moyenne=32.05%)
    Suédois (eanrtsildomkgvhfupbcyjxwzq): Hamming: 26.92%, Edition: 38.46%, Levenshtein: 26.92% (moyenne=30.77%)
    Islandais (arniestulgmkfvohdjbypxcqwz): Hamming: 19.23%, Edition: 26.92%, Levenshtein: 7.69% (moyenne=17.95%)
    Espagnol (eaosrnidltcmupbgvyqhfjzxwk): Hamming: 26.92%, Edition: 30.77%, Levenshtein: -7.69% (moyenne=16.67%)
    Anglais (etaoinshrdlcumwfgypbvkjxqz): Hamming: 15.38%, Edition: 26.92%, Levenshtein: 3.85% (moyenne=15.38%)
    Italien (eaionlrtscdpumvgzfbhqwyjkx): Hamming: 7.69%, Edition: 23.08%, Levenshtein: 11.54% (moyenne=14.10%)
    Danois (erntaidslogkmfvbuphjycwzxq): Hamming: 23.08%, Edition: 26.92%, Levenshtein: -7.69% (moyenne=14.10%)
    Portuguais (aeosridmntculpvgqbfhzjxwky): Hamming: 15.38%, Edition: 23.08%, Levenshtein: -7.69% (moyenne=10.26%)
    Espéranto (aieonlsrtkjudmpvgfbczhqwxy): Hamming: 0.00%, Edition: 26.92%, Levenshtein: -3.85% (moyenne=7.69%)
    Allemand (ensriatdhulgcomwbfkzvpjyxq): Hamming: 3.85%, Edition: 26.92%, Levenshtein: -11.54% (moyenne=6.41%)
    Tchèque (aeonitvsrldkmupzjhybcgfxwq): Hamming: 15.38%, Edition: 23.08%, Levenshtein: -23.08% (moyenne=5.13%)
    Néerlandais (enatirodslgvhkmubpwjzcfxyq): Hamming: 3.85%, Edition: 15.38%, Levenshtein: -15.38% (moyenne=1.28%)
    Turc (aeinrldkmytusbozghcvpfjqwx): Hamming: 7.69%, Edition: 19.23%, Levenshtein: -30.77% (moyenne=-1.28%)
    Finlandais (aintesloukmrvjhpydgbcfwzxq): Hamming: 11.54%, Edition: 19.23%, Levenshtein: -38.46% (moyenne=-2.56%)
    Polonais (aioeznrwstcykdpmujlbghfqvx): Hamming: 7.69%, Edition: 15.38%, Levenshtein: -46.15% (moyenne=-7.69%)
    Le Français est bien en premier avec la fonction distanceLevenshtein.

    Mais en ne prenant pas en compte les caractères accentués les résultats peuvent être faussés.

    Ami calmant, J.P
    Fichiers attachés Fichiers attachés
    Jurassic computer : Sinclair ZX81 - Zilog Z80A à 3,25 MHz - RAM 1 Ko - ROM 8 Ko

  13. #13
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 282
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 282
    Points : 25 604
    Points
    25 604
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par jurassic pork Voir le message
    voici un code python que j'ai trouvé sur le net pour implémenter la fonction distanceLevenshtein
    Petit souci, ton code utilise une fonction "ndiff" que je ne connais/trouve pas...

    Citation Envoyé par jurassic pork Voir le message
    Le Français est bien en premier avec la fonction distanceLevenshtein.
    Oui, rajouter d'autres méthodes affine le système Faudrait maintenant tester d'autres langues pour voir si ça matche

    Citation Envoyé par jurassic pork Voir le message
    Mais en ne prenant pas en compte les caractères accentués les résultats peuvent être faussés.
    C'est parti. On modifie la fonction "genereAlphabet" pour y inclure les caractères accentués en les assimilant à leur équivalent non accentué...
    Code python : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    # Génération de l'alphabet trié par ordre d'apparition des lettres dans le texte
    def genereAlphabet(txt):
    	# Suppression des accents
    	for (x, y) in (
    		("àâä", "a"),
    		("éèêë", "e"),
    		("îï", "i"),
    		("ôö", "o"),
    		("ûü", "u"),
    		("ÿ", "y"),
    	): txt=re.sub(r"[%s]" % x, r"%s" % y, txt)
     
    	# Histogramme et tri
    	d=dict((c, txt.lower().count(c)) for c in string.ascii_lowercase)
    	return "".join(
    		x[0] for x in sorted(
    			((k, v) for (k, v) in d.items()),
    			key=lambda x: x[1],
    			reverse=True,
    		)
    	)
    # genereAlphabet()
    Avec un import re préalable.
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  14. #14
    Expert confirmé
    Avatar de jurassic pork
    Homme Profil pro
    Bidouilleur
    Inscrit en
    décembre 2008
    Messages
    2 171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Bidouilleur
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2008
    Messages : 2 171
    Points : 5 456
    Points
    5 456
    Par défaut
    Citation Envoyé par Sve@r Voir le message
    Petit souci, ton code utilise une fonction "ndiff" que je ne connais/trouve pas...
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    from difflib import ndiff
    et pour les caractères accentués il faudrait mieux (si c'est possible) les rajouter dans la génération de l'alphabet et pas les assimiler à leurs équivalents sans accent.
    Jurassic computer : Sinclair ZX81 - Zilog Z80A à 3,25 MHz - RAM 1 Ko - ROM 8 Ko

  15. #15
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 282
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 282
    Points : 25 604
    Points
    25 604
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par jurassic pork Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    from difflib import ndiff
    Super. Je me suis amusé avec un texte turc trouvé sur le net.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    Madde 26
    1) Her şahsın öğrenim hakkı vardır. Öğrenim hiç olmazsa ilk ve temel safhalarında parasızdır. İlk öğretim mecburidir. Teknik ve mesleki öğretimden herkes istifade edebilmelidir. Yüksek öğretim, liyakatlerine göre herkese tam eşitlikle açık olmalıdır.
    2) Öğretim insan şahsiyetinin tam gelişmesini ve insan haklarıyla ana hürriyetlerine saygının kuvvetlenmesini hedef almalıdır. Öğretim bütün milletler, ırk ve din grupları arasında anlayış, hoşgörü ve dostluğu teşvik etmeli ve Birleşmiş Milletlerin barışın idamesi yolundaki çalışmalarını geliştirmelidir.
    3) Ana baba, çocuklarına verilecek eğitim türünü seçmek hakkını öncelikle haizdirler.
    Madde 27
    1) Herkes, topluluğun kültürel faaliyetine serbestçe katılmak, güzel sanatları tatmak, ilim sahasındaki ilerleyişe iştirak etmek ve bundan faydalanmak hakkını haizdir.
    2) Herkesin yarattığı, her türlü bilim, edebiyat veya sanat eserlerinden mütevellit manevi ve maddi menfaatlerin korunmasına hakkı vardır.
    Le texte est un peu court mais le programme, avec ta fonction, a quand-même bien détecté du Turc

    Citation Envoyé par jurassic pork Voir le message
    et pour les caractères accentués il faudrait mieux (si c'est possible) les rajouter dans la génération de l'alphabet et pas les assimiler à leurs équivalents sans accent.
    Hé là je ne suis pas certain. Car l'algo est en fait basé sur les probabilités indiquées des différentes langues. Or ces probabilités ne concernent que les lettres de base. Comment alors comparer un mot statistique (l'histogramme du texte initial) qui contiendrait des accents avec les mots générés par les valeurs des tables de probabilités qui, eux, seront sans accent?
    Je suis obligé de considérer un "é" (et ses soeurs) comme un "e". Et puis bon ça reste (tiens, il faudrait aussi penser au "c cédille") ludique donc je vais pas non plus me faire des noeuds au cerveau
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  16. #16
    Expert confirmé
    Avatar de jurassic pork
    Homme Profil pro
    Bidouilleur
    Inscrit en
    décembre 2008
    Messages
    2 171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Bidouilleur
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2008
    Messages : 2 171
    Points : 5 456
    Points
    5 456
    Par défaut
    Citation Envoyé par Sve@r Voir le message
    Hé là je ne suis pas certain. Car l'algo est en fait basé sur les probabilités indiquées des différentes langues (sais plus où je les avais trouvées, probablement sur wikipedia). Or ces probabilités ne concernent que les lettres de base.
    Dans ton code dans la variable pourcentageslettres il y a plus de 26 valeurs par lettre donc je suppose qu'il y a aussi les accents
    En pièce jointe la fréquence des lettres et lettres accentuées en fonction de la langue en format csv. Et pour le fichier texte en entrée il vaudrait mieux un texte en format UTF8 pour être sûr de bien repérer les accents.
    Fichiers attachés Fichiers attachés
    Jurassic computer : Sinclair ZX81 - Zilog Z80A à 3,25 MHz - RAM 1 Ko - ROM 8 Ko

  17. #17
    Membre du Club
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    juin 2018
    Messages
    29
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aube (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : juin 2018
    Messages : 29
    Points : 64
    Points
    64
    Par défaut
    Salut!

    Je n'ai pas trop compris si il fallait implémenter un méthode spécifique ou non, donc je vais peut-être être hors-sujet, mais:

    On peut, plutôt que de calculer la probabilité d'apparition d'une lettre,
    calculer la probabilité qu'une lettre apparaisse après une autre (chaînes de markov)

    C'est plutôt simple à mettre en œuvre, comme dans les exemples précédents,
    on parcourt lettre par lettre un texte/mot et on compte les occurrences,
    mais cette fois-ci on fait 26 dictionnaires différents selon la lettre qui précède.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    tableau_occurences = {
        'a' : {           #*lettre qui précède
            'a' : 0,     # lettre qui suit
            'b' : 5,
            ...
        },
        'b' : {
            'a' : 10,
            'b' : 0,
            ...
        },
    }
    """
    Soit le tableau français: (ordonné : lettre précédente, abscisse : lettre suivante)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
            a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z
    ------------------------------------------------------------------------------------
      |  0 12  2  4  7 19  1  1  2  5  1  0  7  6  6  2  3  6  4  4  6  0  1  0  0  0  0
    a |  4  0  3  4  2  0  2  3  0 21  0  0  6  5  9  0  3  0  6 17  9  2  2  0  0  1  0
    b |  0 18  0  0  0 11  0  0  0 12  1  0 12  0  0 19  0  0 17  3  1  4  0  0  0  0  0
    c |  0 14  0  5  0 10  0  0 20  8  0  0  5  0  0 18  0  1  7  0  7  6  0  0  0  0  0
    d | 16  8  0  0  0 38  0  0  0 17  1  0  0  1  0  7  0  0  5  0  0  4  0  0  0  0  0
    e |  9  1  1  4  1  2  1  1  0  1  0  0  3  5 17  0  2  0 23 13  4  2  1  0  2  0  7
    f |  1 10  0  0  0 12 21  0  0 20  0  0  9  0  0 10  0  0 10  1  0  5  0  0  0  0  0
    g |  0  9  0  0  0 30  0  1  0  8  0  0  5  1  9  8  0  0 14  0  0 13  0  0  0  0  0
    h |  0 31  0  0  0 30  0  0  0 14  0  0  1  0  0 12  0  0  2  0  0  4  0  0  0  5  0
    i |  5  3  1  2  2 16  2  2  0  0  0  0  6  3 11  9  1  2  4 18  9  0  2  0  0  0  0
    j | 44 10  0  0  0 12  0  0  0  0  0  0  0  0  0 19  0  0  0  0  0 16  0  0  0  0  0
    k |  8 17  2  0  0 22  0  0  3 19  0  1  3  0  1  4  0  0  2  5  0  1  0  0  0 12  0
    l | 21 16  0  1  0 19  0  0  0 15  0  0 13  0  0  7  0  0  0  1  1  3  0  0  0  1  0
    m | 18 13  8  0  0 24  0  0  0  9  0  0  0  5  0  8 11  0  0  0  0  3  0  0  0  0  0
    n | 11  6  0  6  4  8  2  3  0  5  1  0  0  0  6  2  0  0  1 16 28  1  1  0  0  0  0
    o |  0  0  2  3  1  0  1  2  0  4  0  0  5  5 39  0  3  1  9  3  4 15  1  0  0  1  0
    p |  0 18  0  0  0 16  0  0  5 11  0  0  8  0  0 14  8  0 12  1  3  3  0  0  0  0  0
    q |  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0100  0  0  0  0  0
    r |  4 28  1  2  2 22  0  2  0 15  0  0  0  2  1 12  1  0  3  1  2  1  1  0  0  0  0
    s | 40  7  0  1  0 16  0  0  0  8  0  0  0  0  0  3  1  0  0 17  4  2  0  0  0  0  0
    t | 39 10  0  0  0 18  0  0  1 12  0  0  0  0  0  4  0  0  8  1  3  2  0  0  0  0  0
    u | 20  6  2  3  2 11  2  1  0  8  0  0  7  3  2  0  2  0 13  7  7  0  2  0  1  0  0
    v |  0 25  0  0  0 34  0  0  0 24  0  0  0  0  0 10  0  0  6  0  0  1  0  0  0  0  0
    w |  3 35  0  0  0 22  0  0  2 23  0  0  6  0  2  4  0  0  1  2  0  1  0  0  0  0  0
    x |  9 10  0 12  0  9  1  0  6 10  0  0  0  0  0  4 20  0  0  1 13  2  0  0  0  3  0
    y |  1 20  1  4  9 14  0  3  0  2  0  0  6  4  5  4 10  0  3  9  3  0  0  0  1  0  0
    z | 96  1  0  0  0  1  0  0  0  1  0  0  0  0  0  2  0  0  0  0  0  0  0  0  0  0  0
    Après cet entraînement,
    on a toutes les probabilité de P(lettre_1 => lettre_2) spécifiques à une langue.

    On peut alors calculer "la probabilité qu'un mot existe" dans la langue, par exemple, un mot de 5 lettres:
    P = P12 * P23 * P34 * P45

    Il suffit de faire ce calcul de proba sur 2 langues différentes et prendre la plus grande.

    Traduction python
    Calcul du tableau :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    with open(f"liste_mot_langue_xxx.txt", 'r') as f:
     
        tableau_proba = {}
     
        for word in f:
            for precedente, suivante in fenetre_glissante_taille_2(word):
                tableau_proba.setdefault(precedente, {})
                tableau_proba[precedente][suivante] = tableau_proba[precedente].setdefault(suivante, 0) + 1
     
    # transformation occurences => proba
    for precedente in tableau_proba.keys():
        tab = tableau_proba[precedente]
        for suivante, occurences in tab.items():
            tab[suivante] = occurences / sum(tab.values())
    Probabilité d'un mot
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    Pmot = 1
     
    for precedente, suivante in fenetre_glissante_taille_2(phrase):
     
        tableau_proba[precedente] = dct.setdefault(precedente, {})       
        Pmot = Pmot * tableau_proba[precedente].setdefault(suivante, 0)
    Pour comparer deux langues, simplement:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    if P_lang_1 > P_lang_2:
        print('lang_1')
    else:
        print('lang_2')
    Bonus : générateur pour fenere glissante (itertools)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    def read_by_2(iterable, size=2):
        iterable = iter(" " + iterable + " ")
        d = deque(islice(iterable, size), size)
        yield d
        for x in iterable:
            d.append(x)
            yield d
    En pratique
    Je suis parvenu à des bons résultats (pas d'erreurs sur des textes en français ou en anglais), mais en regardant quel caractère suit 2 autres.
    J'ai généré les tableaux à partir de liste de mots issue d'aspell (simple liste de mot pour corrections orthographiques)

    Voilà, c'était surtout pour partager le principe.Mon implémentation (et mon cote) ne sont vraiment pas terrible, Néanmoins, pour les audacieux:
    https://framagit.org/-/snippets/6189 (makov mémoire à un caractère, mémoire à deux caractères + les probas au fomat json)
    markovchain_guess_language

  18. #18
    Expert confirmé
    Avatar de jurassic pork
    Homme Profil pro
    Bidouilleur
    Inscrit en
    décembre 2008
    Messages
    2 171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Bidouilleur
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2008
    Messages : 2 171
    Points : 5 456
    Points
    5 456
    Par défaut
    hello,
    finalement, j'ai trouvé un script python qui essaie d'identifier la langue d'un texte par la fréquence de ses lettres en utilisant un algorithme personnel. C'est ici
    Ce script prend bien en compte les accents pour son calcul. Il permet aussi de visualiser de façon graphique les résultats (avec pylab). A noter qu'il n'y a pas l'anglais dans les langues

    J'ai dû faire quelques modifications mineures pour le faire fonctionner en python 3 :
    1 - Mettre des parenthèses pour les print
    2 - Pour les open de fichiers ajouter en paramètre d'appel
    encoding='utf-8'
    3 - J'ai rajouté deux fichiers dans le répertoire snippets ( un en français (mon fichier hitchcock.txt), l'autre turc_Sve@r.txt contenant le texte turc de Sve@r. Modification pour cela faite dans le script python :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
        for textfile in ['hitchcock.txt','turc_Sve@r.txt','nl_columbus.txt', 'it_boccaccio.txt', 'fi_kivi.txt']:
    et voici les résultats pour les deux premiers fichiers :

    Nom : ResultTxtFr.png
Affichages : 62
Taille : 34,2 Ko Nom : ResultTxtTurc.png
Affichages : 60
Taille : 33,3 Ko

    Ami calmant, J.P
    Jurassic computer : Sinclair ZX81 - Zilog Z80A à 3,25 MHz - RAM 1 Ko - ROM 8 Ko

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 7
    Dernier message: 28/03/2019, 11h56
  2. [Débutant] faire un programme pour trouver IP
    Par jps1901 dans le forum Visual Studio
    Réponses: 2
    Dernier message: 06/07/2014, 22h52
  3. Concours de programmation pour trouver un (bon) job
    Par Aude_B dans le forum Emploi
    Réponses: 2
    Dernier message: 16/10/2012, 14h53
  4. programme pour trouver l'adresse du port d'un élément
    Par nanou1983 dans le forum Windows Forms
    Réponses: 28
    Dernier message: 20/09/2007, 08h32

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo