################ 
##            ## 
## Exercice 3 ## 
##            ## 
################ 
print('\nExercice 3\n')


## Question 3.1



def affiche_miroir(s) :
    print(s , end=' ')
    # i prend les valeurs  -1, -2, -3, ... , -len(s)
    for i in range(-1,-len(s)-1,-1) :
        # s[-j] == s[len(s)-j] est le jème caractère en partant de la fin
        print(s[i] , end='')           
    print() # on va à la ligne à la fin

affiche_miroir("abc123")

def affiche_miroir_bis(s) :
    print(s , end=' ')
    # i prend les valeurs  1, 2, 3, ... , len(s)-1
    for i in range(len(s)) :  
        print(s[len(s) - i - 1] , end='')
    print()

affiche_miroir("abc123")





## Question 3.2


def miroir(s) :
    res = ''
    for i in range(len(s)) : 
        res = s[i] + res
        # et si on avait écrit ceci :
        # res = res + s[i]
        # Quelle aurait été la différence ?
    return res

print(miroir("abc"))
 
def miroir_bis(s) :
    res = ''
    # i prend les valeurs  -1, -2, -3, ... , -len(s)
    for i in range(-1,-len(s)-1,-1) : 
        res = res + s[i]
    return res

print(miroir_bis("abc"))

## Question 3.3


def est_un_palindrome(s) :
    if s == miroir(s) :
        return True
    else :
        return False
    
assert est_un_palindrome("toto") == False     # cas faux
assert est_un_palindrome("essayasse") == True # longueur impaire
assert est_un_palindrome("ANNA") == True      # longueur paire
assert est_un_palindrome("") == True          # chaîne vide




def est_un_palindrome_bis(s) :
    return s == miroir(s)

assert est_un_palindrome_bis("toto") == False
assert est_un_palindrome_bis("essayasse") == True

def est_un_palindrome_ter(s) :
    for i in range(len(s)) :
        if s[i] != s[len(s)-i-1] :
            return False
    return True



assert est_un_palindrome_ter("toto") == False
assert est_un_palindrome_ter("essayasse") == True





################ 
##            ## 
## Exercice 4 ## 
##            ## 
################ 
print('\nExercice 4\n')

# Question 4.1



def nombre_apparitions(c,s) :
    res = 0
    for i in range(len(s)) :
        if s[i] == c :
            res = res + 1
    return res

assert nombre_apparitions('e','les revenentes')==5
assert nombre_apparitions('e','la disparition')==0


def nombre_apparitions_bis(c,s) :
    res = 0
    for c2 in s :
        if c == c2 :
            res = res + 1
    return res

assert nombre_apparitions_bis('e','les revenentes')==5
assert nombre_apparitions_bis('e','la disparition')==0

## Question 4.2




def absence_de_e_if(s) :
    if nombre_apparitions('e',s) == 0  and nombre_apparitions('E',s) == 0 :
        return True
    else :
        return False



def absence_de_e(s) :
    return nombre_apparitions('e',s) == 0 and nombre_apparitions('E',s) == 0 


assert absence_de_e("")==True # On essaye la chaîne vide
assert absence_de_e("Salut")==True # On essaye un chaîne sans e
assert absence_de_e("eSalut")==False # On essaye e/E au début au mileu et à la fin
assert absence_de_e("SalEut")==False 
assert absence_de_e("Salute")==False 

## Question 4.3


## Question 4.4


def absence_de_e_efficace(s) :
    for i in range(len(s)) :
        if s[i] in 'eE' :
            return False
    return True




################ 
##            ## 
## Exercice 5 ## 
##            ## 
################ 
print('\nExercice 5\n')


def entrelacement(s1,s2) :
    # Le assert est facultatif. Il permet de s'assurer que la condition est bien vérifiée.
    assert len(s1) == len(s2)
    res = ''
    for i in range(len(s1)) :
        res = res + s1[i] + s2[i]
    return res


print(entrelacement("abc",'123'))





################ 
##            ## 
## Exercice 6 ## 
##            ## 
################ 
print('\nExercice 6\n')



def est_bien_ponctuée(s) :
    for i in range(len(s)) :
        if s[i] == '.' and i != len(s) - 1 and s[i+1] != ' ' :
            return False
    return True


assert est_bien_ponctuée('Un. Deux.') == True
assert est_bien_ponctuée('Trois.Quatre.')==False


def est_bien_ponctuée_bis(s) :
    for i in range(len(s)) :
        if s[i] == '.' :
            if i != len(s) - 1 :
                if s[i+1] != ' ' :
                    return False
    return True

assert est_bien_ponctuée_bis('Un. Deux.')==True
assert est_bien_ponctuée_bis('Trois.Quatre.')==False





################ 
##            ## 
## Exercice 7 ## 
##            ## 
################ 
print('\nExercice 7\n')




def est_pangramme(s) :
    alphabet = 'abcdefghijklmnopqrstuvwxyz'
    s = s.lower()
    # on aurait pu écrire "for i in range(len(alphabet))" puis s[i]
    # au lieu de c dans la suite
    for c in alphabet :
        if not (c in s) :   
            return False
    return True


assert est_pangramme('abcdefghijklmnopqrstuvwxyz')==True
assert est_pangramme('Portez ce vieux whisky au juge blond qui fume.')==True
assert est_pangramme('Portez ce jeune cognac à l’avocat roux qui fulmine.')==False


def est_pangramme_bis(s) :
    s  = s.lower()
    for i in range(26):
        if chr(ord('a') + i) not in s :
            return False
    return True

assert est_pangramme_bis('abcdefghijklmnopqrstuvwxyz')==True
assert est_pangramme_bis('Portez ce vieux whisky au juge blond qui fume.')==True
assert est_pangramme_bis('Portez ce jeune cognac à l’avocat roux qui fulmine.')==False





################ 
##            ## 
## Exercice 8 ## 
##            ## 
################ 
print('\nExercice 8\n')


def est_bien_parenthesée(s) :
    n = 0 # <- n est le nombre de parenthèses ouvertes non encore fermées dans s[:i]
    for i in range(len(s)) :
        if s[i] == '(' :
            n = n + 1
        elif s[i] == ')' :
            n = n - 1
            if n < 0 :
                return False
    return n == 0

assert est_bien_parenthesée('(1+2)×(x+(1-3))') == True
assert est_bien_parenthesée('(1+2)×(x+1-3))') == False
assert est_bien_parenthesée('(1+2)×()x+(1-3))') == False