Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 4 sur 4
  1. #1
    Invité régulier
    Inscrit en
    novembre 2011
    Messages
    39
    Détails du profil
    Informations forums :
    Inscription : novembre 2011
    Messages : 39
    Points : 8
    Points
    8

    Par défaut

    Bonjour je met mon 2ème module, une fonction qui cette fois convertie les Chiffre Arabes en Chiffres Romain à sens unique cette fois, toujours pour python 2.7
    Attention vous devez impérativement utiliser idle ou autres programme supportant les caractère unicode pour les nombre supérieur à 3.999, car la fonction utilise le caractère unicode 304 en hexadécimal sois 772 en décimal pour le macron des milliers le code

    Code :
    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
    # -*- coding: cp1252 -*-
    def chiffres_romain(n, sep=u"."):
        s=str(int(n))
        l=len(s)
        def nombre_romain(list_chiffre, res_chiffre, romain, nb_macron, rang, sep):
            for chiffre_var in list_chiffre:
                if (4<=res_chiffre<=999 and nb_macron>=1) or (0<=res_chiffre<=999 and nb_macron==0):
                    if rang==0:
                        if 1<=int(chiffre_var)<=3:
                            romain=unicode(("I" + (unichr(772) * nb_macron)) * int(chiffre_var) + romain)
                            rang+=1
                        elif 4<=int(chiffre_var)<=8:
                            nb=int(chiffre_var)-5
                            if nb==-1:
                                romain=unicode(("I" + (unichr(772) * nb_macron)) + ("V" + (unichr(772) * nb_macron)) + romain)
                                rang+=1
                            elif 0<=nb<=3:
                                romain=unicode(("V" + (unichr(772) * nb_macron)) + ("I" + (unichr(772) * nb_macron)) * nb + romain)
                                rang+=1
                        elif int(chiffre_var)==9:
                            romain=unicode(("I" + (unichr(772) * nb_macron)) + ("X" + (unichr(772) * nb_macron)) + romain)
                            rang+=1
                        elif int(chiffre_var)==0:
                            romain=unicode(romain)
                            rang+=1
                    elif rang==1:
                        if 1<=int(chiffre_var)<=3:
                            romain=unicode(("X" + (unichr(772) * nb_macron)) * int(chiffre_var) + romain)
                            rang+=1
                        elif 4<=int(chiffre_var)<=8:
                            nb=int(chiffre_var)-5
                            if nb==-1:
                                romain=unicode(("X" + (unichr(772) * nb_macron)) + ((unichr(772) * nb_macron) + "L") + romain)
                                rang+=1
                            elif 0<=nb<=3:
                                romain=unicode(("L" + (unichr(772) * nb_macron)) + ("X" + (unichr(772) * nb_macron)) * nb + romain)
                                rang+=1
                        elif int(chiffre_var)==9:
                            romain=unicode(("X" + (unichr(772) * nb_macron)) + ("C" + (unichr(772) * nb_macron)) + romain)
                            rang+=1
                        elif int(chiffre_var)==0:
                            romain=unicode(romain)
                            rang+=1
                    elif rang==2:
                        if 1<=int(chiffre_var)<=3:
                            romain=unicode(("C" + (unichr(772) * nb_macron)) * int(chiffre_var) + romain)
                            rang+=1
                        elif 4<=int(chiffre_var)<=8:
                            nb=int(chiffre_var)-5
                            if nb==-1:
                                romain=unicode(("C" + (unichr(772) * nb_macron)) + ("D" + (unichr(772) * nb_macron)) + romain)
                                rang+=1
                            elif 0<=nb<=3:
                                romain=unicode(("D" + (unichr(772) * nb_macron)) + ("C" + (unichr(772) * nb_macron)) * nb + romain)
                                rang+=1
                        elif int(chiffre_var)==9:
                            romain=unicode(("C" + (unichr(772) * nb_macron)) + ("M" + (unichr(772) * nb_macron)) + romain)
                            rang+=1
                        elif int(chiffre_var)==0:
                            romain=unicode(romain)
                            rang+=1
                elif 1<=res_chiffre<=3 and nb_macron>=1:
                    romain=unicode(sep + ("M" + (unichr(772) * (nb_macron-1))) * res_chiffre + romain)
                    rang=0
            return romain
        nb_macron=0
        nc=0
        res=""
        romain=u""
        rang=0
        for i in range(l-1, -1 ,-1):
            res=s[i] + res
            nc+=1
            if nc==3:
                list_chiffre=list(res)
                list_chiffre.reverse()
                res_chiffre=int(res)
                romain=nombre_romain(list_chiffre, res_chiffre, romain, nb_macron, rang, sep)
                if (4<=res_chiffre<=999 and nb_macron>=1) or (1<=res_chiffre<=999 and nb_macron==0):
                    romain=unicode(sep + romain)
                elif 1<=res_chiffre<=3 and nb_macron>=1:
                    None
                nb_macron+=1
                nc=0
                del res_chiffre
                del list_chiffre
                del res
                res=""
        try:
            if 1<=len(res)<=2:
                list_chiffre=list(res)
                list_chiffre.reverse()
                res_chiffre=int(res)
                romain=nombre_romain(list_chiffre, res_chiffre, romain, nb_macron, rang, sep)
                del res_chiffre
                del list_chiffre
                del res
                del nc
        except:
            None
        if romain.startswith(sep):
            romain=romain[1:]
        if n < 0 and romain[1]==sep:
            romain=list(romain)
            del romain[1]
            romain="".join(romain)
        return romain
    Fichiers attachés Fichiers attachés

  2. #2
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    5 238
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 5 238
    Points : 7 251
    Points
    7 251

    Par défaut

    Salut,

    Excusez moi mais votre approche me semble compliquée (au vu du nombre de lignes).

    Soit un entier N, pour le traduire en chiffre romain, on va:
    - chercher quel est la plus grande valeur du symbole romain S qu'il dépasse,
    - avec ce V on accumule un symbole
    puis on recommence avec N - V.
    Exemple.

    Soit N = 14.
    La liste des (valeurs, symboles) qui nous intéresse est: RMAP = [(10, 'X'), (9, 'IX'), (5, 'V'), (4, 'IV'), (1, 'I')]
    1ère iteration 14 => le V est RMAP[0][0] (=10) on empile X et on réitère
    2eme itération 4 => le V est RMAP[0][3](=4) et on empile IV et on arrête car N=0

    On peut traduire cela en Python:

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    RMAP = [ (10, 'X'),   (9,  'IX'),  (5,  'V'),  (4,  'IV'), (1,  'I')]
     
    def n2r(n):
         r = [] # la liste dans laquelle on empile les resultats
         for v, s in RMAP:
              while n >= v: 
                   r.append(s)
                   n -= v
         return ''.join(r)
    Comme résultats çà donne:

    Code :
    1
    2
    3
    4
    5
    6
    7
    >>> n2r(10)
    'X'
    >>> n2r(9)
    'IX'
    >>> n2r(14)
    'XIV'
    >>>
    Reste à compléter la RMAP pour qu'elle intègre les (valeurs, symboles) plus grands C, L,...
    C'est quand même plus court et plus lisible non?

    - W
    PS: Les symboles romains sont représentés par des caractères ASCII < 127. Que Python les représente Unicode ou en bytes, leur conversion dans un charset supporté par la console sera dans ce cas identique.
    Architectures Post-Modernes

  3. #3
    Invité régulier
    Inscrit en
    novembre 2011
    Messages
    39
    Détails du profil
    Informations forums :
    Inscription : novembre 2011
    Messages : 39
    Points : 8
    Points
    8

    Par défaut

    Ok merci beaucoup pour ton aide précieux wiztricks, il est vrai que ton code est plus lisible que le miens je met le nouveau ici et je garde tout de même l'ancien code aux cas ou ça intéresser quelqu'un pour l'ancien code, le nouveau code d'après ton modèle
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    RMAP = [ (1000, 'M'), (900, 'CM'), (500, 'D'), (400, 'CD'), (100, 'C'), (90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'), (5, 'V'), (4, 'IV'), (1, 'I')]
    def n2r(n):
        r = [] # la liste dans laquelle on empile les resultats
        for v, s in RMAP:
            while n >= v: 
                r.append(s)
                n -= v
        return ''.join(r)
    le problème c'est que les milliers et plus nombre supérieur à 3.999 sont erroner avec ce type de code car 4000 ne s'écrit pas MMMM mais bien
    ĪV̄
    et désoler pour le macron qui fait bugger le forum. Des idées pour ce problème de milliers et plus?

  4. #4
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    5 238
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 5 238
    Points : 7 251
    Points
    7 251

    Par défaut

    Salut,
    ̄X

    Citation Envoyé par MediaVistaIntel Voir le message
    le problème c'est que les milliers et plus nombre supérieur à 3.999 sont erroner avec ce type de code car 4000 ne s'écrit pas MMMM mais bien et désoler pour le macron qui fait bugger le forum. Des idées pour ce problème de milliers et plus?
    La règle de transformation des nombres décimaux >3999 est identique:
    on peut y ajouter les tuples (10000, u'X̄\u0304'), (5000, u'V\u0304'), (4000, u'I\u0304V\u0304')...

    Cela implique qu'on utilise des représentations Unicode plutôt que des bytes ASCII passe partout.

    La difficulté sera que l'affichage suive côté configuration de la console.
    Maintenant, vous pourriez très bien réaliser votre application en tkinter, ce qui permettrait peut être de s'affranchir de cela:

    Regardez ce qu'affiche:
    Code :
    1
    2
    3
    >>> import Tkinter as tk
    >>> tk.Button(text=u'\u2167').pack()    # "VIII"
    >>> tk.Button(text=u'X\u0304').pack()  # X-caron
    - W
    Architectures Post-Modernes

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •