DS Final Info — ECG1-2

I. Exercices sur les suites

I.1 Suites récurrentes

Pour chaque suite définie ci-dessous, écrire une fonction Python prenant en paramètre un entier naturel \( n \) et renvoyant la valeur de \( u_n \). On privilégiera une écriture récursive.

\[ \begin{cases} u_0 = 2 \\ u_{n+1} = 3u_n^2 - 1 \end{cases} \]
\[ \begin{cases} u_1 = 0 \\ u_{n+1} = e^{-u_n} \end{cases} \]
\[ \begin{cases} u_0 = 1,\quad u_1 = 1 \\ u_{n+2} = u_{n+1} + u_n \end{cases} \]
\[ \begin{cases} u_0 = 1 \\ u_{n+1} = \sum_{k=0}^{n} \frac{u_k}{k^2 + 1} \end{cases} \]

Démontrer que :

\[ u_{n+1} = u_n \cdot \frac{n^2 + 2}{n^2 + 1} \]

I.2 Suites imbriquées

Soient \( (a_n) \) et \( (b_n) \) définies par :

\[ a_0 = 0,\quad b_0 = 1 \]

\[ a_{n+1} = 2a_n + b_n,\quad b_{n+1} = 2a_n + 3b_n \]

Calculer \( a_1, b_1, a_2, b_2 \)
Écrire une fonction Python suites(n) qui renvoie \( a_n \) et \( b_n \)
Soit \( s_n = a_n + b_n \). Déterminer une relation de récurrence entre \( s_n \) et \( s_{n+1} \)
Soit \( t_n = 2a_n - b_n \). Déterminer une relation de récurrence entre \( t_n \) et \( t_{n+1} \)

II. Simulation et fréquences

II.1 Simulation 1

On lance 3 fois une pièce donnant PILE avec une probabilité \( \frac{1}{3} \). On note \( X \) le nombre de PILE obtenus.

Compléter le programme suivant :

from random import *
x = random()
if x < ...:
    piece = "PILE"
else:
    piece = "FACE"
print(piece)

Écrire une fonction simulX() qui renvoie la valeur de \( X \)
Donner la loi de probabilité de \( X \) et calculer son espérance

II.2 Simulation 2

On lance une pièce (PILE avec probabilité \( \frac{1}{3} \)) jusqu’à obtenir le premier PILE, ou jusqu’au 4ᵉ lancer.

On note \( X \) le nombre de lancers effectués (maximum 4).

Écrire une fonction simul2X() qui simule cette variable aléatoire
Écrire une fonction simultiplex(n) qui renvoie la moyenne de \( n \) simulations de \( X \)

III. Matrices

Quelle instruction permet d'importer un module pour manipuler des matrices ?
Écrire une instruction qui crée la matrice :

\[ A = \begin{pmatrix} 1 & 2 & 3 \\ 2 & -7 & 6 \end{pmatrix} \]

Quelle instruction permet d’effectuer le produit matriciel \( A \cdot B \) ?
Quelle instruction permet d’afficher la matrice identité \( I_n \) ?
Que renvoie l’instruction print(np.size(A)) ?
Que renvoie print(A[1,2]) ?

IV. Opérations sur les listes

Chaque QCM comporte 20 questions avec 4 réponses possibles (1 à 4). Une seule réponse est correcte.

La correction est donnée par une liste corr, et chaque copie par une liste cop.

Quelle est la bonne réponse à la question 18 ?
Quelle instruction Python permet de l’afficher ?
Quel booléen est associé à une réponse fausse ?
Écrire la liste corrTM correspondant à la correction de la copie de Tom Matt
Écrire une fonction note(cop, corr) qui renvoie le nombre de bonnes réponses
Écrire une fonction reussite(cop, corr) qui affiche "Réussite" si la note est ≥ 10, sinon "Échec"
Écrire une fonction note2bonus(cop, corr) qui ajoute un bonus de 2 points si le candidat a plus de 4 bonnes réponses consécutives (note max : 20)

V. Courbes représentatives

Tracer la courbe de la fonction :

\[ f(x) = e^{x^2} \]

sur l’intervalle \([-1;2]\), avec 200 points régulièrement espacés.

Bonus : ajouter une légende.

Correction DS 2024

# Des erreurs peuvent êtes présentes dans ce fichier, si vous en trouvez, merci de me le signaler.
# J'ai surtout répondu aux questions python, pas à celles de maths.

# Sujet : DS Final 2024

# I Exercices sur les suites

# 1.1 Suites récurrentes

# 1.

n=int(input("Donnez n: "))
def u1(n):
    if n==0:
        return 2
    return 3*(u1(n-1))**2 - 1
print(u1(n))


# 2.

import math

n=int(input("Donnez n: "))
def u2(n):
    if n==1:
        return 0
    return math.exp(-u2(n-1))
print(u2(n))


# 3.

n=int(input("Donnez n: "))
def u3(n):
    if n==0 or n==1:
        return 1
    return u3(n-1) + u3(n-2)
print(u3(n))


# 4. Version avec la somme

