Mardi 31 mars – intégrales : changeons de point de vue

Bonjour.

 

D’abord, voici la correction des derniers exercices A5.

 

Donc, comme bilan provisoire, on a bien compris qu’une intégrale est une aire : celle « sous » la courbe de la fonction qu’on intègre.

 

Mettons-ça de côté quelques temps : nous y reviendrons.

 

Pour jeudi, réfléchissez aux questions toutes simples suivantes :

  • Quelle est une fonction dont la dérivée soit f(x)=2x ? En trouver plusieurs. Qu’ont-elles toutes en commun ? Qu’est ce qui les différencie ?
  • Quelle est une fonction F dont la dérivée soit f(x)=4x-1 ?
  • Quelle est une fonction G dont la dérivée soit g(x)=6x^2-5x+3 ?
  • Quelle est une fonction H dont la dérivée soit h(x)=e^x+\dfrac{1}{x} ?

 

A jeudi !

Mardi 31 mars – exode rurale

Bonjour.

 

Voici le corrigé d’une part de l’exercice 5 sur les graphes, et du dernier exercice de cryptographie.

 

Je vous invite à travailler pour vendredi le dernier exercice (modèle proie – prédateur) de la feuille d’exercices sur les graphes, assez calculatoire (courage !)

 

Après cela, on fera un bilan des différentes techniques liées aux graphes, à la notion d’état stable, à la traduction matricielle des graphes, aux suites de matrices qui en résultent, etc.

 

Bonne semaine à tous.

 

 

Test « rapide » -> se donner 30 minutes

Le sujet :


Un corrigé dans 30 minutes en cliquant sur « lire la suite » :

cm 2020-03-31 - TS1 - A11 - Test rapide primitives ex1 cm 2020-03-31 - TS1 - A11 - Test rapide primitives ex2cm 2020-03-31 - TS1 - A11 - Test rapide primitives ex3

 

Lundi 30 mars – fin de l’orthogonalité dans l’espace

Bonjour.

 

On va commencer par la correction des petits exercices dans le manuel, et par le début du travail sur l’idée d’orthogonalité entre deux plans.

 

Ensuite, on peut terminer le cours sur l’orthogonalité, avec celle entre droite et plan et quelques règles simples.

 

 

Pour mercredi :

  • terminer la feuille G5 – « idée d’orthogonalité dans l’espace »
  • exercice 41 page 351

 

On corrige ça mercredi, on fixe les modalités d’une interro, et on démarre… le calcul intégral !!!

 

Bon début de semaine (si vous arrivez encore à distinguer semaine et week-end…)

CI n°2 – se créer ses propres objets

Bonjour ! Et bienvenue dans cette deuxième semaine.

Le support du jour :


ch3-1-tout-est-objetch3-2-creer-son-propre-objetch3-3-1-creer-une-classech3-3-2-pas-compris-instancech3-3-4-c-est-qui-ce-self-1ch3-3-4-c-est-qui-ce-self-2ch3-4-1ch3-4-2ch3-5


Les exemples du cours et l’autre exemple développé en deuxième partie de cours :

class MaPremiereClasse:
        
    def __init__(self):
        print("constructeur de la classe MaPremierClasse")
        self.nombre = 42     # ajout de l’attribut nombre
        self.nom = "John"

# truc = MaPremiereClasse()

class Etudiant :
    """Cette classe permet de stocker des informations sur un.e etudiant.e

    Un.e etudiant.e est ici caracterise.e par :
    −> ses nom et prenom
    −> son age
    −> son numero d’etudiant.e
    −> son cursus """

    def __init__(self, prenom, nom, age, numero, cursus):
        """Constructeur de notre classe """
        self.nom = nom
        self.prenom = prenom
        self.age = age
        self.numero = numero
        self.cursus = cursus

from math import sqrt

class NombreComplexe:
    """Une classe exemple meme s’il existe un type complex"""

    def __init__(self, a, b):
        self.re = a
        self.im = b
        self.module = sqrt(a ** 2 + b ** 2)

class Personne:
    """Quelqu'un sur l'arbre généalogique

    Une personne, son genre, ses enfants, ses parents"""

    def __init__(self, prenom, nom, age, genre,
                 conj = None, enfants = None, parents = None):
        """Constructeur"""
        self.prenom = prenom
        self.nom = nom
        self.age = age
        self.genre = genre
        self.conj = conj
        if enfants is None:
            self.enfants = []
        else :
            self.enfants = enfants
        if parents is None:
            self.parents = []
        else :
            self.parents = parents
        
        
def affiche(p):
    print("\n", p.prenom, p.nom, "a", p.age, "ans")
    if p.conj is not None:
        print("En couple avec", p.conj.prenom, p.conj.nom)
    if len(p.enfants) > 0:
        print("Enfants :", end = '')
        for e in p.enfants:
            print(e.prenom, end = '\t')
        print()
    if len(p.parents) > 0:
        print("Parents :", end = '')
        for e in p.parents:
            print(e.prenom, end = '\t')
        print()

Et le shell correspondant

>>> moi = Personne("Christophe", "Marchant", 46, "masculin")
>>> moi.conj = Personne("Barbara", "Marchant", 37, "féminin")
>>> affiche(moi)

 Christophe Marchant a 46 ans
En couple avec Barbara Marchant
>>> affiche(moi.conj)

 Barbara Marchant a 37 ans
>>> moi.conj.conj
>>> moi.conj.conj = moi
>>> affiche(moi.conj)

 Barbara Marchant a 37 ans
En couple avec Christophe Marchant
>>> papa = Personne("Jean-Pierre", "Marchant", 73, "masculin")
>>> 
>>> maman = Personne("Nicole", "Marchant", 72, "feminin", papa)
>>> papa.conj = maman
>>> moi.parents
[]
>>> moi.parents =[maman, papa]
>>> affiche(moi)

 Christophe Marchant a 46 ans
En couple avec Barbara Marchant
Parents :Nicole	Jean-Pierre	
>>> papa.enfants += [moi]
>>> maman.enfants = papa.enfants
>>> papa.enfants += [Personne("Pierre", "Marchant", 49, "masculin", None, None, [papa, maman])]
>>> maman.enfants
>>> maman.enfants += [Personne("Marie", "Marvalin", 41, "féminin", None, None, [papa, maman])]
>>> affiche(moi)

 Christophe Marchant a 46 ans
En couple avec Barbara Marchant
Parents :Nicole	Jean-Pierre	
>>> affiche(papa)

 Jean-Pierre Marchant a 73 ans
En couple avec Nicole Marchant
Enfants :Christophe	Pierre	Marie	
>>> affiche(moi.conj)

 Barbara Marchant a 37 ans
En couple avec Christophe Marchant
		
>>> def fratrie(p):
	liste = []
	for e in p.parents:
		for k in e.enfants:
			if k not in liste and k is not p :
				liste += [k]
	return liste

>>> fratrie(moi)
[, ]
>>> for buddy in fratrie(moi):
	print(buddy.prenom, buddy.nom)

	
Pierre Marchant
Marie Marvalin

 

 

 

Prouver un algorithme

On devait pour aujourd’hui implémenter l’algorithme de recherche dichotomique sur un tableau trié :

def recherche_dichotomique(tab, val):
    """ Recherche val dans un tableau tab
        tab est supposé trié """

    # initialisation
    gauche = 0
    droite = len(tab) - 1
    
    while gauche <= droite:
        milieu = (gauche + droite) // 2
        if tab[milieu] == val:
            # on a trouvé val dans le tableau,
            # à la position milieu
            return milieu
        elif tab[milieu] > val:
            # on cherche entre gauche et milieu - 1
            droite = milieu - 1
        else:             # on a tab[milieu] < val
            # on cherche entre milieu + 1 et droite
            gauche = milieu + 1

    # on est sorti de la boucle sans trouver val
    return -1


#tests

liste = [1, 3, 5, 7, 9]
print(liste)
for truc in [0, 42, 5 , 3, 7, 2, 8, 9, 1, -52]:
    print("Pour", truc, "on obtient",
          recherche_dichotomique(liste, truc))
[1, 3, 5, 7, 9]
Pour 0 on obtient -1
Pour 42 on obtient -1
Pour 5 on obtient 2
Pour 3 on obtient 1
Pour 7 on obtient 3
Pour 2 on obtient -1
Pour 8 on obtient -1
Pour 9 on obtient 4
Pour 1 on obtient 0
Pour -52 on obtient -1
>>>

C’est sans difficulté, puisqu’on vous avait donné ce document institutionnel (à comprendre jusqu’au milieu de la troisième page) et que ce code figurait au milieu de la deuxième page.


Prouver un algorithme – en deux temps (à savoir) :

  • Il faut prouver qu’il se termine : On parle de terminaison.

    On utilise ici un variant de boucle, en général

    • soit une variable qui augmente et ne peut pas dépasser un « plafond »
    • soit une variable qui diminue et ne peut pas passer sous un « plancher »
  • Il faut prouver qu’il fait bien ce que l’on attend de lui : On parle de correction.

    Pour cela, on va chercher un un invariant de boucle.

    C’est quoi un « invariant de boucle ? »

    C’est une propriété qui est vérifiée avant l’entrée dans la boucle,
    qui est vérifiée à chaque itération de la boucle et qui amène au résultat escompté à la sortie de la boucle.


Exemple facile pour commencer

Soit l’algorithme

def deux_puissance(n):

    assert n >=0

    #initialisation
    i = 0
    reponse = 1
    
    # traitement :
    while i < n : 
        i += 1
        reponse *= 2

    # terminé :
    return reponse

# tests
assert deux_puissance(0) == 1
assert deux_puissance(1) == 2
assert deux_puissance(2) == 4
assert deux_puissance(8) == 256

Cette fonction passe sans encombres les tests caractérisés par

  • les quatre assert en fin de code qui testent quatre valeurs de retour,
  • le assert en début de fonction qui teste les préconditions « n positif ou nul ».

Mais nous voulons prouver cet algorithme !

  • Terminaison :

    Le variant de boucle est clairement ici i qui augmente forcément avec l’incrémentation i += 1 dans la boucle while. Quand i atteint n, qui est forcément positif ou nul, l’algorithme termine. La terminaison est donc assurée.

  • Correction :

    On veut que le programme renvoie 2 ** n quel que soit n positif ou nul.
    L’invariant de boucle est par exemple ici la propriété

    « reponse vaut 2 ** i »

    • Avant la boucle, i vaut zéro et reponse vaut 1 soit 2 ** 0. OK
    • Si l’invariant « reponse vaut 2 ** i » est vraie à la fin d’un passage de la boucle, au passage suivant
      • i passera à i + 1
      • reponse vaudra reponse * 2 soit 2 ** i * 2 soit 2 ** (i +1). OK
    • Au sortir de la boucle, l’invariant est donc encore respecté et la dernière valeur de i est n donc « reponse vaut 2 ** n » et c’est bien la bonne valeur qu’on renvoie.
    • La correction est donc assurée.

Prouver notre algorithme de dichotomie

On s’appuie sur ce document institutionnel où il est prouvé.

Commentaires.


Et nos tris ?

Et bien pour les deux tris par sélection ou par insertion étudiés :

  • Un variant de boucle est rang initialisée à zéro puis incrémentée et qui ne dépassera pas len(tab). Ceci prouve la terminaison.
  • Un invariant de boucle est

    « les éléments sont triés jusqu’à rang »

    Souvenons-nous que nous l’avions bien souligné (et même encadré en vert). Ceci permet de prouver la correction.

QCM qui était à préparer

Thème A : types de base

Parmi les noms suivants, lequel n’est pas celui d’une méthode d’encodage des caractères ?
Arial
This is the correct answer 🙂
Il s’agit d’une police de caractères, pas d’une méthode d’encodage.
UTF-16
C’est une méthode d’encodage de caractères que nous n’avons pas étudiée où chaque caractère est codé sur une suite de un ou deux mots de 16 bits.
ASCII
La méthode d’encodage de caractères sur laquelle sont basées les autres. Les nouvelles normes comme l’Unicode ou UTF-8 son rétro-compatibles avec l’ASCII.
Unicode
C’est la méthode d’encodage de caractères qui s’est imposée.
Quel est le plus grand entier positif (non signé) représentable en binaire sur 2 octets (c’est-à-dire 16 bits) ?
Le plus grand est
This is the correct answer 🙂
Le bit de poids fort vaut alors , le bit de poids faibles et avec des « 1 » partout, on a . Attention l’énoncé dit « non signé » donc pas de négatifs !
Le plus grand est
C’est le piège dans lequel je suis moi-même tombé : ce serait la bonne réponse pour des entiers signés donc avec des négatifs : de à
Le plus grand est
On sort des 16 bits
Le plus grand est
Quel est le nombre minimum de bits qui permet de représenter les 7 couleurs de l’arc-en-ciel ?
Il faut au moins 3 bits.
This is the correct answer 🙂
Oui avec trois bits, on peut coder :
000 -> 0
001 -> 1
010 -> 2
011 -> 3
100 -> 4
101 -> 5
110 -> 6
111 -> 7
Il faut au moins 2 bits.
Trop peu : avec deux bits, 4 possibilités de zéro à trois.
Il faut au moins 4 bits.
C’est trop !
Il faut au moins 5 bits.
C’est trop !
Quelle est l’écriture en hexadécimal (base 16) du nombre entier positif qui s’écrit 1110 1101 en base 2 ?
ED
This is the correct answer 🙂
1110 donne 14 donc E
1101 donne 13 donc D
DE
Il faudrait 1101 1110 dans cet ordre !
EDF
Il faudrait 1110 1101 1111
FEFD
Non… il faudrait 1111 1110 1111 1101…

Thème B : types construits

Quelle est la valeur de l’expression
[ 2*k + 1 for k in range(4) ]
[1, 3, 5, 7]
This is the correct answer 🙂
C’est une liste en compréhension avec k allant de 0 à 3, donc 2*k allant de 0 à 6 de deux en deux… et on ajoute 1 donc 1, 3, 5, 7
[0, 1, 2, 3]
Non, ce serait par exemple
[ k for k in range(4) ]
[3, 5, 7, 9]
Non, ce serait par exemple
[ 2 * k + 3 for k in range(4) ]
[1, 2, 3, 4]
Non, ce serait par exemple
[ k + 1 for k in range(4) ]
De quelle expression la liste suivante est-elle la valeur ?
[[0,0,0,0], [1,1,1,1], [2,2,2,2]]
[[i] * 4 for i in range(3)]
This is the correct answer 🙂
En effet [0] * 4 donne la liste [0, 0, 0, 0] par exemple… et on s’arrête à 2 puisque c’est range(3).
[[i] * 4 for i in range(4)]
Donnerait
[[0,0,0,0], [1,1,1,1], [2,2,2,2], [3,3,3,3]]
[[i] * 3 for i in range(4)]
Donnerait
[[0,0,0], [1,1,1], [2,2,2], [3,3,3]]
[[i] * 3 for i in range(3)]
Donnerait
[[0,0,0], [1,1,1], [2,2,2]]
On exécute le script suivant :
inventaire = {'pommes': 430, 'bananes': 312,
                    'oranges' : 274, 'poires' : 137}
stock = 0
for fruit in inventaire.keys():
    if fruit != 'bananes':
        stock = stock + inventaire[fruit]
Que contient la variable stock à la fin de cette exécution ?
Elle contient 841.
This is the correct answer 🙂
En effet inventaire est un dictionnaire que l’on parcourt avec ses clés et stock une variable initialisée à zéro. On lui ajoute la valeur correspondant à chaque clé « fruit » qui n’est pas ‘bananes’.
Elle contient 312.
Non, car c’est différent « != » de ‘bananes’.
Elle contient {430, 274, 137}.
Ce sont bien les nombres qu’on ajoute mais cette expression n’a pas de sens en python. On ajoute dans un entier ici.
Elle contient {‘pommes’, ‘oranges’, ‘poires’}.
Non, on ajoute les valeurs. Cette juxtaposition de « clés » n’a pas de sens en python.
On considère le code suivant :
t = [0, 3, 5, 7, 9]
t[9] = 3 + t[5]
Que vaut t à la fin de son exécution ?
L’exécution déclenche une erreur
This is the correct answer 🙂
On veut accéder à t[5] (ou après t[9]) et t contient cinq valeurs indexées de 0 à 4.
t vaut
[0, 3, 5, 7, 9]
t vaut
[0, 3, 5, 7, 9, 3]
t vaut
[0, 3, 5, 7, 9, 8]
On définit la variable suivante :
citation = "Les nombres gouvernent le monde".
Quelle est la valeur de l’expression citation[5:10] ?
citation[5:10] vaut « ombre »
This is the correct answer 🙂
Les lettres de 5 à 10 exclus, donc de la sixième à la dixième.
citation[5:10] vaut « ombres »
Non, citation[5:11] vaut « ombres ».
citation[5:10] vaut « nombre »
Non, citation[4:10] vaut « nombre ».
citation[5:10] vaut « nombres »
Non, citation[4:11] vaut « nombres ».

