Corrigé du sujet de bac S Nouvelle-Calédonie mars 2015

mardi 24 mars 2015
par  Alain BUSSER

Le sujet évoque

Exercice 1

Étude du cas particulier a=2

Comme le minimum 2-2ln(2) est strictement positif, la fonction est strictement positive sur R :

00,10,20,30,40,50,60,70,80,911,11,21,31,41,51,61,71,81,90123

Le script ayant représenté graphiquement cette fonction est le suivant :

  1. a = 2
  2.  
  3. f = (x) -> exp(x)-a*x
  4. dessineFonction f, 0, 2, 0, 4

Télécharger

Étude du cas général où a est un réel strictement positif

Pour connaître les limites de fa en ∞ et -∞, le script suivant ne convient pas :

  1. a = 2
  2. f = (x) -> exp(x)-a*x
  3. affiche f(Infinity)
  4. affiche f(-Infinity)

Télécharger

En effet, s’il conclut bien par le fait que la limite en -∞ est +∞, il commence par afficher qu’en +∞ il y a une forme indéterminée (signification du NaN) :

Algorithme lancé
NaN
Infinity

Algorithme exécuté en 28 millisecondes

Pour lever l’indétermination, il ne reste plus qu’à utiliser le cours...

L’étude de la famille de fonctions fa révèle que le nombre de points d’intersection est 1 lorsque a=e [1] :

  1. a = Math.E
  2.  
  3. f = (x) -> exp(x)-a*x
  4. dessineFonction f, 0, 2, 0, 2

Télécharger

On voit que dans ce cas il y a contact avec l’axe des abscisses :

00,10,20,30,40,50,60,70,80,911,11,21,31,41,51,61,71,81,900,10,20,30,40,50,60,70,80,911,11,21,31,41,51,61,71,81,9

Et pour a plus grand que e, par exemple a=3, on voit deux points d’intersection avec l’axe des abscisses :

  1. a = 3
  2.  
  3. f = (x) -> exp(x)-a*x
  4. dessineFonction f, 0, 2, 0, 4

Télécharger

00,10,20,30,40,50,60,70,80,911,11,21,31,41,51,61,71,81,90123

Exercice 2

Pour les probabilités conditionnelles, on utilise l’arbre pondéré.

  • comme 5% des puces présentent un défaut, on met le curseur en bas à gauche sur 0,05 (ce qui a pour effet de mettre le curseur en haut sur 0,95 : 95% des puces sont livrées) ;
  • comme 2% des puces livrées ont une durée de vie courte, on met le curseur en haut à droite sur 0,02.
Quelle est la probabilité que la puce soit livrée et ait une durée de vie strictement supérieure à 1000 heures ?

On lit en bas de l’arbre : 0,931. Ensuite ?

Quelle est la probabilité que la puce soit éliminée ou ait une durée de vie courte à la sortie de la chaine de fabrication ?

Ah tiens, c’est la probabilité du contraire de l’évènement précédent : 1-0,931=0,069...


Pour calculer les probabilités exponentielles, on utilise le calculateur ; mais d’abord alcoffeethmique pour avoir une valeur approchée du paramètre :

affiche -ln(0.98)/1000

On copie-colle les 0.000020202707317519467 obtenus dans le cadre destiné à entrer le paramètre.

  • si on entre 10000 et 20000 pour les bornes, on lit en bas que « La probabilité qu’elle soit supérieure à 10000 est 0.8171 » ;
  • si on entre 20000 et 30000 comme bornes, on lit en haut le résultat « 0.1221 (à 0,0001 près) »

Pour le calcul de probabilités binomiales, on utilise alcoffeethmique :

affiche laSommeDe (binomiale 15000, 0.003, k for k in [40..50])

L’affichage obtenu est

Algorithme lancé
0.5886001161667217

Algorithme exécuté en 24 millisecondes

Exercice 3

On définit les droites D1 et D2 par point et vecteur directeur, et on redéfinit le point A2 ; pour savoir s’il est sur la droite D2, on fait

  1. A1 = $V [0,2,-1]
  2. u1 = $V [1,2,3]
  3. D1 = $L A1, u1
  4. A2 = $V [1,0,2]
  5. u2 = $V [1,-2,0]
  6. D2 = $L A2, u2
  7. A2 = $V [-1,4,2]
  8. affiche D2.contains A2

Télécharger

Le résultat affiché est que oui :

Algorithme lancé
true