n=int(input("Donnez n: "))
def u4(n):
    if n==0:
        return 1
    s=0
    for i in range(n):
        s=s+(u4(i)/(i**2+1))
    return s
print(u4(n))


# 4. Version sans la somme

n=int(input("Donnez n: "))
def u4bis(n):
    if n==0:
        return 1
    return u4bis(n-1)*((n-1)**2+2)/((n-1)**2+1)
print(u4bis(n))


# 1.2 Suites imbriquées

# 2.

n=int(input("Donnez n: "))
def suites(n):
    def a(n):
        if n==0:
            return 0
        return 2*a(n-1) + b(n-1)

    def b(n):
        if n==0:
            return 1
        return 2*a(n-1) + 3*b(n-1)


    return a(n), b(n)

print(suites(n))


# 1.3 Suites définies par une somme ou un produit

# 1.

n=int(input("Donnez n: "))
s=0
for i in range(1,n+1):
    s=s+1/i**2
print(s)


# 2.b

n=int(input("Donnez n: "))
p=1
for i in range(2,n+1):
    p=p*(1-1/i**2)
print(p)


# 2.f

a=eval(input("Donnez a: "))
def seuil(a):
    n=2
    v=3/4
    while v-1/2>a:
        v=(n+1)/2**n
        n=n+1
    return n
print(seuil(a))


# 3.c

n=int(input("Donnez n: "))

def a(n):
    s=0
    for i in range(1,n+1):
        s=s+i
    return s**4

def b(n):
    s=0
    for i in range(1,n+1):
        s=s+i**4
    return s

def difference(n):
    return a(n) - b(n)

print(difference(n))



# II Simulation et fréquences

# II.1 Simulation 1

# 1.

from random import *
x=random()
if x<1/3:
    piece="PILE"
else:
    piece="FACE"
print(piece)


# 2.

def simulX():
    i=0
    for k in range(3):
        x=random()
        if x<1/3:
            i+=1
    return i
print(simulX())


# II.2 Simulation 2

# 1.

def simul2X():
    for i in range(1, 5):
        if random() < 1/3:
            return i
    return 4
print(simul2X())


# 2. Version simple

n=int(input("Donnez n: "))
def simultipleX(n):
    s=0
    for i in range(n):
        s=s+simul2X()
    return s/n
print(simultipleX(n))


# 2. Version avancée

n=int(input("Donnez n: "))
def simultipleXbis(n):
    return sum([simul2X() for _ in range(n)])/n
print(simultipleXbis(n))



# III Matrices

# 1.

import numpy as np


# 2.

import numpy as np
A=np.array([[1,2,3], [2,-7,6]])


# 3.

import numpy as np
B=np.array([[1,2], [3,4], [5,6]]) # Ligne non demandée, pour éviter les erreurs dans ce fichier, ne pas la mettre dans le DS
np.dot(A,B)


# 4.

import numpy as np
np.eye(n)


# 5.

print(np.size(A)) # Renvoie 6


# 6.

print(A[1,2]) # Renvoie 6, car on commence à compter les lignes et colonnes à partir de 0, et non de 1.



# IV Opérations sur les listes

# 1.

# Réponse : 1


# 2.
corr0 = [4, 2, 1, 4, 3, 1, 3, 3, 2, 1, 1, 3, 3, 2, 4, 4, 2, 1, 3, 3]
print(corr0[17]) # Renvoie 1, car le premier item de la liste à l'indice 0


# 3.

# Réponse : False


# 4.

copTM = [4, 1, 2, 4, 3, 3, 1, 4, 3, 3, 2, 1, 3, 2, 4, 1, 3, 3, 2, 3]

corrTM = [True, False, False, True, True, False, False, False, False, False, False, False, True, True, True, False, False, False, False, True]

# Approfondissement : Algorithme pour générer cette liste automatiquement :
corrTM = [copTM[i]==corr0[i] for i in range(len(copTM))]
print(corrTM)


# 5.

def note(cop,corr):
    n=0
    for i in range(len(cop)):
        if corr[i]==cop[i]:
            n+=1
    return n

print(note(copTM, corr0))


# 6. Version simple

def reussite(cop,corr):
    if note(cop,corr) >= 10:
        return "Réussite"
    else:
        return "Echec"
print(reussite(copTM, corr0))


# 6. Version en une ligne

def reussite(cop,corr):
    return "Réussite" if note(cop,corr)>=10 else "Echec"
print(reussite(copTM, corr0))


# 7.

def notebonus(cop,corr):
    n=0
    for i in range(len(cop)):
        if corr[i]==cop[i]:
            n+=1 # Pareil que d'écrire n=n+1
            if n==4:
                if note(cop,corr) + 2 <= 20:
                    return note(cop,corr) + 2
                else:
                    return 20
        else:
            n=0
    return note(cop,corr)

print(notebonus(copTM, corr0))



# V Courbes représentatives de fonctions

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-1, 2, 200)
y = np.exp(x**2)

plt.plot(x, y, label='f(x) = e^{x²}')
plt.title('Courbe représentative de f(x) = e^{x²}')
plt.legend()
plt.show()