Partage
  • Partager sur Facebook
  • Partager sur Twitter

Invertion des syllabes

    28 novembre 2021 à 14:30:55

    Bonjour, dans le cas d'un exercice de NSI mon professeur m'a demandé de créer un argot ainsi qu'une fonction permettant de modifier les mots de la langue française vers cet argot

    j'ai donc choisit un argot d'inversion des syllabes exemple :

    - argot : gotar

    - campagne : pagnecam

    Sauf que j'ai des difficultés à créer ce programme python et dans un premier temps de trouver les syllabes et de les stocker pour ensuite faire appel a un autre programme qui les inversera

    mon code :

    def coupe_syllabe(mot):
        voyelle = "aeiouy"
        consone = "zrtpqsdfghjklmwxcvbn"
        precedent = mot[0]
        mot2=""
        stockage=""
        for i in range(0,len(mot)-1):
            mot2+=mot[i]
            if mot[i] and mot[i+1] in consone:
                return mot2+mot[i+1]

    Je demande donc votre aide merci d'avance

    • Partager sur Facebook
    • Partager sur Twitter
      28 novembre 2021 à 14:49:36

      Pour découper un mot en syllabes se fait suivant certaines règles.

      Il faut déjà partir de celles ci, pour en faire un algorithme (qu'on pourra coder) et on doit le retrouver à la lecture du code.

      Ca commence sur une feuille de papier comment découper argot en ar/got ou campagne en cam/pa/gne...

      • Partager sur Facebook
      • Partager sur Twitter
        28 novembre 2021 à 14:52:18

        Ça n'a rien d'évident, il te faut un algorithme de syllabation. Et il faut déjà définir syllabe. Dans des cas très simples, tu peux arriver à quelque chose, sinon c'est un travail de linguiste. Il doit exister des fichiers des syllabisés du lexique français.
        • Partager sur Facebook
        • Partager sur Twitter
          28 novembre 2021 à 15:00:12

          j'ai trouvé la règle française qui défini les syllabes, c'est quand "On sépare les syllabes entre deux consonnes sauf à la fin d'un mot. La règle s'applique aussi pour deux consommes qui sont les mêmes. On sépare les syllabes entre une voyelle et une consonne. Lorsque trois consonnes se suivent et sont différentes, on sépare après la deuxième consonne." 

          le seul problème étant que dans mon programme les syllabes sont mal prises en compte et aussi que la dernière lettre n'est pas comprise dedans

          • Partager sur Facebook
          • Partager sur Twitter
            28 novembre 2021 à 15:13:12

            Pour l'avoir déjà fait dans le passé, les règles ne sont pas si simples.
            Comment sépares-tu "tendre", "alphabet", "paraphraser", ou pire "aujourd'hui" ...
            Voici une liste non exhaustive des doublets et triplets à reconnaître:
            bl, br, ch, cl, cr, dr, fl, fr, gn, gr, pl, pr, tr, vr,  chr phr, ...

            On s'aligne sur les suites de voyelles et on recule pour reconnaître ces séquences. Attention aux débuts et fin de mot.

            -
            Edité par PierrotLeFou 28 novembre 2021 à 15:22:23

            • Partager sur Facebook
            • Partager sur Twitter

            Le Tout est souvent plus grand que la somme de ses parties.

              28 novembre 2021 à 15:20:41

              Je vois bien mais après je ne vois pas comment le retraduire en code :/
              • Partager sur Facebook
              • Partager sur Twitter
                28 novembre 2021 à 15:27:36

                Commences par reconnaître les fins de séquences de voyelles. Bon exemples: beaucoup, voyage.
                Le mot interactif pose problème, mais est-ce bien un mot français?
                On cherche le début de la syllabe, pas la fin.

                Tu seras toujours une syllabe en retard ...

                -
                Edité par PierrotLeFou 28 novembre 2021 à 15:32:28

                • Partager sur Facebook
                • Partager sur Twitter

                Le Tout est souvent plus grand que la somme de ses parties.

                  28 novembre 2021 à 15:43:30

                  word=input("Enter the word:")
                  voyelle="aeiouy"
                  syllabe=0
                  for w in word:
                        if w in voyelle:
                              syllabe+=1
                  print("le nombre de syllabe est :")
                  print(syllabe)
                  j'ai ce code mais le seul problème c'est les mots où 2 et+ syllabes se suivent
                  • Partager sur Facebook
                  • Partager sur Twitter
                    28 novembre 2021 à 15:48:46

                    Là vous avez le nombre de syllabes, pas les syllabes, il faut ensuite déterminer comment découper selon des règles.

                    Pour le nombre de syllabes, on peut voir du côté du module NLTK et son module cmudict.

                    • Partager sur Facebook
                    • Partager sur Twitter

                    Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
                    La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

                      28 novembre 2021 à 15:52:03

                      Corentin_n a écrit:

                      j'ai trouvé la règle française qui défini les syllabes, c'est quand "On sépare les syllabes entre deux consonnes sauf à la fin d'un mot. La règle s'applique aussi pour deux consommes qui sont les mêmes. On sépare les syllabes entre une voyelle et une consonne. Lorsque trois consonnes se suivent et sont différentes, on sépare après la deuxième consonne."

                      Il faut imaginer un algorithme. Pour çà on peut supposer qu'on va balayer le mot caractère par caractère et on essaie de reformuler ces règles en fonction de ce balayage.

                      Premier truc, une syllabe contient au moins une voyelle: il peut y avoir n'importe quoi avant qu'on rencontre la première voyelle, toutes ces lettres seront dans la première syllabe (première voyelle rencontrée incluse).

                      Et arrivé là, on regarde ce qui suit: si c'est une voyelle ou une ou plusieurs consonnes pour savoir comment terminer la première syllabe.

                      On retranche la première syllabe du mot et on recommence avec le reste (condition d'arrêt à gérer).

                      Pour l'instant, c'est plus une histoire "avec les mains" qu'un algorithme... mais c'est votre exercice.

                      • Partager sur Facebook
                      • Partager sur Twitter
                        28 novembre 2021 à 16:22:46

                        Ok mais un deuxième problème apparaît :

                        comment stocker les syllabes séparément pour dans un second programme les inverser ?

                        autre problème je n'arrive pas a tester si la valeur de mot[i+1] est inexistante ou si c'est une lettre du mot avec cette boucle :

                        def t(mot):
                            voyelle="aeiouy"
                            syllabe=""
                            s=''
                            for i in range(0,len(mot)):
                                if mot[i] in voyelle:
                                    if mot[i+1]!=s and mot[i+1] in voyelle:

                        ça met toujours out of range alors que j'ai mis "si mot[i+1]!=s" 

                        -
                        Edité par Corentin_n 28 novembre 2021 à 16:46:15

                        • Partager sur Facebook
                        • Partager sur Twitter
                          28 novembre 2021 à 17:05:03

                          Corentin_n a écrit:

                          comment stocker les syllabes séparément pour dans un second programme les inverser ?

                          Ça ce n'est pas un problème, l'algorithme doit prendre 98% de votre temps, le reste est simple, comme celui d'inverser des syllabes.

                          syllabes = ["bon", "jour"]
                          syllabes_inverse = syllabes[::-1] # ou reversed(syllabes)
                          
                          

                          L'algorithme à mon sens est complexe, ça demande un niveau de recherches important et je supposerai qu'il faille travailler par tests unitaires.

                          Le fait d'avoir un message d'erreur lié aux index prouvent que l'algorithme n'est pas fiable selon la variation des longueurs de chaîne de caractères utilisées dans votre fonction.

                          • Partager sur Facebook
                          • Partager sur Twitter

                          Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
                          La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

                            28 novembre 2021 à 17:10:47

                            Sauf que je n'arrive pas a séparer les différentes syllabes

                            le travail étant à rendre sous peu de temps c'est un peut la course ahah

                            -
                            Edité par Corentin_n 28 novembre 2021 à 17:19:01

                            • Partager sur Facebook
                            • Partager sur Twitter
                              28 novembre 2021 à 17:40:20

                              Votre professeur ne vous a pas donné quelques règles à respecter pour créer vos syllabes ?

                              https://www.alloprof.qc.ca/fr/eleves/bv/francais/la-syllabe-f1595

                              Selon les règles ci-dessus, ça demande de connaître l'index précédent et suivant de l'index courant et une bonne poignée de tests afin de vérifier chaque règle.

                              Vous pouvez utiliser les exemples du lien ci-dessus afin de vérifier le bon fonctionnement de votre code.

                              • Partager sur Facebook
                              • Partager sur Twitter

                              Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
                              La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

                                28 novembre 2021 à 17:45:12

                                J'ai quand même un problème principal qui est que je ne parcours pas la dernière valeur du mot avec cette boucle :

                                for i in range(0,len(mot)-1):

                                et je suis obligé de laisser le "-1" car sinon lorsque je fais mot[i+1] et que c'est sur la dernière lettre et bah ça renvoie "out of range"

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  28 novembre 2021 à 17:49:08

                                  Comme je l'ai dit, il faut chercher les séquences de voyelles.
                                  + tu gardes la position de la prwemière pour savoir où commence la séquence de consonnes qui précède.
                                  + tu gardes le suivant de la dernière voyelle pour savoir où commencer la recherche de la prochaine séquence
                                  Tu sauves cette valeur
                                  Après tu recules dans la séquence des consonnes et tu  cherches (pour      2 consonnes ou plus) si la séquence est dans la table
                                  Tu gardes la position du début de cette séquence.
                                  Sinon, il n'y a qu'une consonne dans la syllabe. Ne pas s'occuper des mots comme (justement) "comme". 'mm' n'est pas dans la liste.
                                  -
                                  La séparation ne se fera qu'à la fin.
                                  J'imagine un tableau des "coupures" dont la première valeur est 0 et la dernière est len(mot).
                                  On fait un append des positions de début des séquences de consonnes.
                                  On fait du slicing pour séparer le mot en syllabes.
                                  coupe = []
                                  for i in range(len(coupures)-1:
                                           coupe.append(mot[coupures[i]:coupures[i+1]])
                                  coupe.reverse()
                                  coupe = ''.join(coupe)

                                  edit:

                                  Si le mot commence par une voyelle, la suite des consonnes commence à 0 mais la dernière consonnes est à -1 (tant que 0 < -1 ...)

                                  -
                                  Edité par PierrotLeFou 28 novembre 2021 à 17:54:04

                                  • Partager sur Facebook
                                  • Partager sur Twitter

                                  Le Tout est souvent plus grand que la somme de ses parties.

                                    28 novembre 2021 à 17:57:25

                                    C'est un des problèmes mais il y a aussi ma boucle qui ne parcours pas la dernière valeur
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      28 novembre 2021 à 18:08:46

                                      Quand je te dis de garder la position après la séquence de voyelles, tu n'avances que si la position est inférieure à len(mot)
                                      Si je prend "foret" (sans accent ...)
                                      La seconde séquence de voyelles est le 'e' et le 't' suit.
                                      Tu ne trouveras pas de bvoyelles après le 't' mais tu dois vérifier que tu as atteint la longueur de la chaîne.
                                      Tel que je l'ai décrit, le tableau coupures sera:
                                      coupures = [0, 2, 5]
                                      Le 5 est ajouté à la fin.

                                      Pour le mot "bateau", la séquence de voyelles s'arrêtera à la fin du mot et c'est cette position que tu gardes.

                                      Pour savoir la différence entre les deux, s'il y a au moins une voyelle, tu recherches les consonnes qui précèdent, sinon tu ne fais rien.

                                      -
                                      Edité par PierrotLeFou 28 novembre 2021 à 18:18:49

                                      • Partager sur Facebook
                                      • Partager sur Twitter

                                      Le Tout est souvent plus grand que la somme de ses parties.

                                        28 novembre 2021 à 18:36:08

                                        def t(mot):
                                            comptesyllabe = 0
                                            voyelle = "aeiouy"
                                            consone = "zrtpqsdfghjklmwxcvbn"
                                            syllabe1=""
                                            syllabe2=""
                                            syllabe3=""
                                            syllabe4=""
                                            syllabe5=""
                                            syllabe6=""
                                            for i in range(0, len(mot)-1):
                                                if comptesyllabe == 0:
                                                    comptesyllabe = 1
                                                if comptesyllabe == 1:
                                                    if mot[i+2] in voyelle:
                                                        syllabe1+=mot[i]
                                                        comptesyllabe=2
                                                    else:
                                                        if mot[i] in voyelle:
                                                            if mot[i+1] in voyelle:
                                                                syllabe1+=mot[i+1]
                                                            else:
                                                                syllabe1+=mot[i]
                                                        else:
                                                            syllabe1+=mot[i]
                                                
                                                
                                                if comptesyllabe == 2:
                                                    if mot[i+2] in voyelle:
                                                        syllabe2+=mot[i]
                                                        comptesyllabe=3
                                                    else:
                                                        if mot[i] in voyelle:
                                                            if mot[i+1] in voyelle:
                                                                syllabe2+=mot[i+1]
                                                            else:
                                                                syllabe2+=mot[i]
                                                        else:
                                                            syllabe2+=mot[i]
                                                
                                                
                                                
                                                
                                            return syllabe1,syllabe2
                                                        
                                        

                                        j'ai fais cet algorithme pour séparer les syllabes en syllabe1,2,3 etc

                                        mais au moment où la condition pour passer à la syllabe suivant (la 2) est validée ça retest la lettre qui valide la condition

                                        mis du coup ça ne fonctionne pas car la syllabe2 est "m" alors qu'elle devrait être "pa" ou "pag"

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          28 novembre 2021 à 18:58:09

                                          D'abord, tu n'as absolument pas besoin de la liste des consonnes.
                                          Que ferais-tu avec le mot "anticonstitutionnellement" ?
                                          Si je ne me trompe pas, il y a 9 syllabes ...
                                          Essaies avec plusieurs mots d'afficher la position du début de chaque séquence de voyelles et la position de la fin de la séquence + 1 (position d'une consonne ou fin)
                                          Si tu sais le faire, le reste ne sera pas trop compliqué.
                                          • Partager sur Facebook
                                          • Partager sur Twitter

                                          Le Tout est souvent plus grand que la somme de ses parties.

                                            28 novembre 2021 à 19:39:49

                                            def syl(mot):
                                                print(mot)
                                                voyelles = "eiaouy"
                                                fin = len(mot)
                                                v = fin
                                                c = 0
                                                i = 0
                                                while i < fin:
                                                    if mot[i] in voyelles:
                                                        if v == fin: v=i
                                                    elif i > v:
                                                        c= i
                                                        if c > v:
                                                            print(v,c, mot[v:c])
                                                            v = fin
                                                    i +=1
                                                if i > v:
                                                    print(v, i, mot[v:i])
                                            mots = ["asphalte", "bateau", "beaucoup", "foret","test", "locomotive"]
                                            for w in mots:
                                                syl(w)

                                            edit:
                                            Je fais deux print pour les séquences de voyelles. Cela suppose deux traitements des syllabes.
                                            Il serait préférable de n'avoir qu'un seul traitement. C'est possible!
                                            Je garde mon truc de générer une liste des points de coupure entre les syllabes. Le reste sera évident:
                                            -
                                                return ''.join([mot[coupures[i]:coupures[i+1]] for i in range(len(coupures)-1)][::-1])

                                            re-edit:
                                            @fred1599:
                                            > L'algorithme à mon sens est complexe, ça demande un niveau de recherches important et je supposerai qu'il faille travailler par tests unitaires.
                                            L'algorithme est en effet plus complexe que je pensais, même si je l'avais déjà codé en C il y a assez longtemps.
                                            @Corentin_n:
                                            > le travail étant à rendre sous peu de temps c'est un peut la course ahah
                                            Il aurait fallu y penser avant ...
                                            J'ai tout de même essayeé de le coder en Python. Je pense que ma version fonctionne:
                                            -
                                            def inverserSyllabes(mot):
                                                # Il peut manquer des séquences ou d'autres seraient invalides, 'st' est douteux.
                                                sequences = ['bl', 'br', 'ch', 'cl', 'cr', 'dr', 'fl', 'fr', 'gl', 'gn', 'gr', 'ph', 'pl', 'pr', 'st', 'tr', 'vr', 'chl', 'chr', 'phl', 'phr']
                                                voyelles = "eiaouy"
                                                coupures = []
                                                fin = len(mot)
                                                c = 0   # Position de la première consonne d'une séquence.
                                                i = 0
                                                while i < fin:
                                                    if mot[i] not in voyelles:
                                                        i += 1
                                                    else:
                                                        v = i   # Position de la première voyelle d'une séquence.
                                                        i += 1
                                                        while i < fin and mot[i] in voyelles:  i += 1   # Sauter toutes les voyelles suivantes.
                                                        # On est soit à la fin, soit sur une consonne.
                                                        p = max(c, v-1)
                                                        for k in range(v-2, c-1, -1):   # Pour toutes les séquences de 2 consonnes ou plus, s'il y en a.
                                                            if mot[k:v] in sequences:
                                                                p = k
                                                                break
                                                        coupures.append(p)
                                                        c = i
                                                coupures.append(fin)
                                                return ''.join([mot[coupures[i]:coupures[i+1]] for i in range(len(coupures)-1)][::-1])
                                            #
                                            mots = ['perchlorate', 'bonjour', 'bateau', 'france', 'algebre']
                                            for m in mots:
                                                print(inverserSyllabes(m))

                                            -
                                            Edité par PierrotLeFou 29 novembre 2021 à 2:54:48

                                            • Partager sur Facebook
                                            • Partager sur Twitter

                                            Le Tout est souvent plus grand que la somme de ses parties.

                                              29 novembre 2021 à 18:46:48

                                              J'étais arrivé à un résultat similaire mais avec des erreurs sur des mots "compliqués" tel que aujourd'hui ou encore vendredi

                                              Merci beaucoup pour votre aide

                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                29 novembre 2021 à 19:03:47

                                                Le mot "vendredi" se convertit facilement si on connait la séquence 'dr' comme dans ma liste. Je ne sais pas comment tu sépares "aujourd'hui".
                                                Quand je l'avais fait en C, j'utilisais le code ISO latin-1 dans lequel les lettres accentuées n'occupaient qu'un octet.
                                                Je considérais l'apostrophe comme une voyelle.
                                                Je pouvais séparer des mots comme "l'école" en "l'é-co-le"
                                                Avec ma liste des séquences et en ajoutant l'apostrophe aux voyelles, j'obtiendrais "au-jourd-h'ui"

                                                Pour les mots très particuliers, on peut se créer un dictionnaire.

                                                Par exemple, pour traiter "interactif":

                                                dico = {'interactif': 'in-ter-ac-tif'}

                                                -
                                                Edité par PierrotLeFou 29 novembre 2021 à 19:13:20

                                                • Partager sur Facebook
                                                • Partager sur Twitter

                                                Le Tout est souvent plus grand que la somme de ses parties.

                                                  29 novembre 2021 à 19:13:23

                                                  L'algorithme est en effet plus complexe que je pensais, même si je l'avais déjà codé en C il y a assez longtemps.

                                                  Oui ! Et sans tests unitaires, tu risques les régressions (un mot fonctionnait, puis par le changement de ton code, ne fonctionne plus).

                                                  Tu devrais créer une fonction par règle à mon avis, ça te permettra de modifier ta fonction si la règle a des exceptions.

                                                  Je pense qu'avec les règles que je partage sur mon lien précédent -> https://www.alloprof.qc.ca/fr/eleves/bv/francais/la-syllabe-f1595

                                                  Tu devrais déjà en faire pas mal.

                                                  • Partager sur Facebook
                                                  • Partager sur Twitter

                                                  Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
                                                  La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

                                                    29 novembre 2021 à 19:24:37

                                                    @fred1599:
                                                    Dans le lien on dit:
                                                    > 2. Si deux consonnes sont placées entre deux voyelles, la première appartient à la syllabe précédente, la seconde, à la syllabe suivante.
                                                    Comment sépares-tu "périphérique"?
                                                    ou "cidre", "replacer", etc.
                                                    Pour moi, c'est "pé-ri-phé-ri-que", "ci-dre", "re-pla-ce"
                                                    Mon algo résout beaucoup plus que tu ne le penses.
                                                    Comme je viens de le mentionner, on peutplacer les exceptions dans un dictionnaire.

                                                    J'avoue comme je l'ai mentionné que la séquence 'st' pose problème:

                                                    "instable" "constante" donnent-ils "in-sta-ble" et "cons-tan-te" ?

                                                    -
                                                    Edité par PierrotLeFou 29 novembre 2021 à 19:30:11

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter

                                                    Le Tout est souvent plus grand que la somme de ses parties.

                                                      29 novembre 2021 à 20:27:13

                                                      Bonsoir,
                                                      C'est quasi impossible à faire de façon parfaite...
                                                      Exemple entre 2 voyelles c'est possible mais ça dépend de la construction du mot ainsi on découpera :
                                                      •   ré/unir
                                                      •   extra/ordinaire
                                                      Mais :
                                                      •   oléo/duc 

                                                      Car ici on découpe en fonction de l'étymologie du mot !

                                                      ____________________________________________________________________________________

                                                      Des exemples de ce qu'il ne faut PAS faire :
                                                      •   vo//y//age (on évite de couper avant et après un y)
                                                      •   di//amant (cf. diamant n'est pas composé de di+amant il vient du latin adamantis) 
                                                      •   Bru//x//elles (car il s'agit d'un nom propre et on évite de couper avant et après un x)
                                                      •   aujourd’//hui (car on ne découpe pas après un apostrophe)

                                                      Mais on peut faire :
                                                      •   deu/xième (car le x se prononce ici "z")
                                                      •   pré/avis (car "pré" est un préfixe)

                                                      Donc à moins de faire un script de plusieurs dizaines voire centaines lignes qui te permettra de gérer tous les cas de figures en allant chercher dans une base de données comme wiktionary, il va falloir se contenter d'approximations.

                                                      -
                                                      Edité par ErispoeLeNarvalo 29 novembre 2021 à 20:32:37

                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        29 novembre 2021 à 20:48:38

                                                        Le code de Pierrot est pas mal du tout et relativement simple. Je le place ci-dessous, modifié pour notre problème  :

                                                        def syllabes(mot):
                                                            # Il peut manquer des séquences ou d'autres seraient invalides, 'st' est douteux.
                                                            sequences = [
                                                                'bl', 'br', 'ch', 'cl', 'cr', 'dr', 'fl', 'fr', 'gl', 'gn', 'gr', 'ph',
                                                                'pl', 'pr', 'st', 'tr', 'vr', 'chl', 'chr', 'phl', 'phr'
                                                            ]
                                                            voyelles = "eiaouy"
                                                            coupures = []
                                                            fin = len(mot)
                                                            c = 0  # Position de la première consonne d'une séquence.
                                                            i = 0
                                                            while i < fin:
                                                                if mot[i] not in voyelles:
                                                                    i += 1
                                                                else:
                                                                    v = i  # Position de la première voyelle d'une séquence.
                                                                    i += 1
                                                                    while i < fin and mot[i] in voyelles:
                                                                        i += 1  # Sauter toutes les voyelles suivantes.
                                                                    # On est soit à la fin, soit sur une consonne.
                                                                    p = max(c, v - 1)
                                                                    for k in range(
                                                                            v - 2, c - 1, -1
                                                                    ):  # Pour toutes les séquences de 2 consonnes ou plus, s'il y en a.
                                                                        if mot[k:v] in sequences:
                                                                            p = k
                                                                            break
                                                                    coupures.append(p)
                                                                    c = i
                                                            coupures.append(fin)
                                                            return [mot[coupures[i]:coupures[i + 1]] for i in range(len(coupures) - 1)]
                                                        
                                                        
                                                        mots = [
                                                            "theatre", "beaute", "espion", "chapeau", "charite", "articulation",
                                                            "extreme", "textuel", "fermer", "espoir", "quartier", "objet", "admis",
                                                            "canton", "expert", "massif", "acces", "aller", "rachat", "pathos",
                                                            "graphique", "mignon", "sable", "racler", "mufle", "bigle", "duplex",
                                                            "sabre", "nacre", "cadre", "soufre", "maigre", "stupre", "boutre",
                                                            "ouvrir", "compter", "obstine", "marcher", "morphine", "arbre",
                                                            "applaudir", "technique", "camphre", "instruction", "stagnant",
                                                            'perchlorate', 'bonjour', 'bateau', 'france', 'algebre'
                                                        ]
                                                        
                                                        for m in mots:
                                                            print(m, syllabes(m))
                                                        


                                                        Les meilleures règles que j'aie trouvées : Les coupures de mots à l'écrit

                                                        On peut tester en ligne : Syllaber - Découpe et compte de syllabes poétiques

                                                        -
                                                        Edité par PascalOrtiz 29 novembre 2021 à 20:51:36

                                                        • Partager sur Facebook
                                                        • Partager sur Twitter

                                                        Invertion des syllabes

                                                        × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                        × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                        • Editeur
                                                        • Markdown