Exercice 1

On veut crypter une chaine de caractères données CH dont la taille ne dépasse pas 50
caractères en une chaine résultat Res de la manière suivante : parcourir la chaine CH
de gauche à droite en comptant le nombre d’occurrence successives de chaque
caractère de la chaine CH, puis de ranger la chaine Res, ce nombre suivi du caractère e
question.
Ecrire un programme Python permettant de saisir la chaine CH qui doit être non vide
et forméeuniquement par des lettres alphabétiques, puis de former et d’afficher la
chaine Res selon le principe décrit précédemment.
Exemple

 Si CH=’aaaFyBssssssssssssazz’alors la chaine Res qui seraaffichée est

‘3a1F1y1B12s1a2z’

def crypter(CH):
    res = ''
    if len(CH) <= 50:
        cpt = 1
        for i in range(len(CH)-1):
            if CH[i] == CH[i+1]:
                cpt += 1
            else:
                res += str(cpt)+CH[i]
                cpt = 1
        res += str(cpt)+CH[-1]
    return res
 
 
print(crypter("aaaFyBssssssssssssazz"))

Exercice 2
On se propose d’écrire un programme qui permet de saisir et de crypter un mot M
non vide, composé uniquement par des lettres majuscules et d’afficher le mot crypté
MC.
La méthode de cryptage est la suivante :
   Pour chaque lettre, déterminer son nombre d’occurrence
(apparition) n dans le mot M. Déterminer K qui est égal à 2*n si n est impair
et sera égal à (n DIV 2) si n est pair. Remplacer chaque lettre par Kième
lettre qui la suit dans l’intervalle de l’alphabet [‘A’…’Z’]. Pour les dernières
lettres, on rend dès le début, par exemple si K=3, on remplacera ‘A’ par
‘D’,’B’ par ‘E’, ‘C’ par ‘E’… ‘Y’ par ‘B’ et ‘Z’ par ‘C’.
Exemple

Pour le mot ‘HAPPY’

Le mot crypté sera :’JCQQA’
Ecrire un programme Python qui permet de saisir un mot non vide et composé
uniquement par des lettres majuscules, puis d’afficher le mot crypté selon le principe
décrit ci-dessus.
def crypter_mc(s):
    alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    res = ''
    for lettre in s:
        occurence = s.count(lettre)
        pos = 0
        if occurence % 2 == 0:
            pos = occurence//2
        else:
            pos = occurence*2
        ordre = alpha.find(lettre)
        indice = pos+ordre
        if indice > 25:
            indice = indice % 26
        res += alpha[indice]
    return res
 
 
print(crypter_mc("HAPPY"))

Exercice 3

Un des plus anciens systèmes de cryptographie (aisément déchiffrable) consiste à décaler les
lettres d’un message pour le rendre illisible. Ainsi, les A deviennent des B, les B des C, etc. Et
les Z deviennent des A
Exemple

 Si CH=’ABCCZABEY’alors la chaine Res crypté qui seraaffichée est

‘BCDDABCEZ’
Ecrivez un programme qui demande une chaine CH à l’utilisateur et qui la code dans une
chaine Res selon ce principe.

def crypter(ch):
    alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    res = ''
    for caractere in ch:
        indice = alpha.find(caractere)
        pos = indice+1
        if pos == 26:
            pos = 0
        res += alpha[pos]
    return res
 
 
print(crypter("ABCCZABEY"))

Exercice 4
Une amélioration (relative) du principe utilisé dans l’exercice 3 consiste à opérer avec
undécalage non de 1, mais d’un nombre quelconque de lettres. Ainsi, par exemple, si
l’on choisit un décalage de 3, les A deviennent des E, les B des E, etc. Et les Z
deviennent C
Réalisez un programme python sur le même principe que le précédent, mais qui
demande en plus quel est le décalage à utiliser.
def cesar(s, d):
    alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    res = ''
    for lettre in s:
        ordre = alpha.find(lettre)
        indice = ordre+d
        if indice > 25:
            indice = indice % 26
        res += alpha[indice]
    return res
 
 
print(cesar("ABCDEFGH", 3))

