<jupyter_start><jupyter_text>Premiers pas avec le langage PythonPour commencer, nous utiliserons ce tutoriel : https://rgilliotte.gitbook.io/byte-of-python/  Exercice 1 : Moyenne olympiqueLa moyenne olympique de $n$ nombres est la moyenne des $n-2$ nombres restant après avoir enlevé deux des nombres donnés, l’un ayant la valeur maximum et l’autre la valeur minimum. Décrire une fonction qui étant donnés quatre entiers positifs ou nuls, leur associe leur moyenne olympique. Par exemple, la moyenne olympique des quatre nombres 10, 8, 12, 24 est 11, celle des nombres 12, 12, 12, 12 est 12.  {spécification des fonctions}  mo : fonction (u, v, w, x : entiers $\geq$ 0) $\rightarrow$ réel $\geq$ 0 {moyenne olympique de 4 nombres}  minquatre : fonction (i, j, k, l : entiers $\geq$ 0) $\rightarrow$ entier $\geq$ 0 {minimum de 4 nombres}  maxquatre : fonction (i, j, k, l : entiers $\geq$ 0) $\rightarrow$ entier $\geq$ 0 {maximum de 4 nombres}  maxdeux, mindeux : fonction (a,b : deux entiers $\geq$ 0) $\rightarrow$ entier $\geq$ 0 {maximum et minimum de 2 nombres}<jupyter_code>def maxdeux(a, b):
    return (a + b + abs (a - b))/2
maxdeux(5, -6)
maxdeux(-4, -12)
def mindeux(a, b):
    return (a + b - abs (a - b))/2
mindeux(-5, 7)
def maxquatre(i,j,k,l):
    return maxdeux (maxdeux (maxdeux(i,j), k), l)
maxquatre(2, 4, -1, 0.5)
def minquatre(i, j, k, l):
    return mindeux (mindeux (mindeux(i,j), k), l)

def mo(u, v, w, x):
    return (u+v+w+x - minquatre(u,v,w,x) - maxquatre(u,v,w,x)) / 2
mo(10, 8, 12, 24 )<jupyter_output><empty_output><jupyter_text>Exercice 2 : Maximum de trois entiers Décrire une fonction qui détermine le maximum de trois entiers distincts deux à deux. Il n'y a pas de "selon" en Python.  Maxtrois : fonction (a, b, c : entiers) $\rightarrow$ entier {maximum de 3 nombres distincts deux à deux}<jupyter_code>def maxtrois(a, b, c):
    if (a > b):
        if (a > c):
            return a
        else:
            # {a < c}
            return c 
    # {a < b}
    else: 
        if (b > c): 
            return b 
        #{b < c}
        else:
            return c
maxtrois(1, 45, -6)
def maxthree(a, b, c):
    return maxdeux(maxdeux(a, b), c)
maxtrois(3, 5, 6)<jupyter_output><empty_output><jupyter_text>Exercice 3 : Somme des chiffres d’un nombre Décrire une fonction qui à un entier compris entre 0 et 9999 associe la somme des chiffres qui le composent dans sa représentation en base 10. Exemple : donnée 9639, résultat : 27. Les chiffres formant l’entier donné peuvent être déterminés à l’aide de divisions par 10. On introduit une fonction qui à deux nombres associe le quotient et le reste de leur division :<jupyter_code>def QR(n, d):
    return (n // d, n % d)
def SC(x):
    (q1, c0) = QR (x, 10)
    (q2, c1) = QR (q1, 10)
    (c3, c2) = QR (q2, 10)
    return c0 + c1 + c2 + c3
SC(9639)<jupyter_output><empty_output><jupyter_text>Exercice 4 : signe du produit On donne ci-dessous un algorithme qui lit au clavier deux entiers $x$ et $y$ et qui affiche à l'écran un message indiquant le signe du produit $x \times y$ sans calculer ce produit. **Signe du produit :**  x, y : entiers      lire(x) ; lire(y)  si (((x > 0) et (y > 0)) ou ((x < 0) et (y < 0)))  &nbsp;&nbsp;&nbsp;&nbsp;alors ecrire (”le produit de” & LeTexteE(x) & ”et” & LeTexteE(y) & ”est strictement positif”) sinon si ((x = 0) ou (y  = 0))  &nbsp;&nbsp;&nbsp;&nbsp;alors ecrire (”le produit de” & LeTexteE(x) & ”et” & LeTexteE(y) & ”est nul”)  &nbsp;&nbsp;&nbsp;&nbsp;sinon ecrire (”le produit de” & LeTexteE(x) & ”et” & LeTexteE(y) & ”est strictement négatif”)<jupyter_code>def sdp():
    x = int(input('Saisissez un entier x : '))
    y = int(input('Saisissez un entier y : '))
    
    if (((x > 0) and (y > 0)) or ((x < 0) and (y < 0))):
        print("le produit de " + str(x) + " et " + str(y) + " est strictement positif")
    elif ((x == 0) or (y == 0)):
        print("le produit de " + str(x) + " et " + str(y) + " est strictement nul")
    else:
        print("le produit de " + str(x) + " et " + str(y) + " est strictement négatif")  
sdp()<jupyter_output>Saisissez un entier x : 6
Saisissez un entier y : 0
le produit de 6 et 0 est strictement nul<jupyter_text>Exercice 5 - classement de trois valeurs On souhaite écrire un programme qui lit trois entiers au clavier et les affiche à l'écran en ordre croissant (du plus petit au plus grand).<jupyter_code>def classer3V():
    a = int(input('Saisissez un entier a : '))
    b = int(input('Saisissez un entier b : '))
    c = int(input('Saisissez un entier c : '))
    
    x = maxtrois(a, b, c)
    # a est le plus grand
    if (x == a):
        y = maxdeux(b, c)
        if (y == b):
            print(str(a) + " > " + str(b) + " > " + str(c))
        else:
            print(str(a) + " > " + str(c) + " > " + str(b))
    # b est le plus grand
    elif (x == b):
        y = maxdeux(a, c)
        if (y == a):
            print(str(b) + " > " + str(a) + " > " + str(c))
        else:
            print(str(b) + " > " + str(c) + " > " + str(a))
    # c est le plus grand
    else:
        y = maxdeux(a, b)
        if (y == a):
            print(str(c) + " > " + str(a) + " > " + str(b))
        else:
            print(str(c) + " > " + str(b) + " > " + str(a))
classer3V()<jupyter_output>Saisissez un entier a : 1
Saisissez un entier b : 45
Saisissez un entier c : -6
45 > 1 > -6<jupyter_text>Exercice 6 - Puissance On donne ci-dessous un algorithme qui lit au clavier deux entiers (positifs) x et y et affiche la valeur de $x^y$ : **Puissance :**  x, y : entiers  p : un entier $\geq$ 0 {valeur courante de $x^y$}  lire(x) ; lire(y)  p $\leftarrow$ 1  i parcourant [1..y]  &nbsp;&nbsp;&nbsp;&nbsp;p $\leftarrow$ p * x  ecrire(p)<jupyter_code>def puissance():
    x = int(input('Saisissez un entier x : '))
    y = int(input('Saisissez un entier y : '))
    p = 1
    for i in range(0, y):
        p = p * x
    print(str(x) + " puissance " + str(y) + " = " + str(p))
puissance()<jupyter_output>Saisissez un entier x : 2
Saisissez un entier y : 3
2 puissance 3 = 8<jupyter_text>Exercice 7 - Factorielle Ecrivez dans un fichier factorielle.py un programme pynthon qui lit un entier positif x au clavier et affiche la valeur de $!x$.<jupyter_code>def factorielle(x):
    fac = 1
    if (x >= 0):
        for i in range(2, x + 1):
            fac = fac * i
        print("!x = " + str(fac))
    else:
        print("Calcul impossible")
x = int(input('Saisissez un entier x : '))
factorielle(x)<jupyter_output>Saisissez un entier x : 6
!x = 720<jupyter_text>Une autre possibilité est d'utiliser des *appels récursifs* :<jupyter_code>def factorielle_rec(x):
    if (x == 0):
        return 1
    else:
        return x * factorielle_rec(x - 1)
x = int(input('Saisissez un entier x : '))
factorielle_rec(x)<jupyter_output>Saisissez un entier x : 6
{'fraction_non_alphanumeric': 0.14363262910798122, 'fraction_numerical': 0.022593896713615023, 'mean_word_length': 2.998240469208211, 'pattern_counts': {'":': 0, '<': 35, '<?xml version=': 0, '>': 50, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '8', 'dir': 'jupyter-structured-clean-dedup', 'id': '29820', 'license': 'CC0-1.0', 'n_tokens_mistral': 2803, 'n_tokens_neox': 2700, 'n_words': 877, 'path': 'programmation_python/TP1_corrige.ipynb', 'repo_name': 'fiorinoh/geomas-cours', 'size': '6816'}