Math@mine / Première / Ch1 / Exercices

Exercices — Algorithmique et logique

Première — Chapitre 1

Exercices — Algorithmique et raisonnement logique

Listes Python, logique, implication et raisonnement

Progression :
0 / 7
1

Manipulation de listes

★☆☆ Facile

On considère la liste L = [3, 7, 1, 9, 4, 6, 2, 8, 5].

  1. Quelle est la longueur de L ? Quelle est la valeur de L[0], L[4], L[-1] ?
  2. Quelle est la valeur de L[2:5] ?
  3. Écrire l’instruction Python pour ajouter 10 à la fin de la liste.
  4. Écrire l’instruction pour supprimer la valeur 9 de la liste.
  5. Sans utiliser max(), écrire un algorithme en Python qui calcule le maximum de la liste.
Correction
  1. len(L) = 9. L[0] = 3, L[4] = 4, L[-1] = 5.
  2. L[2:5] = [1, 9, 4] (indices 2, 3, 4).
  3. L.append(10)
  4. L.remove(9)

  5. maxi = L[0] for x in L: if x > maxi: maxi = x print(maxi)
2

Listes en compréhension

★☆☆ Facile

Écrire chaque liste en compréhension Python.

  1. La liste des entiers de 1 à 20.
  2. La liste des carrés des entiers de 1 à 10.
  3. La liste des entiers de 1 à 50 divisibles par 3.
  4. La liste des cubes des entiers impairs de 1 à 15.
  5. La liste [0, 2, 4, 6, 8, 10] (sans écrire chaque valeur).
Correction
  1. [x for x in range(1, 21)] ou list(range(1, 21))
  2. [x**2 for x in range(1, 11)]
  3. [x for x in range(1, 51) if x % 3 == 0]
  4. [x**3 for x in range(1, 16) if x % 2 != 0]
  5. [2*x for x in range(6)] ou list(range(0, 11, 2))
3

Algorithmes sur les listes

★★☆ Intermédiaire

Écrire en Python chaque algorithme.

  1. Une fonction moyenne(L) qui calcule la moyenne des éléments d’une liste de nombres.
  2. Une fonction compter(L, x) qui compte le nombre d’occurrences de x dans L (sans utiliser count()).
  3. Une fonction inverser(L) qui retourne la liste dans l’ordre inverse (sans utiliser reverse() ni le slicing [::-1]).
  4. Une fonction fusionner(L1, L2) qui retourne une liste contenant tous les éléments de L1 et L2 triés dans l’ordre croissant.
Correction
  1. def moyenne(L): return sum(L) / len(L)
  2. def compter(L, x): n = 0 for elem in L: if elem == x: n += 1 return n
  3. def inverser(L): result = [] for i in range(len(L)-1, -1, -1): result.append(L[i]) return result
  4. def fusionner(L1, L2): return sorted(L1 + L2)
4

Vocabulaire ensembliste

★☆☆ Facile

Soit \(E = \{1, 2, 3, 4, 5, 6, 7, 8, 9, 10\}\), \(A = \{2, 4, 6, 8, 10\}\) (pairs), \(B = \{3, 6, 9\}\) (multiples de 3).

  1. Calculer \(A \cap B\), \(A \cup B\) et \(\overline{A}\) (complémentaire dans \(E\)).
  2. Est-ce que \(B \subset A\) ? Justifier.
  3. Calculer \(A \times \{0, 1\}\) (donner les 4 premiers éléments).
  4. Écrire en Python les ensembles \(A\) et \(B\) comme listes, puis calculer leur intersection et réunion.
Correction
  1. \(A \cap B = \{6\}\). \(A \cup B = \{2, 3, 4, 6, 8, 9, 10\}\). \(\overline{A} = \{1, 3, 5, 7, 9\}\).
  2. Non : \(3 \in B\) mais \(3 \notin A\). Donc \(B \not\subset A\).
  3. \(A \times \{0,1\} = \{(2,0), (2,1), (4,0), (4,1), \ldots\}\) (10 éléments au total).
  4. A = [2, 4, 6, 8, 10] B = [3, 6, 9] inter = [x for x in A if x in B] # [6] union = list(set(A + B)) # [2, 3, 4, 6, 8, 9, 10]
5

Connecteurs logiques et tables de vérité

★★☆ Intermédiaire

Pour chaque proposition, indiquer si elle est vraie ou fausse (avec justification).

  1. « \(2 + 2 = 4\) et \(\sqrt{4} = 2\) »
  2. « \(3 > 5\) ou \(7 < 10\) »
  3. « Il existe un entier \(n\) tel que \(n^2 = 2\) »
  4. « Pour tout réel \(x\), \(x^2 \geq 0\) »
  5. Écrire la négation de : « Pour tout entier \(n\), \(n^2 + 1 \geq 2\) »
  6. Écrire la négation de : « Il existe un réel \(x\) tel que \(x^2 < 0\) »
Correction
  1. Vraie : les deux parties sont vraies, et (V et V) = V.
  2. Vraie : même si \(3 > 5\) est faux, \(7 < 10\) est vrai, et (F ou V) = V.
  3. Fausse : \(\sqrt{2}\) n’est pas entier. Il n’existe pas d’entier \(n\) tel que \(n^2 = 2\).
  4. Vraie : le carré de tout réel est positif ou nul.
  5. Négation : « Il existe un entier \(n\) tel que \(n^2 + 1 < 2\) », c’est-à-dire \(n^2 < 1\).
  6. Négation : « Pour tout réel \(x\), \(x^2 \geq 0\) » (qui est vraie, donc la proposition originale était fausse).