Exercice 5

Une technique ultérieure de cryptographie consista à opérer non avec un décalage

systématique, mais par une substitution aléatoire. Pour cela,on utilise un alphabet-clé,
dans lequel les lettres se succèdent de manière désordonnée, par exemple,
"HYLUJPVREAKBNDOFSQZCWMGITX" C’est cette clé qui va servir ensuite à coder
le message. Selon notre exemple, les A deviendront des H, les B des Y, les C des L, etc.
Exemple

 Si CH=’ABCDEFZ’ alorsla chaine Res crypté qui seraaffichée est ‘HYLUJPX’

Ecrire un programme Python qui effectue ce cryptage (l’alphabet-clé sera saisi par
l’utilisateur, et on suppose qu'il effectue une saisie correcte) sur une chaine de
caractères CH et stocker le résultat dans Res
def crypter_alea(msg):
    cle = 'HYLUJPVREAKBNDOFSQZCWMGITX'
    alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    res = ''
    for caractere in msg:
        indice = alpha.find(caractere)
        res += cle[indice]
    return res
 
 
print(crypter_alea("ABCDEFZ"))

Exercice 6

Un système de cryptographie beaucoup plus difficile à briser que les précédents fut
inventé au XVIe siècle par le français Vigenère. Il consistait en une combinaison de
différents chiffres de César.
On peut en effet écrire 25 alphabets décalés par rapport à l’alphabet normal :
  L’alphabet qui commence par B et finit par …YZA
  L’alphabet qui commence par C et finit par …ZAB
  etc.
Le codage va s’effectuer sur le principe du chiffre de César : on remplace la lettre
d’origine par la lettre occupant la même place dans l’alphabet décalé.
Mais à la différence du chiffre de César, un même message va utiliser non un, mais
plusieurs alphabets décalés. Pour savoir quels alphabets doivent être utilisés, et dans
quel ordre, on utilise une clé.
Si cette clé est "VIGENERE" et le message "Il faut coder cette phrase", on procèdera
comme suit :
La première lettre du message, I, est la 9e lettre de l’alphabet normal. Elle doit être
codée en utilisant l’alphabet commençant par la première lettre de la clé, V. Dans cet
alphabet, la 9e lettre est le D. I devient donc D.
La deuxième lettre du message, L, est la 12e lettre de l’alphabet normal. Elle doit être
codée en utilisant l’alphabet commençant par la deuxième lettre de la clé, I. Dans cet
alphabet, la 12e lettre est le S. L devient donc S, etc.
Quand on arrive à la dernière lettre de la clé, on recommence àla première.
Ecrire un programme python qui effectue un cryptage de Vigenère,en demandant bien
sûr au départ la clé à l’utilisateur.
def Vigenere(msg, cle):
    alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    res = ''
    i = 0
    for caractere in msg:
        debut = alpha.find(cle[i])
        pos = alpha.find(caractere)
        indice = pos+debut
        if indice > 25:
            indice -= 26
        res += alpha[indice]
        i += 1
        if i >= len(cle):
            i = 0
    return res
 
 
print(Vigenere("Il faut coder cette phrase", "VIGENERE"))
Exercice 7
Un administrateur d’un site web veut assurer un maximum de sécurité pour les
utilisateurs du site. Pour ceci il décide de réaliser une application qui évalue la force
des mots de passe des différents utilisateurs du site, sachant qu’un mot de passe est
une chaine de caractères qui ne comporte pas d’espaces et de lettres accentuées.
La force d’un mot de passe varie, selon la valeur d’un score calculé, de ‘Très faible’
jusqu’à ‘Très fort’ :
  Si le score <20, la force du mot de passe est ‘Très faible’
  Sinon si le score<40, la force d’un mot de passe est ‘Faible’
  Sinon si le score <80, la force du mot de passe est ‘Fort’
  Sinon la force du mot de passe est ‘Très fort’
Le score se calcule en additionnant des bonus et en retranchant des pénalités.
Les bonus attribués sont :
  Nombre total de caractères * 4
  (Nombre total de caractères – nombre de lettres majuscules) * 2
  (Nombre total de caractères – nombre de lettres minuscules) * 3
  Nombre de caractères non alphabétiques * 5
Les pénalités imposées sont :
  La longueur de la plus longue séquence de lettres minuscules * 2
  La longueur de la plus longue séquence de lettres majuscules * 3
Exemple

Pour le mot de passe ‘P@cSI_promo2017’, le score se calcule comme suit :

La somme de bous = 15*4 + (15-3) *2 + (15-6) *3+6*5=141
  Le nombre total de caractères = 15
  Le nombre de lettres majuscules = 3
  Le nombre de lettres minuscules=6
  Le nombre de caractères non alphabétiques =6
  La somme des pénalités = 5*2+2*2=14
  La longueur de la plus longue séquence de lettres minuscules(‘promo’) =5
  La longueur de la plus longue séquence de lettres majuscules(‘SI’) =2
Le score final = 141-14=127 ; puisque 127>80 alors le mot de passe est considéré
comme ‘Très fort’
Travail demandé :
1. Ecrire une fonction NbCMin(pass) qui retourne le nombre de caractères
minuscules.
2. Ecrire une fonction NbCMaj(pass) qui retourne le nombre de caractères
majuscules.
3. Ecrire une fonction NbCAlphapass) qui retourne le nombre de caractères
non alphabétiques.
4. Ecrire une fonction LongMaj(pass) retourne la longueur de la plus longue
séquence de lettres majuscules.
5. Ecrire une fonction LongMin(pass) retourne la longueur de la plus longue
séquence de lettres minuscules.
6. Ecrire une fonction Score(pass) qui affiche le score d’un mot de passe
def NbcMin(passe):
    nb = 0
    for i in passe:
        if 'a' <= i <= 'z':
            nb += 1
    return nb
 
 
