Certains élèves sont un peu plus à l'aise avec la programmation et travaillent plus vite que les autres. Ici se trouve une série d'exercices pour les occuper en classe.
Dans un premier temps, le but de ces exercices est de croiser ce qui est enseigné en mathématiques et en NSI.
L'ensemble des fonctions créées doivent être dans un même fichier car des exercices ont besoin des fonctions précédemment écrites.
On pourra par exemple créer le fichier mathematiques.py dans son dossier.
Ecrire une fonction enleve_espaces_devant qui prend en paramètre un string texte et qui
renvoie un string dépourvu des caractères "espace" placés devant s'il y en a.
Afin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> enleve_espaces_devant(" coucou")
"coucou"
>>> enleve_espaces_devant("coucou")
"coucou"
>>> enleve_espaces_devant(" cou cou")
"cou cou"
>>> enleve_espaces_devant(" cou cou ")
"cou cou "Ecrire une fonction enleve_espaces_a_la_fin qui prend en paramètre un string texte et
qui renvoie un string dépourvu des caractères "espace" placés à la fin s'il y en a.
Afin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> enleve_espaces_a_la_fin("coucou ")
"coucou"
>>> enleve_espaces_a_la_fin("coucou")
"coucou"
>>> enleve_espaces_a_la_fin("cou cou ")
"cou cou"
>>> enleve_espaces_a_la_fin(" cou cou ")
" cou cou"Ecrire une fonction nb_occurences(texte,caractere) qui prend en paramètres un string
texte et un string caractere composé d'un unique caractère et qui renvoie un integer
correspondant au nombre de fois où ce caractère est présent.
Afin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> nb_occurences("coucou","c")
2
>>> nb_occurences("coucou","h")
0
>>> nb_occurences("coucou.",".")
1
>>> nb_occurences("coucou ça va?"," ")
2Ecrire une fonction est_un_nombre qui prend en paramètre un string nombre et qui renvoie
un booléen qui vaut True si ce string représente un nombre réel sans avoir besoin d'effectuer
d'opérations (hormis un changement de signe placé devant) et False sinon.
Afin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> est_un_nombre("32")
True
>>> est_un_nombre("32x")
False
>>> est_un_nombre("32+")
False
>>> est_un_nombre("32-")
False
>>> est_un_nombre("165204652456156416532")
True
>>> est_un_nombre("16520465245q6156416532")
False
>>> est_un_nombre("-32")
True
>>> est_un_nombre("+32")
True
>>> est_un_nombre("--32")
False
>>> est_un_nombre("3-2")
False
>>> est_un_nombre(" 32 ")
True
>>> est_un_nombre(" -32 ")
True
>>> est_un_nombre(" - 32 ")
False
>>> est_un_nombre("3-2")
False
>>> est_un_nombre("32.2")
True
>>> est_un_nombre("-3.2")
True
>>> est_un_nombre("-3.2.2")
False
>>> est_un_nombre("-3 .2")
False
>>> est_un_nombre(" -3.2 ")
True
>>> est_un_nombre("-3.2.2")
False
>>> est_un_nombre("3-2")
False
>>> est_un_nombre("- 32")
False
>>> est_un_nombre(" 000.0000002 ")
True
>>> est_un_nombre("-.0000002 ")
TrueEcrire une fonction conversion_nombres(expression) qui prend en paramètre un string
expression qui correspond à un nombre et qui renvoie un integer si c'est possible ou un flottant
On gérera les opérations +, -, *, /, ^.
Afin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> conversion_nombres(" +32 ")
32
>>> conversion_nombres("32.0")
32
>>> conversion_nombres("32.1")
32.1
>>> conversion_nombres("-00032.00000000000000000000")
-32
Ecrire une fonction liste_expression_numerique(expression) qui prend en paramètre un string
expression qui correspond à une expression numérique dépourvue de parenthèses et qui renvoie une liste composée des nombres et des opérations qui la composent.
On gérera les opérations +, -, *, /, ^.
Afin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> liste_expression_numerique(" 223 + 4 ")
[223,"+",4]
>>> liste_expression_numerique("-223")
[-223]
>>> liste_expression_numerique("-2.3+45*7")
[-2.3,"+",45,"*",7]
>>> liste_expression_numerique("-45.000-7")
[-45,"-",7]
>>> liste_expression_numerique("2^80+7")
[2,"^",80,"+",7]Ecrire une fonction evaluation_liste_sans_parenthese(liste) qui prend en paramètre une liste composé de nombres, ou de strings correspondant aux opérations et qui renvoie un integer (ou un flottant) qui correspond au résutat du calcul donné dans la liste.
On gérera les opérations +, -, *, /, ^.
L'algorithme procedera ainsi :
Afin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> evaluation_liste_sans_parenthese([2,"+",3])
5
>>> evaluation_liste_sans_parenthese([2,"^",3,"^",3])
134217728
>>> evaluation_liste_sans_parenthese([2,"-",3,"*",4])
-10
Une première satisfaction
Compléter la fonction calculs_expressions_sans_parentheses(expression) qui prend en paramètre un string représentant un calcul numérique sans parenthese et qui évalue le résultat.
def calculs_expressions_sans_parentheses(expression):
return .............................................................Oui, il n'y a bien qu'une seule ligne à l'intérieur de cette fonction.
Afin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> calculs_expressions_sans_parentheses(" 23 + 5 * 4")
43
>>> calculs_expressions_sans_parentheses(" 23.0 + 5 * 4-2^3")
35Une deuxième dans la foulée
Compléter la fonction calculs_expressions(expression) qui prend en paramètre un string représentant un calcul numérique qui peut avoir des parenthèses et qui évalue le résultat.
def calculs_expressions(expression):
if .................... : # Si l'expression comporte un caractère "("
indice_droit=0
while expression[indice_droit]!=")":
indice_droit+=1
indice_gauche=indice_droit
while expression[indice_gauche]!="(":
indice_gauche-=1
nb=calculs_expressions_sans_parentheses(expression[indice_gauche+1:indice_droit])
if expression[indice_gauche-1] in ["+","-","*","/","^"] or indice_gauche==0:
nouvelle_expression=expression[:indice_gauche]+str(nb)+expression[indice_droit+1:]
else: #pour traiter l'ajout d'une multiplication. Par ex 4(2+6)
nouvelle_expression=expression[:indice_gauche]+"*"+str(nb)+expression[indice_droit+1:]
print(nouvelle_expression)
return ...................... #on lance calculs_expressions mais avec la nouvelle expression
else:
return .......................... #on lance le calcul sans parentheseAfin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> calculs_expressions("3*(2*(4+5))")
3*(2*9)
3*18
54
>>> calculs_expressions("3 + 4.0 *(6 +(2*4-(5/2)+(3/2))) ")
3 + 4.0 *(6 +(2*4-2.5+(3/2)))
3 + 4.0 *(6 +(2*4-2.5+1.5))
3 + 4.0 *(6 +7.0)
3 + 4.0 *13
55Ecrire une fonction liste_expression_litterale(expression) qui prend en paramètre un string
expression qui correspond à une expression littérale en \(x\) dépourvue de parenthèses et qui renvoie une liste composée des nombres ( y compris \(x\)), des opérations qui la composent.
On gérera les opérations +, -, *, /, ^.
Afin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> liste_expression_numerique(" -x+5")
[-1,"*","x","+",5]
>>> liste_expression_numerique("12x^2+54x-3.2")
[12,"*","x","^",2,"+",54,"x","-",3.2]Compléter la fonction evaluation_litterale_sans_parentheses(expression,valeur) qui prend en paramètre un string représentant une expression littérale avec \(x\) sans parenthese et qui évalue le résultat en remplaçant \(x\) par valeur.
Ne pourrait-on pas utiliser deux fonctions déjà créées afin de rendre cet exercice facile?
Afin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> evaluation_litterale_sans_parentheses("-x+2",45)
-43
evaluation_litterale_sans_parentheses("x^2",9)
81
evaluation_litterale_sans_parentheses("32x^3-45x+22+10x-x",3)
778La récompense d'un dur labeur.
Compléter la fonction evaluation_litterale(expression,valeur) qui prend en paramètre un string représentant une expression littérale qui peut avoir des parenthèses et qui évalue le résultat.
def evaluation_litterale(expression,valeur):
if ............................: # Si l'expression comporte un caractère "("
indice_droit=0
while expression[indice_droit]!=")":
indice_droit+=1
indice_gauche=indice_droit
while expression[indice_gauche]!="(":
indice_gauche-=1
nb=evaluation_litterale_sans_parentheses(expression[indice_gauche+1:indice_droit],valeur)
if expression[indice_gauche-1] in ["+","-","*","/","^"] or indice_gauche==0:
nouvelle_expression=expression[:indice_gauche]+str(nb)+expression[indice_droit+1:]
else: #pour traiter l'ajout d'une multiplication. Par ex 4(2+6)
nouvelle_expression=expression[:indice_gauche]+"*"+str(nb)+expression[indice_droit+1:]
print(nouvelle_expression)
return ........................................ # on relance evaluation_litterale avec la nouvelle expression
else:
return .................................................. #on lance le calcul sans parentheseAfin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> evaluation_litterale("x(x+2)",5)
x*7
35
>>> evaluation_litterale("4x^5(-2x+2+(x+5))",5)
4x^5(-2x+2+10)
4x^5*2
25000Maintenant que l'on est capable d'évaluer des expressions numériques et littérales, on s'attaque au développement d'expressions littérales de polynômes.
Compléter la fonction produit_litteral(expression) qui prend en paramètre un string représentant un produit ou succession de produits (sans parenthèse, sans somme, sans différence) d'expressions littérales avec \(x\) comme unique variable et qui renvoie un tuple contenant deux éléments : l'exposant de \(x\) et son coefficient.
Afin d'éclaircir ce qui est demandé, voici des exemples de réponses de la fonction:
>>> produit_litteral("x^2*5*2x") # rappel : x^2*5*2x = 10x^3
(3,10)
>>> produit_litteral("3*8*5")
(0,120)
>>> produit_litteral("3x*8*x^2*5*x*-2") #oui, logiquement il y a des parenthèses à -2, mais notre programme gère quand même
(4,-240)