Algorithme exécuté en 69 millisecondes

Pour vérifier que les droites D1 et D2 ne sont pas coplanaires, on vérifie qu’elles ne sont ni parallèles, ni sécantes :

  1. A1 = $V [0,2,-1]
  2. u1 = $V [1,2,3]
  3. D1 = $L A1, u1
  4. A2 = $V [1,0,2]
  5. u2 = $V [1,-2,0]
  6. D2 = $L A2, u2
  7. A2 = $V [-1,4,2]
  8. affiche D1.isParallelTo D2
  9. affiche D1.intersects D2

Télécharger

Le résultat est qu’effectivement D1 et D2 ne sont pas coplanaires :

Algorithme lancé
false
false

Algorithme exécuté en 75 millisecondes

Pour vérifier que Δ1 et D1 sont perpendiculaires, on vérifie que leurs vecteurs directeurs le sont :

  1. A1 = $V [0,2,-1]
  2. u1 = $V [1,2,3]
  3. D1 = $L A1, u1
  4. A2 = $V [1,0,2]
  5. u2 = $V [1,-2,0]
  6. D2 = $L A2, u2
  7. A2 = $V [-1,4,2]
  8. v = $V [-6,-3,4]
  9. Δ1 = $L A1, v
  10. Δ2 = $L A2, v
  11. affiche Δ1.direction.isPerpendicularTo D1.direction

Télécharger

Ah tiens oui, ils le sont :

Algorithme lancé
true

Algorithme exécuté en 34 millisecondes

Pour vérifier que n est normal à P1, on vérifie qu’il est perpendiculaire à deux vecteurs de P1, non colinéaires entre eux :

  1. A1 = $V [0,2,-1]
  2. u1 = $V [1,2,3]
  3. D1 = $L A1, u1
  4. A2 = $V [1,0,2]
  5. u2 = $V [1,-2,0]
  6. D2 = $L A2, u2
  7. A2 = $V [-1,4,2]
  8. v = $V [-6,-3,4]
  9. Δ1 = $L A1, v
  10. Δ2 = $L A2, v
  11.  
  12. n = $V [17,-22,9]
  13. affiche n.isPerpendicularTo u1
  14. affiche n.isPerpendicularTo v

Télécharger

On confirme que n est normal à P1 :

Algorithme lancé
true
true

Algorithme exécuté en 60 millisecondes

On va maintenant définir P1 par un de ses points (l’intersection de Δ1 et D1) et son vecteur normal n. Pour P2 on fait pareil sauf qu’on ne connaît pas de vecteur normal. Alors on le construit avec « cross », appliqué à deux vecteurs non colinéaires de P2. On se demande si les deux plans sont sécants ou parallèles :

  1. A1 = $V [0,2,-1]
  2. u1 = $V [1,2,3]
  3. D1 = $L A1, u1
  4. A2 = $V [1,0,2]
  5. u2 = $V [1,-2,0]
  6. D2 = $L A2, u2
  7. A2 = $V [-1,4,2]
  8. v = $V [-6,-3,4]
  9. Δ1 = $L A1, v
  10. Δ2 = $L A2, v
  11. n = $V [17,-22,9]
  12. P1 = $P (Δ1.intersectionWith D1), n
  13. P2 = $P (Δ2.intersectionWith D2), (u2.cross v)
  14.  
  15. affiche P1.isParallelTo P2

Télécharger

La réponse

Algorithme lancé
false

Algorithme exécuté en 80 millisecondes

est qu’ils ne sont pas parallèles. Ce qui signifie donc qu’ils sont sécants !

Alors on définit leur intersection Δ :

  1. A1 = $V [0,2,-1]
  2. u1 = $V [1,2,3]
  3. D1 = $L A1, u1
  4. A2 = $V [1,0,2]
  5. u2 = $V [1,-2,0]
  6. D2 = $L A2, u2
  7. A2 = $V [-1,4,2]
  8. v = $V [-6,-3,4]
  9. Δ1 = $L A1, v
  10. Δ2 = $L A2, v
  11. n = $V [17,-22,9]
  12. P1 = $P (Δ1.intersectionWith D1), n
  13. P2 = $P (Δ2.intersectionWith D2), (u2.cross v)
  14.  
  15. Δ = P1.intersectionWith P2
  16. affiche Δ.direction.isPerpendicularTo D1.direction
  17. affiche Δ.direction.isPerpendicularTo D2.direction

