Fonctions - Exercices

Symétrie Centrale

Ecrire une fonction en Python de paramètres les coordonnées de deux points A et I qui renvoie les coordonnées d'un point B symétrique de A par rapport à I

Une solution de l'exercice "Symétrie centrale".

def f(x,a) :
	return 2x - a
def symetrique(xA,yA,xI,yI)
		return f(xI,xA),f(yI,yA)

Translation de vecteur $\overrightarrow{AB}$

Ecrire une fonction en Python de paramètres les coordonnées de trois points A, B et C qui renvoie les coordonnées d'un point D image de C par la translation de vecteur $\overrightarrow{AB}$

Une solution de l'exercice "translation".

def vecteur(xA,yA,xB,yB) :
	return (xB-xA,yB-yA)
def translation(xA,yA,xB,yB,xC,yC) :
	xAB,yAB=vecteur(xA,yA,xB,yB)
	return xAB+xC,yAB+yC

Parallélogramme (Académie de Lyon)

Ecrire une fonction en Python de paramètres les coordonnées de quatre points A, B, C et D qui renvoie True si ABCD est un parallélogramme et False sinon

Ecrire une fonction en Python de paramètres les coordonnées de quatre points A, B, C et D qui renvoie True si ABCD est un parallélogramme non applati et False sinon

Remarque

Pour éviter les problèmes de représentation des nombres machines on donne aux sommets des coordonnées entières.

Parallélogramme : question 1

def parallelogramme(xA,yA,xB,yB,xC,yC,xD,yD) :
	if (xB-xA == xC-xD and yB-yA == yC-yD) : return True
	else : return False

Parallélogramme : question 2

def vecteursEgaux(xA,yA,xB,yB,xD,yD,xC,yC) :
	if (xB-xA == xC-xD and yB-yA == yC-yD) : return True
	else : return False
def alignement(xA,yA,xB,yB,xC,yC) :
	if ((xB-xA)*(yC-YA) == (xC-xA)*(yB-YA)) : return True
	else : return False

def parallelogrammeNonAplati(xA,yA,xB,yB,xC,yC,xD,yD) :
	VE = vecteursEgaux(xA,yA,xB,yB,xD,yD,xC,yC) 
	Al = alignement(xA,yA,xB,yB,xC,yC)
	return VE and not Al

Carré (Académie de Lyon)

Ecrire une fonction en Python de paramètres les coordonnées de quatre points A, B, C et D qui renvoie True si ABCD est un losange et False sinon

Ecrire une fonction en Python de paramètres les coordonnées de quatre points A, B, C et D qui renvoie True si ABCD est un carré non applati et False sinon

Remarque

Pour éviter les problèmes de représentation des nombres machines on donne aux sommets des coordonnées entières.

Losange : question 1

def vecteurs(xA,yA,xB,yB) :
	return (xB-xA,yB-yA)
def alignement(xA,yA,xB,yB,xC,yC) :
	xAB,yAB=vecteurs(xA,yA,xB,yB)
	xAC,yAC=vecteurs(xA,yA,xC,yC)
	if xAB*yAC == xAC*YAB : return True
	else : return False
	
def orthoVecteurs(xA,yA,xB,yB,xC,yC,xD,yD) :
	xAB,yAB=vecteurs(xA,yA,xB,yB)
	xCD,yCD=vecteurs(xC,yC,xD,yD)
	if xAB*xCD + yAB*YCD == 0 : return True
	else : return False