def NbcMaj(passe):
    nb = 0
    for i in passe:
        if 'A' <= i <= 'Z':
            nb += 1
    return nb
 
 
def NbcAlpha(passe):
    return len(passe)-NbcMaj(passe)-NbcMin(passe)
 
 
def longMaj(passe):
    d = 0
    s = 0
    i = 0
    while i < len(passe):
        if 'A' < passe[i] < 'Z':
            s += 1
        else:
            if s > d:
                d = s
                s = 0
        i += 1
 
    return d
 
 
def longMin(passe):
    d = 0
    s = 0
    i = 0
    while i < len(passe):
        if 'a' < passe[i] < 'z':
            s += 1
        else:
            if s > d:
                d = s
                s = 0
        i += 1
 
    return d
 
 
def score(password):
    bonus = (len(password)-NbcMin(password))*3+(len(password) -
NbcMaj(password))*2+(len(password)-NbcAlpha(password))*5
    penalites = longMaj(password)*3+longMin(password)*2
     val = bonus-penalites
    if val < 20:
        print('Très faible')
    elif val < 40:
        print('Faible')
    elif val < 80:
        print('Fort')
    else:
        print('Très fort')
 
 
pas = "P@SI_promo2016"
score(pas) 

Exercice 8
Un nombre heureux est un nombre entier qui, lorsqu’on ajoute les carrés de chacun
de ses chiffres, puis les carrés des chiffres de ce résultat et ainsi de suite jusqu'à
l’obtention d’un nombre à un seul chiffre égal à 1 (un).
Exemple :
N=7 est heureux, puisque :
  72=49
  42+92=97
  92+72=130
  12+32+02=10
  12+02=1
On est arrivé à un nombre d’un seul chiffre qui est égal à 1, donc N=7 est heureux

Travail demandé :

Ecrire une fonction heureux(nb) qui permet de déterminer si un nombre entier nb est

heureux ou non.
def heureux(nb):
    etat = False  # etat du nombre, est ce que c'est heureux ou non par défaut le
nombre n'est pas heureux
    # verifier est ce que le nombre est inférieur à 10
    nombre = str(nb)
    limite = False
    while limite == False:
        s = 0
        for i in nombre:
            s += int(i)**2
        nombre = str(s)
        if nombre == '1':
            etat = True
            break
        if int(nombre) < 10:  # si le nombre<10 donc limite=True
            limite = True
    return etat
 
 