Thème C : traitement de données en tables

Qu’est-ce qu’un fichier CSV ?
Un format de données
This is the correct answer 🙂
« CSV : Comma Separated Values » : des données séparées par des virgules, par exemple.
une librairie Python permettant l’affichage des images
Non, PIL ou pillow est une libraireie de travail sur les images en python
un format d’image
N’importe quoi : JPG, PNG en sont par contre.
Un utilitaire de traitement d’image
Non, ça c’est Paint, Photofiltre, le GIMP…
Laquelle de ces affirmations est vraie ?
on peut ouvrir un fichier CSV à l’aide d’un tableur
This is the correct answer 🙂
Oui, les valeurs séparées par des virgules seront alors case par case, et ce pour chaque ligne en gros…
un fichier CSV permet de gérer l’apparence du code dans l’éditeur
N’importe quoi 😉
un fichier CSV permet de gérer l’apparence d’une page HTML
Un fichier CSS fait ça, pas un CSV
un fichier CSV contient un programme à compiler
Non, un fichier C peut-être…
On exécute le script suivant :
notes = {"Paul": 12, "Jean": 16, "Clara": 14, "Aïssa": 18}
t = list(notes.keys())
Quelle est la valeur de t à la fin de cette exécution ?
C’est
["Paul", '"Jean", "Clara", "'Aïssa']
This is the correct answer 🙂
Oui, on transfrome en liste avec list les clés du dictionnaire notes.
C’est
Paul
Non, il en manque et c’est dans une liste.
C’est
[12, 16, 14, 18]
Non, ça c’est si on convertit en liste les valeurs notes.values()
C’est
[ "Paul": 12, "Jean": 16, "Clara": 14, "Aïssa": 18 ]
Non ça c’est n’importe quoi.
On a défini deux tables de données :
data1 = [(‘Bruce’, ’Wayne’), (‘Chuck’, ‘Norris’), (‘Bruce’, ‘Lee’), (‘Clark’, ‘Kent’)]
data2 = [(‘Diana’, ’Prince’), (‘Chuck’, ‘Norris’), (‘Peter’, ‘Parker’)]
Quelle instruction permet de construire une table data regroupant l’ensemble des informations de data1 et data2 ?
C’est
data = data1 + data2
This is the correct answer 🙂
Cette question m’a aussi « embrouillé ».
On a bien l’ensemble des informations, même si, grosse vanne… on a deux fois (‘Chuck’, ‘Norris’)
C’est
data == data1 + data2
Non, ça c’est un booléen qui vaut False car on teste si c’est égal.
C’est
data = [element for element in data1 or data2]
Gros piège ! Celle-ci empêcherait-elle les doublons ? Presque… Mais elle plante : le « or » n’a pas de sens.
C’est
data = [data1] + [data2]
Non, puisque data1 et data2 sont déjà des listes.
Qu’est-ce que le format de fichier CSV ?
un format de fichier où les données sont séparées par un caractère tel qu’une virgule
un format de fichier pour décrire une base de données
Non, on en reparlera 😉
un format de fichier mis au point par Microsoft pour Excel
Non, c’est par exemple XLS
un format de fichier décrivant une page Web
Non, pour les pages web, on utilise de fichiers HTML ou CSS
On a extrait les deux premières lignes de différents fichiers.
Déterminer celui qui est un authentique fichier CSV :
Nom,Pays,Temps
Camille Muffat,France,241.45
This is the correct answer 🙂
Trois valeurs séparées par des virgules et la première ligne contient le nom des « champs ».
Nom Pays Temps
Camille Muffat France 241.45
Manquent les virgules ou les points-virgules !
{ « Nom »: « Camille Muffat », « Pays »: « France », « Temps »: 241.45}
Ici un dictionnaire avec des clés.
{ Nom: « Camille Muffat », Pays: « France », Temps: 241.45}
N’importe quoi

Thème F : langages et programmation

étant un entier strictement positif, la fonction suivante calcule sa factorielle, c’est-à-dire le produit
Comment faut-il écrire la ligne en pointillée ci-dessous pour ce faire ?
def factorielle(n):
    f = 1
    .........
        f = f * i
    return f
Il faut écrire dans les pointillés
for i in range(1, n+1):
This is the correct answer 🙂
On multiplie bien f par tous les entiers de 1 à n. ON peut même faire mieux avec
for i in range(2, n+1):
Il faut écrire dans les pointillés
for i in range(1, n):
On n’aura pas multiplié par , le range s’arrêterait juste avant
Il faut écrire dans les pointillés
for i in range(0, n):
Là on va multiplier par zéro et le résultat fera zéro.
Il faut écrire dans les pointillés
for i in range(n+1):
Là on va multiplier par zéro et le résultat fera zéro.
On exécute le script suivant :
a = 4
b = 4
c = 4
while a < 5:
    a = a - 1
    b = b + 1
    c = c * b
Que peut-on dire ?
ce programme ne termine pas
This is the correct answer 🙂
En effet la terminaison est assurée quand a dépasse ou atteint 5, mais a est initialisé à 4 et décroît. On « boucle » indéfiniment.
à la fin de l’exécution, la variable a vaut 5
Non 4, 3, 2, 1, 0, -1 … et pas de fin !
à la fin de l’exécution, la variable b vaut 34
à la fin de l’exécution, la variable c vaut 42
Non, même si on kiffe le 42 😉
On souhaite écrire une fonction qui renvoie le maximum d’une liste d’entiers :
def maximum(L):
    m = L[0]
    for i in range(1,len(L)):
        if .........:
            m = L[i]
    return m
Par quoi faut-il remplacer les pointillés pour que cette fonction produise bien le résultat attendu ?
Par L[i] > m
This is the correct answer 🙂
Si ce test est réalisé, on doit changer le maximum m.
Par L[i] > L[i-1]
Non, rien à voir avec l’indice avant.
Par L[i] > L[i+1]
Non, rien à voir avec l’indice après. En plus ça plante à la fin.
Par i > m
Non, ici i est l’indice et c’est la valeur L[i] qui nous intéresse.
Quel est le seul langage de programmation parmi les propositions suivantes ?
C++
This is the correct answer 🙂
Oui, même si on ne l’a pas étudié !
CSS
Langage de style de pages web.
HTML
Langage de contenu de pages web.
WEB
Pas un langage à ma connaissance.
La fonction suivante calcule la racine carrée du double d’un nombre flottant.
from math import sqrt

def racine_du_double(x):
    return sqrt(2*x)
Quelle est la précondition sur l’argument de cette fonction ?
C’est x >= 0.
This is the correct answer 🙂
Il faut un positif (ou nul) pour une racine carrée.
C’est x < 0
Non, le contraire.
C’est 2 * x > 0.
On peut aussi avoir x == 0 qui ne serait pas accepté.
C’est sqrt(x) >= 0
Non, la condition est sur x et pas sur la racine de x.
La fonction maxi ci-dessous a pour but de renvoyer la valeur maximale présente dans la liste qui lui est passée en argument.
def maxi(L):
    dernier_indice = len(L) - 1
    valeur_max = L[0]
    for i in range(1,dernier_indice):
        if L[i] > valeur_max:
            valeur_max = L[i]
    return valeur_max
Cette fonction a été mal programmée. On souhaite réaliser un test pour le démontrer.
Parmi les propositions suivantes, laquelle mettra la fonction maxi en défaut ?
C’est
maxi([1, 2, 3, 4])
This is the correct answer 🙂
En effet le maximum est au dernier indice et on ne teste pas cette valeur avec le range là-haut
C’est
maxi([4, 3, 2, 1])
On aura l’impression que c’est correct car le maximum n’est pas au dernier indice.
C’est
maxi([1, 3, 3, 2])
On aura l’impression que c’est correct car le maximum n’est pas au dernier indice.
C’est
maxi([1, 1, 1, 1])
On aura l’impression que c’est correct car le maximum n’est pas forcément au dernier indice, on le rencontre avant.

Thème G : algorithmique

Quelle est la valeur de c à la fin de l’exécution du code suivant :
L = [1,2,3,4,1,2,3,4,0,2]
c = 0
for k in L:
    if k == L[1]:
        c = c+1
3
This is the correct answer 🙂
C’est le nombre de fois où l’on rencontre 2 en parcourant la liste puisque L[1] vaut 2.
0
2
10
Que renvoie la fonction suivante quand on l’appelle avec un nombre entier et une liste d’entiers ?
def mystere(n,L):
    for x in L:
        if n == x:
            return True
    return False
une valeur booléenne indiquant si le nombre n est présent au moins une fois dans la liste L
une valeur booléenne indiquant si le nombre n est présent plusieurs fois dans la liste L
une valeur booléenne indiquant si le nombre n est le plus grand de la liste L
une valeur booléenne indiquant si le nombre n est le plus petit de la liste L
La fonction mystere suivante prend en argument un tableau d’entiers.
def mystere(t):
    for i in range(len(t) - 1):
        if t[i] + 1 != t[i+1]:
            return False
    return True
si le tableau passé en argument est une suite d’entiers consécutifs
si le tableau passé en argument est trié en ordre croissant
si le tableau passé en argument est trié en ordre décroissant
si le tableau passé en argument contient des entiers tous identiques
On exécute le script suivant :
liste=[48, 17, 25 , 9, 34, 12, -5, 89, 54, 12, 78, 8, 155, -85]

def recherche(liste):
    valeur_1 = valeur_2 = liste[0]
    for item in liste:
        if item < valeur_1:
            valeur_1 = item
        elif item > valeur_2:
            valeur_2 = item
        else:
            pass
    return (valeur_1, valeur_2)
Que va renvoyer l’appel
recherche(liste) ?
C’est (-85, 155).
This is the correct answer 🙂
C’est un couple composé du minimum et du maximum.
C’est (155, -85).
C’est [-85, 155].
C’est [155, -85].
Un algorithme de recherche dichotomique dans une liste triée de taille nécessite, dans le pire des cas, exactement comparaisons.
Combien cet algorithme va-t-il utiliser, dans le pire des cas, de comparaisons sur une liste de taille ?
comparaisons au pire des cas.
This is the correct answer 🙂
Ben oui, après un coup, on se retrouve avec une moitié de éléments et donc au pire encore comparaisons, donc au pire en tout.
comparaisons au pire des cas.
comparaisons au pire des cas.
comparaisons au pire des cas.
On considère la fonction suivante :
def f(x,L):
    i = 0
    j = len(L)-1
    while i<j:
        k = (i+j)//2
            if x <= L[k]:
                j = k
            else:
                i = k + 1
    return i
Cette fonction implémente :
la recherche dichotomique
This is the correct answer 🙂
Oui, à une petite différence de celui vu en cours :
ici i est la variable de gauche,
j celle de droite,
k le milieu,
si le nombre est à gauche, j devient k (contre k-1 dans notre cours),
si le nombre est à droite, i devient k + 1 (comme dans notre cours). Par ailleurs, ce code renvoit toujours un indice du tableau, donc on présuppose certainement que la valeur est dans le tableau !
le tri par insertion
le tri par sélection
la recherche du plus proche voisin

Samedi 28 mars – orthogonalité entre deux droites de l’espace

Bonjour.

 

D’abord, la correction des exercices donnés hier.

Appréciez l’efficacité du produit scalaire pour démontrer qu’un triangle est rectangle…

 

Ensuite on démarre la deuxième grande partie du chapitre : l’orthogonalité dans l’espace; on commence par celle entre deux droites dans la suites du cours.

 

C’est assez simple, faites juste bien attention à intégrer tout de suite la nuance entre « orthogonales » et « perpendiculaires ».

 

Pour lundi :

  • exercice 2 page 339. Vous rajouterez une question 3 : les droites d et d’ de la question 2 sont-elles perpendiculaires ?
  • sur cette feuille, traitez la question 1.

 

Bon week-end !

 

Samedi 28 mars – quelques propriétés simples des intégrales

Bonjour.

 

Commençons par corriger ici les exercices 7 page 121 et 52 à 55 page 133 sur les intégrales.

 

Les techniques d’encadrement par des rectangles (ou par d’autres figures parfois plus précises comme des trapèzes) sont importantes, donc vérifiez bien que vous comprenez l’exercice 7 page 121.

 

On poursuit un tout petit peu le premier paragraphe du cours avec quelques propriétés très simples.

 

Pour mardi : exercices 57 et 58 page 133 et un dernier entrainement sur les calculs simples d’intégrales :

  • \int_{-10}^{10} 7 \mathrm{d}x
  • \int_{-2}^{2,5} (5-2x) \mathrm{d}x
  • \int_2^8 (2x-1) \mathrm{d}x

 

Bon week-end.