Télécharger

Une fois qu’on a Δ, il est temps de se rappeler que

Le but de l’exercice est de prouver l’existence d’une droite perpendiculaire à la fois à D1 et D2

Or le script précédent dit que Δ convient :

Algorithme lancé
true
true

Algorithme exécuté en 32 millisecondes

On constate qu’effectivement la droite joignant M à N a pour vecteur directeur, le vecteur v de l’énoncé :

  1. A1 = $V [0,2,-1]
  2. u1 = $V [1,2,3]
  3. D1 = $L A1, u1
  4. A2 = $V [1,0,2]
  5. u2 = $V [1,-2,0]
  6. D2 = $L A2, u2
  7. v = $V [-6,-3,4]
  8. M = D1.pointClosestTo D2
  9. N = D2.pointClosestTo D1
  10.  
  11. affiche (N.subtract M).isParallelTo v

Télécharger


Remarque :

On peut calculer les coordonnées de deux points de la droite Δ sans calculer Δ elle-même : En effet elle passe par

  • Le point M de D1 qui est le plus proche possible de D2 ;
  • Le point N de D2 qui est le plus proche possible de D1

Le script suivant calcule ces points, qui définissent Δ :

  1. A1 = $V [0,2,-1]
  2. u1 = $V [1,2,3]
  3. D1 = $L A1, u1
  4. A2 = $V [1,0,2]
  5. u2 = $V [1,-2,0]
  6. D2 = $L A2, u2
  7. M = D1.pointClosestTo D2
  8. N = D2.pointClosestTo D1
  9. affiche M.inspect()
  10. affiche N.inspect()

Télécharger

On trouve alors ces coordonnées :

Algorithme lancé
[0.7377049180327868, 3.4754098360655736, 1.2131147540983607]
[-0.4426229508196722, 2.8852459016393444, 2]

Algorithme exécuté en 25 millisecondes

Exercice 4

On note (un) et (vn) les suites réelles définies, pour tout entier naturel n, par
u0=1, v0=0, et
un+1=√3un−vn
vn+1=un+√3vn

Pour ceux qui ont suivi l’enseignement de spécialité, l’exercice porte sur les puissances d’une matrice : En notant Vn le vecteur de coordonnées (un ;vn), on a Vn+1=MVn où M est une matrice. Alors le vecteur V est initialisé à la valeur (1 ;0) et l’algorithme devient

  1. rac3 = racine 3
  2. V = $V [1, 0]
  3. M = $M [[rac3,-1],[1,rac3]]
  4. for k in [1..2]
  5.     V = M.x V
  6.     affiche V.inspect()

Télécharger

(remplacer 2 par une autre valeur si on veut aller plus loin que l’énoncé).

Pour ceux qui ont suivi l’enseignement obligatoire, l’algorithme devient

  1. rac3 = racine 3
  2. [u,v] = [1,0]
  3. for n in [1..2]
  4.     [u,v] = [rac3*u-v,u+rac3*v]
  5.     affiche [u,v]

Télécharger

Mais l’énoncé décrivait l’algorithme dans un langage ne permettant pas l’affectation « simultanée » et il fallait utiliser ce genre d’astuce pour répondre à la question...

Cette variante représente graphiquement la suite (u) :

  1. rac3 = racine 3
  2. [u,v] = [1,0]
  3. suite = [u]
  4. for n in [1..20]
  5.     [u,v] = [rac3*u-v,u+rac3*v]
  6.     suite.push u
  7. dessineSuite suite, 12, 0, 5000

Télécharger

On voit que la suite n’est pas convergente :

0123456789101112010002000300040005000

Voilà comment on peut vérifier numériquement l’égalité complexe de l’énoncé :

  1. z = new Complexe 1
  2. a = new Complexe racine(3), 1
  3. for k in [1..10]
  4.     z = z.fois a
  5.     affiche z

Télécharger

Cela permet de voir que les suites (u) et (v) sont la partie réelle et la partie imaginaire d’une suite géométrique de raison a=2 eiπ/6 ; d’où les exrpressions analytiques de un et vn...


[1La dérivée de fa étant ex-a, s’annule lorsque ex=a soit en ln(a). Par croissance de la fonction exponentielle, on en déduit que fa(a) est un minimum, qu’on calcule puis on conclut en constatant qu’on cherche les nombres qui annulent fa, ce qui revient à étudier le signe du minimum.


Commentaires