Algorithmes et programmes en seconde : corrigé détaillé des exercices 1 à 10

a) La valeur saisie est convertie par int( ) : \(x\) est une variable de type entier (int).

b) Le programme calcule successivement \(4x\), puis \(4x+1\), puis le carré.

c) En suivant les affectations : \(f(x)=(4x+1)^2\) (que l’on peut développer en \(16x^2+8x+1\)).

Fonctionnement. L’algorithme demande une chaîne de caractères \(C\) non vide. Il range dans \(\ell\) le nombre de caractères de \(C\) : \(\ell\) est donc la position du dernier caractère. Il extrait ensuite de \(C\) la sous-chaîne qui commence au caractère numéro \(\ell\) et qui contient 1 caractère, et l’affiche.

Exemple. Avec \(C=\) « algorithme » : \(\ell=10\) et Sch(« algorithme », 10, 1) = « e ».

Rôle. L’algorithme affiche le dernier caractère de la chaîne saisie. En Python, on écrirait simplement C[len(C)-1] ou C[-1] (attention, en Python la numérotation commence à 0).

a) Jusqu’à 50 photocopies, chacune coûte 0,15 € : \(\text{Prix}=0{,}15\times N\). Au-delà, les 50 premières coûtent \(50\times0{,}15=7{,}50\) € et chacune des \(N-50\) suivantes coûte 0,10 €.

Ligne ① : Prix=0.15*N
Ligne ② : Prix=0.15*50+0.10*(N-50) (soit Prix=7.5+0.1*(N-50))

b) Le programme complet :

print(« Entrer N : »)
N=int(input())
if N<=50:
    Prix=0.15*N
else:
    Prix=0.15*50+0.10*(N-50)
print(« Prix= »,Prix)

c) Contrôles : pour \(N=30\), \(30\times0{,}15=4{,}50\) € ; pour \(N=50\), \(7{,}50\) € ; pour \(N=80\), \(7{,}50+30\times0{,}10=10{,}50\) €. Remarque : si l’on comprend que toutes les copies passent à 0,10 € au-delà de 50, la ligne ② devient Prix=0.10*N ; mais alors 51 copies (5,10 €) coûteraient moins cher que 50 (7,50 €), ce qui est peu vraisemblable.

a) Durée = distance ÷ vitesse.

\[ t_1=\frac{5}{15}=\frac{1}{3}\text{ h}=20\text{ min} \qquad t_2=\frac{7-5}{12}=\frac{1}{6}\text{ h}=10\text{ min} \]

Louise met 30 minutes au total.

b) À 15 km/h, on parcourt \(\frac{15}{60}=0{,}25\) km par minute ; à 12 km/h, \(\frac{12}{60}=0{,}2\) km par minute. Donc :

• si \(0\leqslant t\leqslant20\) : \(d(t)=0{,}25\,t\) ;
• si \(20\lt t\leqslant30\) : \(d(t)=5+0{,}2\,(t-20)\) ;
• si \(t\gt30\) : la course est finie, \(d(t)=7\).

t=float(input(« t en minutes : « ))
if t<=20:
    d=0.25*t
elif t<=30:
    d=5+0.2*(t-20)
else:
    d=7
print(« d(t) = »,d, »km »)

Par exemple, pour \(t=25\) min, le programme affiche \(5+0{,}2\times5=6\) km.

a) On suit l’évolution de \(S\) pour \(n=5\) :

Le résultat affiché est 55.

b) À chaque tour, on ajoute \(i^2\) à \(S\). L’algorithme calcule donc la somme des carrés des entiers de 1 à \(n\) : \(S=1^2+2^2+\dots+n^2\).

On traduit les trois cas par une instruction conditionnelle à trois branches :

def f(x):
    if x<=0:
        return x**2
    elif x<=1:
        return x
    else:
        return -2*x+3

Le elif n’est examiné que si \(x\gt0\) : la condition x<=1 correspond donc bien au cas \(0\lt x\leqslant1\). Tests : \(f(-2)=4\), \(f(0{,}5)=0{,}5\), \(f(3)=-3\).

a) Rôle des variables :

• n est un compteur : il vaut 0 au départ et augmente de 1 à chaque « Pile » ; à la fin, il contient le nombre de Pile obtenus ;
• i est la variable de la boucle : elle prend les valeurs 1, 2, …, 100 et compte les lancers ;
• x est un nombre aléatoire de \([0\,;1[\) tiré à chaque lancer ; x<0.5 arrive avec une probabilité \(\frac{1}{2}\) et représente « Pile ».

b) Il suffit d’englober la simulation dans une seconde boucle qui se répète M fois (et de remettre n à 0 à chaque simulation) :

from random import random
M=int(input(« M = « ))
for k in range(1,M+1):
    n=0
    for i in range(1,101):
        x=random()
        if x<0.5:
            n=n+1
    print(« simulation »,k, »: n= »,n)

a) Pour chaque entier \(k\) de 1 à \(N\), on ajoute 1 à \(x\) lorsque \(k\) divise \(N\). La fonction renvoie donc le nombre de diviseurs de \(N\). Par exemple, diviseurs(12) = 6 (1, 2, 3, 4, 6, 12).

b) On réutilise cette fonction dans une boucle de 1 à 100 (en Python, « \(k\) divise \(N\) » s’écrit N%k==0) :

def diviseurs(N):
    x=0
    for k in range(1,N+1):
        if N%k==0:
            x=x+1
    return x
for n in range(1,101):
    if diviseurs(n)>=10:
        print(n)

Le programme affiche 48, 60, 72, 80, 84, 90 et 96 (par exemple 60 a 12 diviseurs : 1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60).

a) \(x\) est converti par int( ) : c’est un entier.

b) Le programme calcule \(x^2\), puis \(-x^2+3x\), puis \(-x^2+3x+4\).

• \(x=1\) : \(y=1\), puis \(-1+3=2\), puis \(2+4=\) 6 ;
• \(x=-2\) : \(y=4\), puis \(-4-6=-10\), puis −6 ;
• \(x=12\) : \(y=144\), puis \(-144+36=-108\), puis −104.

c) Attention à la ligne y=-y+3*x : c’est l’opposé de \(y\) qui est utilisé. On obtient \(f(x)=-x^2+3x+4\).

a) Pour \(n=4\), la boucle prend \(j=1,2,3,4\) (range(1,n+1) s’arrête avant \(n+1\)) :

\[ S=0+2+4+6+8=20 \]

Le programme affiche S= 20.

b) Le programme ajoute \(2j\) pour \(j\) allant de 1 à \(n\) : il calcule la somme des \(n\) premiers nombres pairs non nuls, \(S=2+4+\dots+2n\). Comme \(1+2+\dots+n=\frac{n(n+1)}{2}\), on a \(S=n(n+1)\) ; pour \(n=4\), \(4\times5=20\).