(a) age est une chaîne (str). L’expression age + 1 tente d’additionner une chaîne et un entier → TypeError (types incompatibles).

(b) x3.5, alors x == "3.5". Donc x * 2 répète la chaîne : "3.5" + "3.5" → affiche 3.53.5.

(c) Correction :

age = int(input("Âge ? "))
x = float(input("Nombre réel ? "))
print(age + 1)
print(2 * x)

(d) Exemple : saisir 17.5 pour l’âge. int("17.5") échoue car la chaîne n’est pas un entier (il y a un point). On doit utiliser float puis éventuellement arrondir.

(a) \(a+b*2 = 17+5*2 = 17+10 = 27\). Et \((a+b)*2 = (22)*2 = 44\).

(b) a/b = 17/5 = 3.4 (réel). a//b = 3 (quotient entier). a%b = 2 (reste). Interprétation : \(17 = 5\times 3 + 2\).

(c) Trace :
Départ : a=17, b=5
L1: a=a+b → a=22, b=5
L2: b=a-b → b=22-5=17, a=22
L3: a=a-b → a=22-17=5
Fin : a=5, b=17. L’algorithme échange les valeurs (swap) sans variable temporaire.

(d) a,b = b,a échange directement (tuple unpacking). Plus sûr car évite erreurs d’ordre et problèmes potentiels si les expressions sont plus complexes.

(a) (x >= -2) and (x < 5).

(b) (x < 0) or (x > 1) (ou bien not((x >= 0) and (x <= 1))).

(c) (x <= -3) or (x >= 2).

(d) (x >= 1) and (x <= 4) and (x != 3).

(a) Posons \(A=(0\le x\le 1)\) et \(B=(x=3)\).
Condition = not(A or B) = (not A) and (not B).
Donc : ( (x < 0) or (x > 1) ) and (x != 3).

(b) Ensemble solution : tous les réels hors \([0 ; 1]\) et différents de 3 : \(]-\infty ; 0[\cup]1 ; +\infty[\) puis retirer \(\{3\}\).

(c)
\(x=0{,}5\) : dans \([0;1]\) → condition fausse.
\(x=2\) : hors \([0;1]\) et ≠3 → vraie.
\(x=3\) : interdit → fausse.
\(x=-1\) : hors \([0;1]\) et ≠3 → vraie.

(d) Version lisible :

dans_01 = (x >= 0) and (x <= 1)
est_3 = (x == 3)
ok = (not dans_01) and (not est_3)

(a)

u = 1.0
n = 0
while u < 100:
    u = 1.15*u + 2
    n = n + 1
print(n)

(b) \(u_0=1\).
\(u_1=1{,}15\cdot1+2=3{,}15\).
\(u_2=1{,}15\cdot3{,}15+2=3{,}6225+2=5{,}6225\).
\(u_3=1{,}15\cdot5{,}6225+2=6{,}465875+2=8{,}465875\).

(c) Pour tout \(n\), \(u_{n+1}=1{,}15u_n+2 > u_n\) dès que \(u_n\ge 0\). Or \(u_0=1>0\), donc la suite est strictement croissante et tend vers +∞ : elle dépassera forcément 100 → la boucle finit.

(d) Afficher n et u :

print("n =", n, "u_n =", u)

(a)

n = 5
S = 0
for k in range(1, n+1):
    S = S + k*k
print(S)

(b) \(1^2+2^2+3^2+4^2+5^2=1+4+9+16+25=55\).

(c) \(\dfrac{5\cdot6\cdot11}{6}=5\cdot11=55\) ✅.

(d)

ok = True
for n in range(1, 51):
    S = 0
    for k in range(1, n+1):
        S += k*k
    F = n*(n+1)*(2*n+1)//6
    if S != F:
        ok = False
        print("Erreur pour n=", n, S, F)
        break
print("Formule OK" if ok else "Formule KO")

(a)

L = [12, 8, 15, 15, 9, 18, 7]
mn = L[0]
mx = L[0]
for x in L:
    if x < mn:
        mn = x
    if x > mx:
        mx = x