def parallelogrammeNonAplati(xA,yA,xB,yB,xC,yC,xD,yD) :
	VE = (vecteurs(xA,yA,xB,yB) == vecteurs(xD,yD,xC,yC) 
	Al = alignement(xA,yA,xB,yB,xC,yC)
	return VE and not Al
	
def losange(xA,yA,xB,yB,xC,yC,xD,yD):
	PNA = parallelogrammeNonAplati(xA,yA,xB,yB,xC,yC,xD,yD)
	VO = orthoVecteurs(xA,yA,xC,yC,xD,yD,xB,yB)
	return PNA and VO

Carré : question 2

def vecteurs(xA,yA,xB,yB) :
	return (xB-xA,yB-yA)
def alignement(xA,yA,xB,yB,xC,yC) :
	xAB,yAB=vecteurs(xA,yA,xB,yB)
	xAC,yAC=vecteurs(xA,yA,xC,yC)
	if xAB*yAC == xAC*YAB : return True
	else : return False
	
def orthoVecteurs(xA,yA,xB,yB,xC,yC,xD,yD) :
	xAB,yAB=vecteurs(xA,yA,xB,yB)
	xCD,yCD=vecteurs(xC,yC,xD,yD)
	if xAB*xCD + yAB*YCD == 0 : return True
	else : return False

def parallelogrammeNonAplati(xA,yA,xB,yB,xC,yC,xD,yD) :
	VE = (vecteurs(xA,yA,xB,yB) == vecteurs(xD,yD,xC,yC) 
	Al = alignement(xA,yA,xB,yB,xC,yC)
	return VE and not Al
	
def longueur(xA,yA,xB,yB) :
	xAB,yAB=vecteurs(xA,yA,xB,yB)
	return xAB*xAB + yAB+yAB

def losange(xA,yA,xB,yB,xC,yC,xD,yD):
	PNA = parallelogrammeNonAplati(xA,yA,xB,yB,xC,yC,xD,yD)
	VO = orthoVecteurs(xA,yA,xC,yC,xD,yD,xB,yB)
	return PNA and VO 
	
def carre(xA,yA,xB,yB,xC,yC,xD,yD):
	losange = losange(xA,yA,xB,yB,xC,yC,xD,yD)
	ML = longueur(xA,yA,xB,yB) ==longueur(xB,yB,xC,yC)
	return losange and ML

Méthode de Dichotomie (Eduscol)

Cette situation peut donner lieu à des activités en classe de seconde.

La méthode de dichotomie constitue un procédé dont la compréhension et la mise en oeuvre peuvent être particulièrement délicates pour les élèves. Le détour par l'algorithmique permet de « faire fonctionner » la méthode et de l'observer en acte. Cette activité peut se décliner de façons multiples pour les élèves. Il peut être simplement question de relier les blocs d'instructions aux éléments correspondant dans le texte qui décrit l'algorithme.

Soit $f$ une fonction continue sur un intervalle I. Soit a et b deux points de I tels que $a < b \text{ et } f(a)×f(b)< 0 $. On sait qu’il existe au moins une solution de l’équation $f(x) = 0$ sur l’intervalle [a ; b]. Le principe de l’algorithme de dichotomie consiste à considérer le point $c = \frac{a+b}{2}$. Si $f(a)×f(c)\leq 0$, on sait qu’il existe une solution sur l’intervalle [a ; c]. Sinon, on a $f(b)×f(c)\leq 0$, et il existe une solution sur l’intervalle [c ; b]. Ainsi, à chaque étape on passe d’un intervalle contenant une solution à un intervalle de longueur moitié contenant une solution. On itère le procédé jusqu’à obtenir un intervalle de longueur inférieure à la précision requise.

Ecrire une fonction en Python permettant de renvoyer une valeur approchée de la solution de l'équation $f(x) = 0$

Une solution de l'exercice Méthode de Dichotomie.

def dichotomie(f,a,b,epsilon=0.0001):
	assert(f(a)*f(b)< 0  and a < b)	#vérifie les hypothèses requises
	while b-a > epsilon:
		c = (a+b)/2
		if f(a)*f(c) <= 0:
			a,b = a,c
		else:
			a,b = c,b
	return (a+b)/2

On remarque que dans la définition de la fonction, une valeur par défaut est fournie pour epsilon. Cela signifie que l’appel dichotomie(f,a,b) est équivalent à l’appel dichotomie(f,a,b,0.0001).

Pour imposer une précision différente de la valeur par défaut, il suffit de la préciser, dichotomie(f,a,b,0.0000001) par exemple.

Après avoir ouvert la bibliothèque math par la commande from math import *, on obtient pour epsilon = 0,0001 :

>>>from math import *
>>>dichotomie(cos,0,2)
1.570770263671875.

PGCD.

Ecrire une fonction permettant de déterminer le pgcd de deux entiers naturels $ a $ et $ b $.

Résolution de l'exercice PGCD

Premier programme.


def pgcd(a , b) :
    
    """
    Cette fonction permet de calculer le PGCD de deux entiers naturels a et b
    """
    while b!=0 :
        aux= a
        a=b
        b= aux%b
    return a


>>>c = pgcd(72 , 48)
24
>>>

Second programme.

On peut en python se passer de la variable intermédiaire aux utilisée dans le programme précédent à l'aide d'affectations parallèles.

Par exemple, si l'on veut échanger les valeurs des variables a et b, il suffit d'écrire a,b=b,a en langage python (dans la plupart des autres langages, une variable auxiliaire serait nécessaire).

Cette particularité permet d'écrire un programme plus proche de notre descriptif :

def pgcd(a , b) :
    
    """
    Cette fonction permet de calculer le PGCD de deux entiers naturels a et b
    """
	assert(a>0 and type(a)==type(b)==int and b>0) # vérifie que a et b sont des entiers positifs
    while (b!=0):
        a,b =b, a%b
    return a


>>>c = pgcd(72 , 48)
24
>>>

Décompositions en facteurs premiers (Eduscol)

Écrire une fonction, de paramètre un entier naturel n, qui renvoie une liste de facteurs premiers de n

Résolution de l'exercice "Factorisation en facteurs premiers".

def factorisation(n):
	assert(n>=2 and type(n)==int)	#vérifie que n est un entier supérieur ou égal à 2
	L = []
	d = 2
	while n>1:
		if n%d == 0:			# on a trouvé un diviseur !
			while n%d == 0:		# on le factorise autant que possible et
				L.append(d)		# on l’ajoute à chaque fois dans la liste
				n = n//d
		d = d + 1
	return L

L'indentation ici est cruciale

>>> factorisation(24)
[2, 2, 2, 3]