Fonctions

On propose ici également un rappel des fonctions déjà écrites afin d'avoir une vue d'ensemble du programme.

def nbCaracIdentiq(chaine) :
    """ L'entrée chaine est une chaine de caractères.
    La sortie est un entier positif.
    La fonction retourne le nombre de caractères successifs en tête de chaine
    qui sont égaux à chaine[0].
    Par exemple, NbCaracIdentiq('331234') est égal à 2.
    NbCaracIdentiq('bbb12cb34') est égal à 3. 
    L'image de la chaîne vide '' doit être 0.
    """
    
    if len(chaine) == 0 : 
        return 0 # si la chaine est vide, l'image est 0.
     
    premier_caractere = chaine[0]
    cpt = 0 # compteur pour le nb de caractères 
           # identiques en tête de chaine
     
    for x in chaine :
        if x == premier_caractere : cpt += 1
        else : break
    return cpt 
    
    
    
    
def coupeRepetTete(ch):
    """ L'entrée ch est une chaîne de caractères.
    La sortie sera une chaîne de caractères chsortie.
    chsortie est ch privée du premier caractère ch[0]
    ainsi que des caractères qui suivent égaux à ch[0].
    Si par exemple ch='rrtzra', 
    alors coupeRepetTete(ch)='tzra'. """
    m = nbCaracIdentiq(ch) # m est le nombre de caractères
                         # identiques en tête de chaîne
    return ch[m:] # on retourne la chaîne
                   # privée des m premiers caractères
                   
    
def ligneSuivante(ch):
    """ L'entrée ch est une chaîne de caractères.
    La sortie sera une chaîne de caractères.
    Le principe de construction de la chaîne de sortie 
    à partir de la chaîne d'entrée est le principe
    de la suite de Conway  
    http://fr.wikipedia.org/wiki/Suite_de_Conway. """
    
    ligne = ''
    while ch != '' :
        ligne += str(nbCaracIdentiq(ch))+ch[0]
        ch = coupeRepetTete(ch)
    return ligne
    
    
def triangleConway(ch,n):
    """ ch : chaîne de caractères, constituée de chiffres.
    n entier > 0.
    La fonction retourne une chaîne de caractères.
    Le résultat est un empilement en 'triangle'  des  n premiers termes
    de la suite de Conway. """
    
    triangle = ''
    ligne_suiv = ch
    for i in range(n) :
        triangle += ligne_suiv+'\n'
        ligne_suiv = ligneSuivante(ligne_suiv)
    return triangle
    
    
## utilisation de la fonction ##               
print(triangleConway('1',10))    

Affichage :

1
11
21
1211
111221
312211
13112221
1113213211
31131211131221
13211311123113112211

""" 
Suite de Robinson.
http://fr.wikipedia.org/wiki/Suite_de_Robinson  
"""

def compteCarac(ch, car) :
    """ ch est une chaîne de caractères.
    car est un caractère.
    La fonction retourne un int, égal au nombre 
    d'occurrences du caractère car dans la chaîne ch."""
    
    cpt = 0
    for x in ch :
        if x == car :
            cpt += 1
    return cpt
    # en fait existe déjà en python : ch.count(car)

def ligneSuivante(ch) :
    """ ch est une chaîne de caractères, constituée de chiffres.
    La fonction retourne une chaîne de caractères, 
    terme suivant dans la suite de Robinson
    http://fr.wikipedia.org/wiki/Suite_de_Robinson  """
    lig_suiv = ''
    for k in '9876543210' :
        if k in ch :
            lig_suiv += str(compteCarac(ch, k))+k
    return lig_suiv
    
def triangleRobinson(ch, n) :
    """ ch est une chaîne de caractères.
    n est un entier >0.
    La fonction retourne une chaîne de caractères, 
    empilement de n termes successifs de la suite de Robinson
    à partir du premier terme ch."""
    triangle = ''
    lig_suiv = ch
    for i in range(n) :
        triangle += lig_suiv+'\n'
        lig_suiv = ligneSuivante(lig_suiv)
    return triangle
    
print(triangleRobinson('0',10))

def javanais(mot, syll) :
    
    ## on passe le mot en minuscules.
    motminus = mot.lower()
    
    voyelles = 'aeiouy'
    Voyelles = 'AEIOUY'
    consonnes = 'bcdfghjklmnpqrstvwxz'
    Consonnes = 'BCDFGHJKLMNPQRSTVWXZ'
    
    motjav = '' # contiendra la traduction javanaise.
    
    ## boucle pour ajouter syll derrière les groupes de consonnes  
    ## sauf derrière la consonne éventuelle de fin de mot.       
    for j in range(len(motminus)-1) :
        if (mot[j] in consonnes and motminus[j+1] not in consonnes) :
            motjav += motminus[j]+syll
        else :
            motjav += motminus[j]
    
    ## On ajoute la dernière lettre du mot de départ au résultat. 
    motjav+=motminus[-1]  
    
    ## On ajoute syll au début du mot résultat      
    ## si mot commençait par une voyelle.          
    if motminus[0] in voyelles :
        motjav = syll+motjav
        
    ## Raffinement pour le fun.   
    ## si le mot commençait par une majuscule (nom propre...)  
    ## le résultat commencera par une majuscule.  
    if mot[0] in Voyelles or mot[0] in Consonnes:
        motjav = motjav[0].upper() + motjav[1:]
        
    return motjav
    
print("javanais('Abraracourcix','av') : ", javanais('Abraracourcix','av'))
print("javanais('Abraracourcix','oz') : ", javanais('Abraracourcix','oz'))

print("javanais('pythonique','ail') : ", javanais('pythonique','ail'))

def bissextile(n) :
    regle = (n%4 == 0)
    exception = (n%100 == 0 and n%400 != 0)
    return regle and not(exception)

print(bissextile(1900))
print(bissextile(2000))
print(bissextile(2002))
print(bissextile(2012))