print(mn, mx)

(b)

mx = L[0]
idx = 0
for i in range(len(L)):
    if L[i] > mx:
        mx = L[i]
        idx = i
print(idx)

(c) min = 7, max = 18. L’indice de 18 est 5 (car L[5]=18).

(d) Si toutes les valeurs sont positives, min=0 restera 0 alors que 0 n’est pas dans la liste → résultat faux. Il faut initialiser avec un élément réel de la liste.

(a) Dans la liste, il y a 6 valeurs égales à 1 → 6 succès.

(b) Fréquence : \(6/10=0{,}6\).

(c) Pourcentage : \(0{,}6\times100=60\%\).

(d)

def freq(L):
    if len(L) == 0:
        return 0.0
    c = 0
    for x in L:
        if x == 1:
            c += 1
    return c / len(L)

(a)

def fact(n):
    p = 1
    for k in range(1, n+1):
        p = p * k
    return p

(b) Par convention et cohérence des formules (ex: \(\binom{n}{0}=1\)), on a \(0!=1\). Le programme renverra 1 car la boucle ne s’exécute pas.

(c)

def fact(n):
    if (not isinstance(n, int)) or (n < 0):
        return None
    p = 1
    for k in range(1, n+1):
        p *= k
    return p

(d) \(6!=1\cdot2\cdot3\cdot4\cdot5\cdot6=720\). Donc fact(6) doit renvoyer 720.

(a) Le code est correct : il applique exactement Euclide.

(b) Trace (résumé) : \(9999=3663\times2+2673\), \(3663=2673\times1+990\), \(2673=990\times2+693\), \(990=693\times1+297\), \(693=297\times2+99\), \(297=99\times3+0\). Donc PGCD = 99.

(c) Si \(d\) divise \(a\) et \(b\), alors \(d\) divise aussi \(a-bq\). Or \(r=a\%b=a-bq\). Donc l’ensemble des diviseurs communs de \((a,b)\) = celui de \((b,r)\) ⇒ le PGCD est inchangé.

(d) Utiliser a=abs(a), b=abs(b) au début, car \(\mathrm{PGCD}\) est défini sur des entiers positifs.

(a)

import random

def freq_pile(N):
    c = 0
    for i in range(N):
        # pile si 0, face si 1 (équilibrée)
        if random.randint(0, 1) == 0:
            c += 1
    return c / N

(b) Le hasard crée des fluctuations : sur un nombre fini d’essais, on n’obtient pas exactement la proportion théorique.

(c)

import random

def freq_pile_biaisee(N, p=0.62):
    c = 0
    for i in range(N):
        u = random.random()
        if u < p:
            c += 1
    return c / N

(d) Plus N est grand, plus la fréquence se stabilise autour de p (fluctuation relative diminue). Pour N=100, on peut voir 0,44 ou 0,57 ; pour N=10 000, on est généralement proche de 0,62 (ex : 0,617).

(a)

import random

def proba_au_moins_un_6(N):
    c = 0
    for i in range(N):
        ok = False
        for k in range(4):
            d = random.randint(1, 6)
            if d == 6:
                ok = True
        if ok:
            c += 1
    return c / N

(b) \(P(\ge 1\;6)=1-P(0\;6)=1-(5/6)^4\).

(c) Compter “au moins un” directement est pénible (cas multiples). Le contraire “aucun 6” est simple : 4 lancers indépendants, chacun probabilité 5/6.

(d) La simulation doit donner une valeur proche de \(1-(5/6)^4\approx 1-0{,}4823\approx 0{,}5177\). Avec N=50 000, on s’attend à ~0,515–0,520.

(a) n=4 : i=0 → j=0,1,2,3 (4 couples) ; i=1 → j=1,2,3 (3) ; i=2 → j=2,3 (2) ; i=3 → j=3 (1). Total 10.

(b) \(c=\sum_{i=0}^{n-1} (n-i)=n+(n-1)+\cdots+1=\dfrac{n(n+1)}{2}\).

