def sauv_ex(n,chaine):
    """sauvegarde exercice n"""
    with open ("ennonces_html/exercice"+str(n)+".html", "w",encoding='utf-8') as f:
        f.write(chaine)

def sauv_corr(n,chaine):
    """sauvegarde correction n"""
    with open ("corriges_html/exercice"+str(n)+".html", "w",encoding='utf-8') as f:
        f.write(chaine)
        
        
def repertoires():
    from os import makedirs
     #preparation des repertoires de sauvegarde                    ,             ,
    for repertoire in ("ennonces_html","corriges_html","exercices_pdf"):
        try:
            makedirs(repertoire)
        except:
            pass
def ecrire(n):
    """ecrire proprement un entier"""
    chaine=str(n)
    k=len(chaine)%3
    if k==0:
        k=3
    o=0
    newchaine=""
    for c in chaine:
        newchaine+=c
        o+=1
        if o==k:
            newchaine+=" "
            o-=3
    return newchaine


def ecrire2(n):
    """ecrire proprement un decimal"""                     
    chaine=str(n)
    decompo=chaine.split(".")
    if len(decompo)<2:
        return ecrire(int(n))

    elif  decompo[1]=="0":
        return ecrire(int(n))
    else:
        pe=ecrire(decompo[0])
        pd=ecrire(decompo[1][::-1])[::-1]
        return pe+","+pd
    
    
def fraction_chaine(a,b):
    return """<p style="display: inline-block;
        vertical-align: middle; 
        margin: 0 0.2em 0.4ex;
        text-align: center;">

    <span style="display: block; padding-top: 0.15em;">{}</span>
    <span style="display: none;">/</span>
    <span style="border-top: thin solid black;">{}</span>
    </p>""".format(a,b) 
    
def fraction_entiers(n,p,forcer=False):
 
    if forcer or p!=1:
        return fraction_chaine(ecrire(n),ecrire(p))
    else:
        return ecrire(n)
    
    

def round2(x,nbdigit=0):
    """x est un nombre, la fonction renvoie l'arrondi à nbdigit près
       sans riquer des erreurs d'arrondi comme avec la fonction native   
    
    """
    if not isinstance(x, (int,float)):
        raise NameError("x must be int or float")
        return
    if not isinstance(nbdigit,int):
        raise NameError("nbdigit must be integer")
        return
    if nbdigit<0 :
        raise NameError("error nbdigit <0 ")
        return
    if x<0:
        return -round2(-x)
    #x est un nombre positif, et nbdigit un entier positif
    partie1=str(x).split(".")[0][:-1]
    partie2=str(x).split(".")[0][-1]
    try:
        partie2+=str(x).split(".")[1]
    except:
        pass
    pcorrige=""
    n=0
    while n<=nbdigit:
        try:
            pcorrige+=partie2[n]
            
        except:
            pass
        n+=1
    try:
        suivant=int(partie2[n])
    except:
        suivant =0
    p=partie1+pcorrige[0]
    if len (pcorrige)>1:
            p+="."+pcorrige[1:]
  
    nb=[x for x in p]
    if suivant>4:
        nb=["0"]+nb
        ok=False
        x=len(nb)
        while not ok:
            x-=1
            if nb[x]!=".":
                if int(nb[x])<9:
                    nb[x]=str(int(nb[x])+1)
                    ok=True
                else:
                    nb[x]="0"
    nb=float("".join(nb))
    if nb==int(nb):
        nb=int(nb)
    return nb

def deux_chiffres2lettres(n):
    """ convertit un nombre de deux chiffres en lettre """
    if n==71:
        return "soixante et onze"
    chiffre={   0:"z&eacute;ro",
                1: "un", 
                2 :"deux",
                3 : "trois",
                4 : "quatre",
                5 : "cinq" ,
                6 : "six",
                7 : "sept",
                8 : "huit",
                9 : "neuf",
                10 : "dix",
                11 : "onze",
                12: "douze",
                13 :"treize",
                14 :"quatorze",
                15 : "quinze",
                16 : "seize",
                17 : "dix-sept",
                18 : "dix-huit",
                19 : "dix-neuf"}

    dizaines={10 : "dix",
             20: "vingt", 
             30: "trente",
             40: "quarante",
             50: "cinquante",
             60: "soixante",
             80: "quatre-vingts"}
    if n in chiffre.keys():
        return chiffre[n]
    elif n in dizaines.keys():
        return dizaines[n]
    elif (n//10)*10 in dizaines.keys():
        dizaines[80]="quatre-vingt"
        chaine=dizaines[(n//10)*10]
        d=(n//10)*10
        u=n-d
        if u>1:
            return chaine+"-"+chiffre[u]
        elif u==0:
            return chaine
        else :# et un ?
            if d==80 :
                return chaine+"-un"
            else:
                return chaine+"-et-un"
    else:
        dizaines[80]="quatre-vingt"
        d=(n//10)*10-10
        r=n-d
        return dizaines[d]+"-"+chiffre[r]
            

        

                 

        
def trois_chiffres2lettres(n):
    """ convertit un nombre de trois chiffres en lettre """
    chiffre={   0:"z&eacute;ro",
                1: "un", 
                2 :"deux",
                3 : "trois",
                4 : "quatre",
                5 : "cinq" ,
                6 : "six",
                7 : "sept",
                8 : "huit",
                9 : "neuf"}
    c=n//100
    r=n-c*100
    
    chaine=""
    if c==0:
        return deux_chiffres2lettres(r)
    elif c==1 and r!=0:
        return "cent-"+deux_chiffres2lettres(r)
    elif c==1 and r==0:
        return "cent"
    elif r==0:
        return chiffre[c]+"-cents"
    else:
        return chiffre[c]+"-cent-"+deux_chiffres2lettres(r)
        
        
        
    return chaine

def nb2lettres(n):
    """ convertit un nombre en lettre """
    chaine=""
    if type(n) is not int:
       print("la fonction ne supporte que le type entier pour l'instant")
       return
    elif len(str(n))>15:
        print("Nombre trop grand!")
        return
    elif n==0:
        return "z&eacute;ro"
    else:
        

    
        

        #decomposition en classe
        classe=10**9
        lesclasses=[]
        for i in range(4):
            lesclasses.append(n//classe)
            n=n%classe
            classe=classe//10**3
        
        rang=10**12
        #milliards
        if lesclasses[0]==1:
            chaine="un milliard "
        elif lesclasses[0]>1:
            chaine=trois_chiffres2lettres(lesclasses[0])+" milliards "
        else:
            chaine=""

        #millions
        if lesclasses[1]==1:
            chaine+="un million "
        elif lesclasses[1]>1:
            chaine+=trois_chiffres2lettres(lesclasses[1])+" millions "

        #milliers
        milliers=trois_chiffres2lettres(lesclasses[2])
        if lesclasses[2] in (200,300,400,500,600,700,800,900,80,180,280,380,480,580,680,780,880,980):
            milliers=milliers[:-1] #on doit  enlever le s si multiple de 100 ou fini par 80
        if lesclasses[2]==1:
            chaine+="mille"
        elif lesclasses[2]>1:
            chaine+=milliers+"-mille"

        #unit&eacute;s
        if lesclasses[2]!=0 and lesclasses[3]!=0:
            chaine+="-"
        if lesclasses[3]>0:
            chaine+=trois_chiffres2lettres(lesclasses[3])
            
            
            
       
        return chaine[0].upper()+chaine[1:]+"."