6

Implication, réciproque, contraposée

★★☆ Intermédiaire

Pour chaque implication, écrire la réciproque et la contraposée, puis dire si chacune est vraie ou fausse.

  1. « Si \(n\) est divisible par 6, alors \(n\) est divisible par 2. »
  2. « Si \(x = 3\), alors \(x^2 = 9\). »
  3. « Si \(n^2\) est impair, alors \(n\) est impair. » (démontrer par contraposée)
  4. Identifier : quelle est la condition nécessaire et quelle est la condition suffisante dans l’implication « être un carré parfait ⟹ être positif ou nul » ?
Correction
  1. Implication : vraie. Réciproque : « Si \(n\) est divisible par 2, alors il est divisible par 6 » → fausse (contre-ex : \(n=4\)). Contraposée : « Si \(n\) n’est pas divisible par 2, il n’est pas divisible par 6 » → vraie (équivalente à l’implication).
  2. Implication : vraie. Réciproque : « Si \(x^2 = 9\), alors \(x = 3\) » → fausse (contre-ex : \(x = -3\)). Contraposée : « Si \(x^2 \neq 9\), alors \(x \neq 3\) » → vraie.
  3. Contraposée : « Si \(n\) est pair, alors \(n^2\) est pair ». Si \(n = 2k\), alors \(n^2 = 4k^2 = 2(2k^2)\), bien pair. ✓
  4. Être un carré parfait est une condition suffisante d’être positif ou nul. Être positif ou nul est une condition nécessaire d’être un carré parfait. La réciproque est fausse : \(x = 3\) est positif mais pas un carré parfait.
7

Algorithme des années bissextiles

★★★ Difficile

Une année est bissextile si elle est divisible par 4, sauf si elle est divisible par 100, à moins qu’elle ne soit aussi divisible par 400.

  1. Écrire la proposition logique complète définissant une année bissextile à l’aide des connecteurs « et », « ou », « non ».
  2. Écrire en Python une fonction est_bissextile(n) qui retourne True si l’année \(n\) est bissextile.
  3. Tester avec 2000, 1900, 2024, 2100.
  4. Utiliser une liste en compréhension pour lister toutes les années bissextiles entre 1900 et 2100.
  5. Combien y a-t-il d’années bissextiles entre 1900 et 2100 inclus ?
Correction
  1. Bissextile ⟺ (divisible par 4) ET ((non divisible par 100) OU (divisible par 400)).
  2. def est_bissextile(n): return (n % 4 == 0) and (n % 100 != 0 or n % 400 == 0)
  3. 2000 : True ✓ (400). 1900 : False ✓ (100 mais pas 400). 2024 : True ✓ (4, pas 100). 2100 : False ✓ (100, pas 400).
  4. bissextiles = [n for n in range(1900, 2101) if est_bissextile(n)]
  5. len(bissextiles) = 49 années bissextiles.
8

Comparaison de complexités — Linéaire vs quadratique

★★☆ Intermédiaire

On compare deux algorithmes qui parcourent une liste de \(n\) éléments :

def algo_lineaire(L): s = 0 for x in L: # n itérations s = s + x return s def algo_quadratique(L): n = len(L) nb = 0 for i in range(n): # n itérations for j in range(n): # n itérations if L[i] == L[j]: nb = nb + 1 return nb
  1. Donner le nombre d'opérations effectuées par algo_lineaire et algo_quadratique en fonction de \(n\). Exprimer leur coût (= ordre de grandeur) sous la forme \(O(n^k)\).
  2. Compléter le tableau ci-dessous (durée approximative pour 1 million d'opérations par seconde) :
\(n\)Linéaire (\(n\) op.)Quadratique (\(n^2\) op.)
100??
10 000??
1 000 000??
  1. Tracer les deux courbes \(t \mapsto n\) et \(t \mapsto n^2\) sur le même repère (échelle linéaire), pour \(n \in [0, 100]\). Que remarque-t-on ?
  2. Pourquoi le coût quadratique devient-il rapidement « impraticable » pour de grands \(n\) ?
Correction
  1. algo_lineaire : \(n\) opérations, coût \(O(n)\). algo_quadratique : \(n \times n = n^2\) opérations, coût \(O(n^2)\).
  2. Tableau (à \(10^6\) op./s) :
    \(n\)LinéaireQuadratique
    1000,0001 s0,01 s
    10 0000,01 s100 s (≈ 1 min 40)
    1 000 0001 s10⁶ s (≈ 11 jours)
  3. La courbe \(y = n^2\) (parabole) part lentement à 0 puis grimpe beaucoup plus vite que la droite \(y = n\). À partir de \(n = 1\), elle dépasse définitivement la droite. Pour \(n = 100\) : \(n^2 = 10000\) (100 fois plus que \(n\)).
  4. Pour \(n = 10^6\), passer de \(O(n)\) (1 seconde) à \(O(n^2)\) (11 jours) montre la croissance quadratique. Sur des ensembles de données réels (millions d'éléments), un algorithme quadratique est inutilisable. C'est pourquoi en informatique on cherche toujours à améliorer la complexité (par exemple le tri rapide \(O(n \log n)\) au lieu du tri par sélection \(O(n^2)\)).