(c) n=10 → \(c=10\times11/2=55\).

(d) Le coût est de l’ordre de \(n^2\) (croît comme un carré).

(a)

def u_n(n):
    u = 2
    for k in range(n):
        u = 2*u + 1
    return u

(b) \(u_1=2\cdot2+1=5\), \(u_2=2\cdot5+1=11\), \(u_3=2\cdot11+1=23\).

(c)

def somme_u(n):
    u = 2
    S = u
    for k in range(n):
        u = 2*u + 1
        S = S + u
    return S

(d) Conjecture : \(u_n=3\cdot2^n-1\). Vérif : n=0 → 3·1-1=2 ✅ ; n=1 → 6-1=5 ✅ ; n=2 → 12-1=11 ✅. Justification rapide : si \(u_n=3\cdot2^n-1\), alors \(u_{n+1}=2u_n+1=2(3\cdot2^n-1)+1=3\cdot2^{n+1}-1\).

(a)

S = 0
n = 0
while S < 1000:
    n += 1
    S += n
print(n, S)

(b) S augmente strictement (on ajoute n>0), donc dépasse forcément 1000.

(c) On veut \(\frac{n(n+1)}{2}\ge1000\) → \(n^2\approx2000\) → \(n\approx45\) (car \(45^2=2025\)). On s’attend à n autour de 45.

(d) Minimalité : après calcul, vérifier : S >= 1000 et S - n < 1000 (car S-n = S_{n-1}).

(a) n=1 : range(1) → {0} → S=0. n=2 : {0,1} → S=1. n=3 : {0,1,2} → S=3. Or la vraie somme vaut 1,3,6.

(b) On inclut 0 et on oublie n. C’est un off-by-one.

(c) Correction 1 :

for k in range(1, n+1):
    S += k

Correction 2 :

for k in range(n):
    S += (k+1)

(d)

def somme(n):
    if n < 1:
        return 0
    S = 0
    for k in range(1, n+1):
        S += k
    return S

(a)

def premier_positif(L):
    for i in range(len(L)):
        if L[i] > 0:
            return i
    return -1

(b) L[0]=-3 (non), L[1]=7 (oui) → indice 1.

(c)

def premier_positif_info(L):
    for i in range(len(L)):
        if L[i] > 0:
            return i, L[i]
    return -1, None

(d) “premier” dépend de l’ordre. Le maximum dépend des valeurs et peut être ailleurs. Ici, premier positif = 7 (indice 1), max = 12 (indice 3).

(a)

def est_premier(n):
    if n < 2:
        return False
    for d in range(2, int(n**0.5) + 1):
        if n % d == 0:
            return False
    return True

(b) Si \(n=ab\) avec \(a\le b\), alors \(a\le\sqrt{n}\). Donc si aucun diviseur ≤ √n, il n’y en a aucun.

(c) 1 non ; 2 oui ; 9 non (3×3) ; 17 oui ; 221 non (13×17).

(d) Optimisation :

def est_premier(n):
    if n < 2: return False
    if n == 2: return True
    if n % 2 == 0: return False
    d = 3
    while d*d <= n:
        if n % d == 0:
            return False
        d += 2
    return True

(a) Somme = 40, n=8 → \(\bar x=40/8=5\).

(b) Écarts au carré : (2-5)^2=9, (4-5)^2=1 (trois fois → 3), (5-5)^2=0 (deux fois → 0), (7-5)^2=4, (9-5)^2=16. Somme = 9+3+0+4+16=32 → \(V=32/8=4\).

(c)

def moyenne(L):
    if len(L) == 0: return 0.0
    S = 0
    for x in L:
        S += x
    return S / len(L)

def variance(L):
    if len(L) == 0: return 0.0
    m = moyenne(L)
    S = 0.0
    for x in L:
        S += (x - m)**2
    return S / len(L)

(d) \(\sigma=\sqrt{4}=2\). Interprétation : les valeurs s’écartent typiquement d’environ 2 autour de 5.