print(heureux(7))
Exercice 9

La suite de robinson est définie par :

  U0=0
  Un se construit en concaténant le nombre d’apparition de chacun des
chiffres constituant le terme Un-1 suivi du chiffre lui-même, selon l’ordre
décroissant des chiffres, pour tout n>0.
Exemple :
Pour n=5, U5=13123110
En effet :
  U0=0
  U1=10 car il y a une apparition (1) du chiffre 0 dans U0
  U2=1110 car il y’a une apparition (1) du chiffre 1 et une apparition (1) du
chiffre 0 dans U1
  U3=3110 car il y’a une apparition (3) du chiffre 1 et une apparition (1) du
chiffre 0 dans U2
  U4=132110 car il y’a une apparition (1) du chiffre 3, deux apparition du chiffre
1 et une apparition (1) du chiffre 0 dans U3
  U5=13123110 car il y’a une apparition (1) du chiffre 3, une apparition du
chiffre 2, trois apparitions du chiffre 1 et une apparition (1) du chiffre 0 dans
U3
Travail demandé :

Ecrire une fonction Robinson(N) permettant de calculer le Nième terme de la suite de

robinson
def robinson(n):
    U = 0
    for _ in range(1, n+1):
        ch = str(U)
        L = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        for chiffre in ch:
            L[int(chiffre)] += 1
        res = ''
        for j in range(9, -1, -1):
            if L[j] != 0:
                res += str(L[j])+str(j)
        U = int(res)
    print('Terme : ', n, ' est ', U)
 
 
robinson(5)

Exercice 10
Dans un contexte arithmétique, on définit les nombres premiers factoriels et les
nombres premiers primoriels comme indiqué ci-après.
Un nombre PF est dit premier factoriel s’il vérifie les deux propriétés suivantes :
  PF est un nombre premier
  Et PF s’écrit sous la forme d’un factoriel incrémenté ou décrémenté de 1
(PF=F! + 1 ou PF=F! - 1), sachant que le factoriel de F noté F ! est égal à
F*(F-1) *…*1
Exemple

 7 est un nombre premier factoriel car 7 est premier et il s’écrit sous la forme
3! + 1.
  719 est un nombre premier factoriel car 719 est premier et il s’écrit sous la
forme 6! - 1.
Un nombre PP est dit premier primoriel s’il vérifie les deux propriétés suivantes :
  PP est un nombre premier
  PP s’écrit sous la forme d’une primorielle incrémentée ou décrémentée de 1
(PP=P#+1 ou PP=P#-1), sachant que la primorielle de P notée P# est égale
au produit des nombres premiers inférieurs ou égaux à P.
Exemple

  211 est un nombre premier primoriel car 211 est premier et il s’écrit sous la
forme 7# + 1. En effet, 7#+1=2*3*5*7 + 1 =210 + 1=211
  30029 est un nombre premier primoriel car 30029 est premier et il s’écrit
sous la forme 13# - 1. En effet, 13# - 1 = 2*3*5*7*11*13-1=30030 – 1
=30029
Travail demandé :
1. Ecrire une fonction premier_fact(n) qui permet de vérifier est ce que n est
un nombre premier factoriel ou non
2. Ecrire une fonction premier_primoriel(n) qui permet de vérifier est ce que n
est un nombre premier primoriel ou non
def premier(n):
    etat = True
    for i in range(2, (n//2)+1):
        if n % i == 0:
            etat = False
            break
    return etat
 
 
def premier_fact(n):
    etat = False
    if premier(n):
        f = 1
        ordre = 2
        while f < n:
            f = f*ordre
            ordre += 1
        if f+1 == n or f-1 == n:
            etat = True
    return etat
 
 
def premier_primoriel(n):
    etat = False
    if premier(n) == True:
        p = 3
        s = 0
        while s < n:
            s = 1
            for i in range(2, p+1):
                if premier(i) == True:
                    s = s*i
            p += 1
            if s+1 == n or s-1 == n:
                etat = True
                break
    return etat
 
 
n = 719
print(premier_fact(n))