Révision

Somme des n premiers entiers

Écrire un programme qui lit un entier n supposé positif ou nul, et qui affiche la somme des entiers de 1 à n. La valeur affichée doit être un entier.

Rappel: la somme des entiers de 1 à $n$ vaut $\frac{n (n+1)}{2}$.

Solution

n = int(input('Entrez un entier n positif ou nul:'))
sum = (n * (n+1)) // 2
print(f'La somme des entiers de 1 à {n} vaut {sum}')

Conversion de distances

Écrire une fonction convert_to_m(f, i) qui prend en entrée un nombre de pieds (feet) f et un nombre de pouces (inches) i, et qui retourne la distance correspondante en mètres.

Indication: 1 pied vaut 12 pouces, et 1 pouce vaut 2,54 centimètres

Solution

def convert_to_m(f, i):
    return (12 * f + i) * 2.54 / 100

Aire d’un polygone régulier

Un polygone est régulier si tous ses côtés ont même longueur, et si les angles entre ses côtés adjacents sont égaux. Écrire une fonction aire(c, n) qui retourne l’aire d’un polygône régulier à n côtés de longueur c.

Indication: l’aide d’un tel polygône peut être calculée par la formule $\frac{n \times c^2}{4 \times \tan(\frac{\pi}{n})}$

Solution

from math import tan, pi

def aire(c, n):
    return (n * (c ** 2)) / (4 * tan(pi / n))

Conversion de note

Écrire une fonction note(e) qui convertit une évaluation e donnée par une lettre en la note correspondante dans le tableau ci-dessous. Votre fonction doit renvoyer -1.0 si l n’est pas une lettre du tableau.

Lettre	Note
A	4.0
B	3.0
C	2.0
D	1.0
F	0.0

Solution

def note(e):
    if e == 'A':
        return 4.0
    elif e == 'B':
        return 3.0
    elif e == 'C':
        return 2.0
    elif e == 'D':
        return 1.0
    elif e == 'F':
        return 0.0
    else:
        return -1.0

Code de César

Le code de César est l’un des premiers exemples de cryptage connu. Son principe est très simple: il consiste à transformer chaque caractère de l’alphabet par un décalage de 3 lettres. Ainsi, A devient D, B devient E, L devient O, X devient A et Z devient C. La méme technique s’applique aux lettre minucules. Les autres caractères ne sont pas modifiés. Écrire une fonction cesar(m, d): qui crypte la chaîne de caractères m en utilisant un décalage de d caractères, puis retourne la chaîne cryptée. Attention, d peut être positif ou négatif.

Indications:

• la fonction ord(c) retourne le code ASCII du caractère c. Les lettres majuscules ont des codes consécutifs. Idem pour les lettres minuscules.
• inversement chr(p) retourne le caractère de code ASCII c.
• la méthode isalpha() permet de savoir si un caractère est une lettre

Solution

def cesar(m, d):
    str = ''
    for c in m:
        if c.isalpha():
            if c >= 'a' and c <= 'z':
                ref = ord('a')
            else:
                ref = ord('A')
            pos = ord(c) - ref
            decalage = (pos + d) % 26
            str += chr(ref + decalage)
        else:
            str += c
    return str

Liste d’entiers

Écrire une fonction nzp(l) qui prend une liste d’entiers l et qui retourne un triplet (n,z,p) de trois listes: n contient les entiers négatifs de l, z les zéros de l et p les entiers positifs de l. Les entiers dans n, z et p doivent être dans le même ordre que dans l.

Par exemple, nzp([0,-4,3,1,9,0,-1,6,-2,0,7]) doit retourner ([-4,-1,-2], [0,0,0], [3,1,9,6,7]).

Solution

def nzp(l):
    return ([n for n in l if n < 0], [z for z in l if z == 0], [p for p in l if p > 0])

Sous-ensembles d’un ensemble

Écrire une fonction sous_ensembles(e) qui produit la liste des sous-ensembles de l’ensemble e. L’ordre des sous-ensembles retournés est sans importance.

Par exemple, sous_ensembles({1,2,3}) retourne [set(), {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}].

Indication: pour choisir un élément dans un ensemble e

for x in e:
  break
 # x est l'un des élément de e

Solution

def sous_ensembles(e):
    if len(e) == 0:
        return [set()]
    else:
        for x in e:
            break
        se_no_x = sous_ensembles(e - {x})
        return se_no_x + [ee | {x} for ee in se_no_x]

Nombre d’occurrences

Écrire une fonction max_occurrences(s) qui prend en entrée une séquence s (liste, tuple, ensemble, etc) et qui génère la séquence des éléments de s qui y apparaissent le plus grand nombre de fois.

Par exemple:

for x in max_occurrences([1,2,1,3,4,5,2,7,5]):
    print(x)

doit afficher: 1 puis 2 puis 5.

Solution

def max_occurrences(s):
    # calcule la fréquence des éléments de s et la fréquence max
    freq = {}
    fmax = 0
    for x in s:
        if x not in freq:
            freq[x] = 1
        else:
            freq[x] += 1
        if freq[x] > fmax:
            fmax = freq[x]
    # génere la séquence de occurrences max
    for x in freq:
        if freq[x] == fmax:
            yield x