(a) On attend 1.0.

(b) En binaire, 0.1 n’a pas d’écriture finie → approximation → petites erreurs qui s’additionnent.

(c) Comparaison robuste :

eps = 1e-9
if abs(S - 1.0) < eps:
    print("≈ 1")

(d) Travailler en dixièmes entiers :

T = 0
for i in range(10):
    T += 1     # 1 dixième
print(T/10)    # 1.0

(a)

L = list("abacaba")
d = {}
for ch in L:
    if ch in d:
        d[ch] += 1
    else:
        d[ch] = 1
print(d)

(b) a : 4, b : 2, c : 1.

(c)

def freq_lettres(texte):
    d = {}
    for ch in texte:
        d[ch] = d.get(ch, 0) + 1
    return d

(d) Le dictionnaire associe directement chaque valeur à son compteur, sans chercher un index fixe : plus simple et efficace quand il y a beaucoup de valeurs différentes.

(a)

def sqrt_babylone(a, eps=1e-6):
    if a <= 0:
        return None
    x = float(a)
    while True:
        xn = 0.5*(x + a/x)
        if abs(xn - x) < eps:
            return xn
        x = xn

(b) a=2 : x0=2. x1=0,5(2+2/2)=0,5(2+1)=1,5. x2=0,5(1,5+2/1,5)=0,5(1,5+1,3333)=1,4167. (on se rapproche de 1,4142...)

(c) Le seuil garantit une précision demandée, alors qu’un nombre fixe peut être trop grand (inutile) ou trop petit (pas assez précis).

(d) Déjà intégré : si a≤0 → None.

(a)

def est_croissante(L):
    for i in range(len(L)-1):
        if L[i] > L[i+1]:
            return False
    return True

(b) [1,2,2,5] → True ; [1,3,2] → False (car 3>2).

(c)

def est_croissante_info(L):
    for i in range(len(L)-1):
        if L[i] > L[i+1]:
            return False, i
    return True, None

(d) Au plus \(n-1\) comparaisons → coût proportionnel à n (linéaire).

(a)

def histo(L):
    C = [0, 0, 0, 0]
    for x in L:
        if 0 <= x and x < 5:
            C[0] += 1
        elif x < 10:
            C[1] += 1
        elif x < 15:
            C[2] += 1
        elif x < 21:
            C[3] += 1
    return C

(b) L = [2,5,7,10,14,15,20,9,0,18]
[0;5[: {2,0} → 2
[5;10[: {5,7,9} → 3
[10;15[: {10,14} → 2
[15;21[: {15,20,18} → 3
Donc compteurs = [2,3,2,3].

(c) n=10 → pourcentages : [20%, 30%, 20%, 30%].

(d) Si on écrivait [15;20[, alors 20 serait exclu. Ici on veut inclure 20 → utiliser une borne supérieure 21 (ou un test spécial x==20).

(a)

import random

def proba_X_ge_15(N):
    c = 0
    for i in range(N):
        piles = 0
        for k in range(20):
            if random.randint(0, 1) == 0:
                piles += 1
        if piles >= 15:
            c += 1
    return c / N

(b) \(X\sim\mathcal{B}(20,\tfrac12)\). Donc \[ P(X\ge 15)=\sum_{k=15}^{20} \binom{20}{k}\left(\tfrac12\right)^k\left(\tfrac12\right)^{20-k} =\sum_{k=15}^{20} \binom{20}{k}\left(\tfrac12\right)^{20}. \]

(c) Obtenir ≥15 piles sur 20 est très improbable. Si l’événement est rare, sur un N petit on peut observer 0 fois → fréquence 0 (mauvaise estimation). Il faut un N grand (ex : 100 000 ou plus) pour voir assez de succès.

(d) Par symétrie (pièce équilibrée) : \(P(X\ge 15)=P(X\le 5)\) (car remplacer pile par face renverse le comptage : k piles ↔ 20-k piles). Vérifier en simulant aussi \(X\le 5\) : les deux fréquences doivent être proches.