Exos Complet 1 e

Première NSI - Exercices
Table des matières
1 Introduction à Python - Série 1 2
2 Introduction à Python - Série 2 5
3 Représentation des nombres entiers naturels 7
4 Listes - Série 1 9
5 Listes - Série 2 11
6 Tuples et ensembles 13
7 Représentation des entiers relatifs 15
8 Chaînes de caractères 16
9 Sites web statiques - HTML et CSS 18
10 Fichiers 21
11 Algorithmes de recherche séquentielle et de tri 24
12 Dictionnaires 26
13 Circuits logiques 28
14 Sites web statiques - Javascript 30
15 Algorithmes de recherche dichotomique 33
16 Représentation des caractères et des nombres réels 35
17 Traitement de données en tables 37
18 Système d’exploitation Linux 42
19 Exercices variés Python - Série 1 46
20 Réseaux 48
21 Algorithmes gloutons 51
23 Assembleur 56
24 Algorithmes kNN 60
26 Réseaux - Filius 65
27 Sites web dynamiques et PhP 68
Première NSI - Lycée Descartes - V. de Clippel 1

Introduction à Python - Série 1
Exercice 1.1 (Console 1) Observer et analyser les résultats obtenus dans la console.
>>> 11/4 >>> 11%4

2.75 3
>>> 11//4 >>> type (1/7)
2 < class ' float ' >
Exercice 1.2 (Console 2) Observer les résultats obtenus dans la console.
>>> a = 3 >>> b = a /7
>>> type ( a ) >>> b
< class ' int ' > 0.42857142857142855
>>> alpha = float ( a ) >>> c = 14* b
>>> alpha >>> c
3.0 6.0
>>> type ( alpha ) >>> gamma = int ( c )
< class ' float ' > >>> gamma
6
1) Quelle est la différence entre les variables a et alpha ?

2) Quel est le type de c ? Comment l’expliquez-vous ?
3) Quel est le type de gamma ?
>>> a , b = 2 , 5
>>> print ( " Somme = " , a + b )
Somme = 7
>>> print ( " Le p r o d u i t de " ,a , " par " ,b , " vaut : " , a * b )
Le p r o d u i t de 2 par 5 vaut : 10
>>> msg = " b o n j o u r "
>>> msg2 = ' tout le monde '
>>> msg + msg2
' b o n j o u r tout le monde '
1) Quel est le type de la variable msg ? Comment vérifie-t-on cela ?

2) Que réalise l’opérateur + sur les chaînes de caractères ?
Exercice 1.4 (Console 4) On a tapé les instructions suivantes dans la console. Compléter.
# Bloc 1 # Bloc 2 # Bloc 3 # Bloc 4

>>> a , b = 5 , 8.5 >>> a = 3 >>> a , b = 5 , 7 >>> a , b = 5 , 7
>>> 2 <= a and a < 6.5 >>> a += 2 >>> a = b >>> b = a
... >>> a >>> b = a >>> a = b
>>> a %2 == 0 or b < 4 ... >>> a >>> a
... >>> a *= 2 ... ...
>>> not ( a %2 == 0) >>> a >>> b >>> b
... ... ... ...
>>> a > b >>> b - a == 2
... ...

Exercice 1.5 (Console 5) On considère les instructions suivantes.
1 a, b = 5, 2 a b
2 a = a + 1 1
3 b = a + 1
4 b += 1 2
5 a, b = b, a 3
6 a = b
4
5
6
1) Sans taper les instructions, remplir le tableau ci-dessus avec les valeurs prises par a et b.
2) Par quoi aurait-on pu remplacer la ligne 4 pour avoir le même effet ?
3) Quelle est l’effet de l’instruction a, b = b, a ? Par quelles instructions aurait-on pu remplacer
cette instruction ?
Exercice 1.6 (Range) On considère les programmes suivants.

Qu’obtient-on après leur exécution ?
# Programme 1 # Programme 2 # Programme 3

for i in range (8) : for a in range (3 ,10): for pair in range (80 ,90 ,2):
print ( i ) print (a , end = " " ) print ( pair )
Exercice 1.7 (Différence entre if et while) On considère les deux programmes suivants.
# Programme 1 # Programme 2
a = 7.5 a = 7.5
if a > 3 : while a > 3 :
a = a -1 a = a -1
Dans chaque cas, que vaut a après l’exécution ?
Exercice 1.8 (Trier deux valeurs) Ecrire une fonction afficheValeur qui prenne en entrée
deux valeurs a et b et affiche la plus petite puis la plus grande.
Exercice 1.9 (Bonjour) Ecrire une fonction afficheBonjour qui prenne en entrée un entier
monChoix et affiche "Bonjour Monsieur" si la valeur entrée est 0, "Bonjour Madame" si la valeur
entrée est 1 et "Bonjour" si la valeur est autre.
Exercice 1.10 (Année bissextile)

1) Ecrire une fonction booléenne (elle doit renvoyer False ou True) estBissextile qui permet de
tester si une année est bissextile. On rappelle qu’une année est bissextile si elle est divisible par
4, mais pas divisible par 100, sauf si elle est divisible par 400.
Ainsi 1900 n’était pas une année bissextile alors que 2000 l’était.
2) Ecrire la même fonction en utilisant uniquement des opérations logiques (sans instructions condi-
tionnelles).
Exercice 1.11 (Plein d’étoiles) Ecrire une fonction triangleEtoile qui prend comme paramètre
un nombre entier naturel n et qui affiche le résultat ci-contre quand on exécute TriangleEtoile(5) :
*
**
***
****
*****

Exercice 1.12 (Somme) Ecrire une fonction sommePremiersEntiers qui calcule la somme des
nombres de 1 à n. Ecrire une version avec une boucle for et une autre avec une boucle while.
Que renvoie sommePremiersEntiers(100) ?
Exercice 1.13 (Positionnement tortue) Taper le programme suivant et interpréter les lignes
de code en fonction de l’affichage.
from turtle import *
def p o s I n i t () :
setup (900 ,600)
fd (100)
e x i t o n c l i c k ()
p o s I n i t ()
Exercice 1.14 (Triangle) Ecrire un programme qui trace un triangle équilatéral.

Introduction à Python - Série 2
Exercice 2.1 (Multiples) Ecrire la fonction multipleOuPas qui affiche pour un nombre entier
positif nb, l’un des messages suivants :
• "Ce nombre est pair"
• "Ce nombre est impair, mais est multiple de 3"
• "Ce nombre n’est ni pair ni multiple de 3"
Exercice 2.2 (Des nombres) Observer ce que l’on obtient à la console si on exécute le code
suivant.
for d in range (10) :
for u in range (10) :
n = 10* d + u
print ( n )
Remplacer l’instruction print(n) par print(n, end='') puis par print(n, end='-'). Observer chaque
fois le résultat à la console.
Exercice 2.3 (Tables) Ecrire un programme qui affiche les tables de multiplications de 1 à 10.
Indication : utiliser une boucle imbriquée comme dans l’exercice précédent.
Exercice 2.4 (Seuil 1) On place un capital de 500 euros sur un compte rémunéré à 3% par
an. L’algorithme ci-dessous permet de calculer le nombre d’années au bout duquel le capital sera
doublé. Le programme traduisant cet algorithme comprend des erreurs. Corriger les erreurs.
Fonction double() def double () :

somme ← 500 somme = 500
nbAnnees ← 0 nbAnnees = 0
Tant que somme < 1000 While somme < 1000
somme ← 1,03 × somme somme = 1.03* somme
nbAnnees ← nbAnnees + 1 n b A n n e e s = n b A n n e e s +1
Fin Tant que return ( n b A n n e e s)
Fin
Qu’obtient-t-on si on tape double() à la console ?
Exercice 2.5 (Evolution d’un capital 1) Une somme de 2000 euros est déposée sur un compte
rémunéré au taux annuel de 2 %.
1) Ecrire un script affichant la somme disponible sur le compte au bout de 20 ans.

2) Comment modifier ce script pour que l’on puisse afficher la somme disponible au bout de n’im-
porte quelle durée en années ?
3) Comment modifier ce script pour qu’il puisse fonctionner avec n’importe quelle somme, n’im-
porte quel taux et n’importe quelle durée en années ?
Exercice 2.6 (Evolution d’un capital 2) Une somme de 2000 euros est déposée sur un compte
rémunéré au taux annuel de 2 %.
1) Ecrire un script affichant le nombre d’années au bout duquel le compte atteindra 3000 euros.
2) Comment modifier ce script pour qu’il puisse fonctionner avec n’importe quelle somme initiale,
n’importe quel taux et n’importe quelle somme finale attendue ?
Exercice 2.7 (Factorielle) Ecrire une fonction qui, à partir d’un nombre de départ, calcule sa
factorielle.
Remarque : factorielle 8, notée 8 !, vaut 1 × 2 × 3 × 4 × 5 × 6 × 7 × 8.

Exercice 2.8 (Hasard 1)
1) Tester
from random import r a n d i n t
print ( r a n d i n t (1 ,3) )
2) On lance un dé à 6 faces. Ecrire une fonction de5 qui renvoie True si la valeur du dé est 5, False
sinon.
Exercice 2.9 (Double 6) On lance deux dés équilibrés à six faces numérotées de 1 à 6. Ecrire
une fonction renvoyant le nombre de lancers nécessaires pour obtenir un double six.
Exercice 2.10 (Hasard 2) On choisit au hasard une carte dans un jeu classique de 32 cartes. Si
la carte est un as, on s’arrête ; sinon, on remet la carte dans le paquet et on recommence... Ecrire
un programme simulant cette expérience et renvoyant le nombre de tirages nécessaires pour obtenir
un as pour la première fois.
Exercice 2.11 (Supérieur à 10) Est-il possible de trouver un (ou des) entier(s) n tels que :
1 1 1 1
+ + + ... + > 10 ?
1 2 3 n
Ecrire un algorithme puis l’implémenter en Python.
Exercice 2.12 (Tracé) Taper le programme suivant et interpréter les lignes de code en fonction
de l’affichage.
1 from turtle import *

2 def e x e m p l e T r a c e () :
3 setup (900 , 600)
4 up () ; s e t h e a d i n g (90) ; goto (0 , -300) ; down ()
5 color ( ' yellow ')
6 goto (0 , 300)
7 up () ; goto ( -175 , 0) ; down ()
8 color ( ' blue ' , ' blue ')
9 b e g i n _ f i l l () ; circle (50) ; e n d _ f i l l ()
10 up () ; goto (275 , 0) ; down ()
11 color ( ' red ' , ' green ')
12 b e g i n _ f i l l () ; circle (50) ; e n d _ f i l l ()
13 e x i t o n c l i c k ()
14
15 e x e m p l e T r a c e ()
Exercice 2.13 (Figures géométriques) On travaille dans une fenêtre graphique de taille
600×600.
1) Ecrire un programme permettant de tracer un carré de côté 100 avec la tortue.

2) Modifier le programme précédent pour tracer un pentagone régulier de côté 50.
3) Améliorer encore votre programme en écrivant une fonction PolygoneReg prenant en entrée le
nombre de côtés et leur longueur afin de tracer un polygone régulier.

Représentation des nombres entiers naturels
Exercice 3.1 (Conversions 1) Convertir en base 10 :

(127)8 (2A9)16 (110101)2
Exercice 3.2 (Conversions 2)

1) Convertir en binaire sur 8 bits puis en hexadécimal (sur 2 caractères) le nombre en base 10
suivant : (67)10 .
2) Convertir le nombre hexadécimal suivant (F E)16 en base 10 puis en base 2.
3) Combien peut-on coder d’entiers naturels sur 8 bits ? Donner l’intervalle de valeur correspondant
(en base 10).
Exercice 3.3 (Conversions 3) Convertir les nombres suivants

1) en binaire : 25 0x3B9
2) en décimal : 0x50 0b101110101
3) en hexadécimal : 0b100000101 1024 50 283
Exercice 3.4 (Conversions 4) Convertir les nombres suivants :

916 en base 16 317 en base 2
Exercice 3.5 (Opérations 1) Effectuer les opérations suivantes en binaire :

1100011 + 11001 1000000 + 1111111 1101 × 101
Exercice 3.6 (Multiplication par 2)

1) Effectuer la multiplication en base binaire de 15 × 2.
2) Comment passer d’un nombre binaire à sa valeur multipliée par 2 ?
Exercice 3.7 (Opérations 2) Effectuer les opérations suivantes en binaire et vérifier les résultats
en procédant aux conversions nécessaires.
1001 + 1011 1+1+1+1
Exercice 3.8 (Opérations 3) Effectuer les opérations suivantes en binaire et vérifier les résultats
en procédant aux conversions nécessaires.
1011 × 11 1100 × 101 100111 × 110
Exercice 3.9 (Couleurs) Compléter le tableau ci-dessous.
Composants (rouge vert bleu)

Nom de couleur
hexadécimal décimal
Fuchsia 255 0 255
Gold FF D7 00
Chocolate 210 105 30
Beige F5 F5 DC
ForestGreen 34 139 34

Exercice 3.10 (Vrai ou faux ?) Dans chacun des cas suivants, donner la valeur du booléen rep.
1) rep = not True
2) rep = True or False
3) rep = True and False
4) rep = 5<3 and 5>3
5) rep = 5<3 or 5>3
6) x = -4
rep = x**2 == -16
7) x, y, z = 3, 4, 5
rep = x**2 + y**2 == z**2
8) a, b = 3, -7
rep = a**3 > 50 and b**2 < 50
9) a, b = 3, -7
rep = (a**3 > 50 and b**2 < 50)or (a**2 < 10 and b**2 > 10)
Exercice 3.11 (Loi mystère) Soient a et b deux booléens. On définit la loi Mystere telle que
a Mystere b = (a or b)and not(a and b)
1) Compléter la table de vérité de la loi Mystere :
b
0 1
a
0
1
Indication : il est utile de s’aider d’une table plus détaillée :
a b a or b a and b not (a and b) (a or b) and not(a and b)
0 0
0 1
1 0
1 1
2) Que se cache-t-il derrière la loi Mystere ?

Listes - Série 1
Exercice 4.1 (Console) Observer les résultats obtenus dans la console.
>>> L =[1 , -2 ,3 ," rer " ] >>> list1 =2*[ 'a ']
>>> len ( L ) >>> list1 . append (3.0) # ajout d ' une valeur
4 >>> list1
>>> L [0] [ 'a ' , 'a ' , 3.0]
1 >>> range (0 ,10)
>>> L [2] range (0 , 10)
3 >>> list ( range (10) ) # d é f . par t r a n s t y p a g e
>>> L [ -1] [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9]
' rer ' >>> list ( range (2 ,8) )
>>> 'a ' in L [2 , 3 , 4 , 5 , 6 , 7]
False >>> list ( range (1 ,15 ,2) )
>>> type ([1 ,2 ,3]) [1 , 3 , 5 , 7 , 9 , 11 , 13]
< class ' list ' > >>> list ( range (5 , -1 , -1))
>>> [1 ,2 ,3]==[1 ,3 ,2] [5 , 4 , 3 , 2 , 1 , 0]
False >>> l I m p a i r s = [2* k +1 for k in range (5) ]
>>> [1 ,2 ,3]+[4 ,5] >>> l I m p a i r s
[1 , 2 , 3 , 4 , 5] [1 , 3 , 5 , 7 , 9]
Exercice 4.2 (Parcours) Exécuter les codes suivants et observer les résultats.
def a f f i c h e L i s t e E l ( L ) : def a f f i c h e L i s t e I n d ( L ) :
""" P a r c o u r s sur les é l é ments """ """ P a r c o u r s sur les i n d i c e s """
for elem in L : for k in range ( len ( L ) ) :
print ( elem ) print ( k , L [ k ])
>>> L = [ 'a ' ,1 ,2.5 ," b o n j o u r" ] >>> L = [ 'a ' ,1 ,2.5 ," b o n j o u r" ]
>>> a f f i c h e L i s t e E l ( L ) >>> a f f i c h e L i s t e I n d ( L )
Exercice 4.3 (De 1 à 6) Le but de cet exercice est de générer la liste L des entiers de 1 à 6 de 3
manières différentes :
1) par compréhension ;
2) grâce à une fonction creeListeEntiers1 qui prend comme paramètre un nombre entier naturel
n > 0. Cette fonction pourra utiliser l’opérateur + ;
3) grâce à une fonction creeListeEntiers2 qui prend comme paramètre un nombre entier naturel
n > 0. Cette fonction pourra utiliser la méthode append.
Exercice 4.4 (Les carrés maintenant) Mêmes consignes qu’à l’exercice précédent pour générer
la liste des carrés des nombres de 1 à 6.
Exercice 4.5 (Les jours de la semaine) Ecrire une fonction jourSemaine qui prenne en entrée
un entier i et retourne le i-ème jour de la semaine (si l’on fournit la valeur 2 en entrée à cette
fonction, elle devra donc retourner "Mardi").
Remarque : il est demandé de ne pas utiliser de structure conditionnelle.
Exercice 4.6 (Jeu de dés) On lance un dé. Si le numéro est 1, 5 ou 6, alors c’est gagné, sinon
c’est perdu. Ecrire un programme simulant ce jeu en utilisant une liste.

Exercice 4.7 (Listes par compréhension) Exécuter le code suivant et essayer de comprendre
le résultat.
Nb1 = [10 ,20 ,30 ,40]
Nb2 = [50 ,60 ,70 ,80]
liste1 = [2* Nb1 [ i ] for i in range ( len ( Nb1 ) ) ]
liste2 = [2* Nb1 [ i ] for i in range ( len ( Nb1 ) ) if i !=2]
liste3 = [3* Nb1 [ i ] -1 for i in range ( len( Nb1 ) ) ]
liste4 = [3*i -1 for i in range ( len ( Nb1 ) ) ]
liste5 = [ Nb1 [ i ]==20 for i in range ( len( Nb1 ) ) ]
liste6 = [ Nb1 [ i ]+ Nb2 [ i ] for i in range ( len ( Nb1 ) ) ]
liste7 = [ e l e m e n t +5 for e l e m e n t in Nb2 ]
liste8 = [ e l e m e n t > 60 for e l e m e n t in Nb2 ]
liste9 = [ Nb2 [ i ] for i in range ( len ( Nb1 ) ) if Nb1 [ i ] >25]
print ( " liste1 : " , liste1 )


Listes - Série 2
Exercice 5.1 (Listes par compréhension) Dans cet exercice, les listes sont des listes d’entiers.
1) Ecrire une fonction puissance(liste,k) qui élève chaque élément de liste à la puissance k. Par
exemple puissance([1,2,3,4,5],3) renvoie [1,8,27,64,125].
2) Ecrire une fonction addition(liste1,liste2) qui additionne terme à terme les éléments de deux
listes de même longueur. Par exemple addition([1,2,3],[5,6,7]) renvoie [6,8,10].
3) Ecrire une fonction nonZero(liste) qui renvoie la liste de tous les éléments non nuls. Par exemple
nonZero([7,0,2,3,0,4,9,0]) renvoie [7,2,3,4,9].
4) Ecrire une fonction pairs(liste) qui renvoie la liste de tous les éléments pairs. Par exemple
pairs([1,0,6,7,0,4,5,0]) renvoie [0,6,0,4,0].
Exercice 5.2 (Listes aléatoires)

1) Ecrire une fonction listAleaInt(n, min, max) qui fabrique une liste de n nombres entiers natu-
rels compris entre min et max de façon aléatoire (utiliser les fonctions du module random).
2) Même consigne pour une fonction listAleaNum(n, min, max) mais avec des flottants.
On veillera à coder ces fonctions en une ligne.
Exercice 5.3 (Mélange) Ecrire une fonction mix mélangeant les éléments d’une liste. On pourra
la tester en lui demandant de mélanger la liste des 20 premiers entiers.
Exercice 5.4 (Coïncidences)

1) Ecrire une fonction nbValIndId qui renvoie le nombre de fois où deux listes ont des valeurs
identiques aux mêmes indices.
Ainsi par exemple, si L1 = [3, 55, 20, 55, 24, 55] et L2 = [6, 55, 3, 14, 24, 55],
nbValIndId(L1,L2) doit renvoyer 3 car les éléments sont les mêmes aux indices 1, 4 et 5.
2) **Difficile** Ecrire une fonction nbValId qui renvoie une liste (triée par ordre croissant) avec les
valeurs communes à deux listes de même longueur et le nombre de fois où cela se produit.
Ainsi par exemple, si L1 = [3, 55, 20, 55, 24, 55] et L2 = [6, 55, 3, 14, 24, 55],
nbValId(L1,L2) doit renvoyer [3, 24, 55, 55],4.
3) **Difficile** Ecrire une fonction coincidence qui renvoie une liste des valeurs communes à
deux listes et des indices correspondants dans chaque liste, et calcule alors la proportion de
coïncidences arrondie à 2 chiffres après la virgule (proportion des éléments qui ont la même
valeur et le même indice dans les deux listes par rapport au nombre total d’éléments des listes).
Ainsi par exemple, si L1 = [3, 55, 20, 55, 24, 55, 3] et L2 = [6, 55, 3, 14, 24, 55, 6],
coincidence(L1,L2) doit renvoyer [[3,0,2], [24,4,4], [55,1,1], [55,5,5]], 0.43.
4) Tester plusieurs fois la fonction coincidence avec deux listes aléatoires de 50 entiers naturels
compris entre 0 et 20.
5) Tester plusieurs fois la fonction coincidence avec la liste des 20 premiers entiers et cette même
liste mélangée avec la fonction mix de l’exercice "Mélange".
Exercice 5.5 (Différences) Ecrire une fonction nbIndicesDifferents(tab1,tab2) qui prend en

paramètres deux listes, que l’on supposera de même taille, et qui renvoie le nombre d’indices
auxquels les deux listes diffèrent.

Exercice 5.6 (Avec matplotlib)
1) Construire aléatoirement une liste listeVal de 10 000 entiers compris entre 0 et 10.
2) Construire une liste listeEff de 11 éléments constituée du nombre d’occurrences des entiers
variant de 0 à 10 dans listeVal. Les effectifs seront rangés à l’index correspondront à la valeur
concernée.
3) Tester le code Python suivant :
import m a t p l o t l i b. pyplot as plt
l i s t e F r e q = [ elem /100 for elem in l i s t e E f f]

plt . title ( " Fr é q u e n c e s simul é es " )
plt . ylabel ( " Fr é quence en p o u r c e n t a g e " )
plt . xticks ( list ( range (0 ,11)) , list ( range (0 ,11)) )
plt . yticks ( list ( range (0 ,101 ,10)) )
plt . bar ( list ( range (11) ) , l i s t e F r e q )
plt . show ()

Tuples et ensembles
Exercice 6.1 (Console tuple) Observer les résultats obtenus dans la console.
>>> tuple1 = () # tuple vide

>>> tuple2 = (1 , " b o n j o u r" ,7.6) # D é f i n i t i o n par e x t e n s i o n
>>> tuple2
(1 , ' b o n j o u r ' , 7.6)
>>> tuple3 = 3.14 , ' pi ' # D é f i n i t i o n par e x t e n s i o n
>>> tuple3
(3.14 , ' pi ')
>>> t4 = tuple ( k **2 for k in range (5) ) # D é f . par compr é h e n s i o n
>>> t4
(0 , 1 , 4 , 9 , 16)
>>> tuple ( " rer " ) # D é f i n i t i o n par t r a n s t y p a g e
( 'r ' , 'e ' , 'r ')
>>> tuple5 = tuple ( range (6) )
>>> tuple5
(0 , 1 , 2 , 3 , 4 , 5)
>>> 4 in tuple ( range (4) ) # Test d ' a p p a r t e n a n c e
False
>>> (1 ,2 ,3 ,4) == tuple ( range (4) )
False
>>> m o n T u p l e = tuple ( range (1 ,4) ) + (1 , 'a ' ,3.7)
>>> m o n T u p l e
(1 , 2 , 3 , 1 , 'a ' , 3.7)
>>> m o n T u p l e [4]
'a '
>>> len ( m o n T u p l e)
6
>>> m o n T u p l e [4] = 3 # erreur - non m o d i f i a b l e
T y p e E r r o r : ' tuple ' object does not s u p p o r t item a s s i g n m e n t
Exercice 6.2 (Console set) Observer les résultats obtenus dans la console.
>>> set1 = set () # e n s e m b l e vide

>>> set2 = {1 , 'a ' ,2 ,1 , 'a ' ,2 , 'a '} # D é f i n i t i o n par e x t e n s i o n
>>> set2
{1 , 2 , 'a '}
>>> set3 = set ( k **2 for k in range (4) ) # D é f . par compr é h e n s i o n
>>> set3
{0 , 1 , 9 , 4}
>>> S = set ( " abcd " ) # D é f i n i t i o n par t r a n s t y p a g e
>>> S
{ 'd ' , 'c ' , 'a ' , 'b '}
>>> set6 = set ( range (6) )
>>> set6
{0 , 1 , 2 , 3 , 4 , 5}
>>> 'B ' in set ( " b o n j o u r" )
False
>>> {1 ,3 ,2 ,2 ,1 ,1 ,3 ,3} == {3 ,2 ,1}
True
>>> len ({1 ,3 ,2 ,2 ,1 ,1 ,3 ,3})
3

Exercice 6.3 (Somme) Ecrire la fonction sommeT qui prend en paramètre un tuple et renvoie la
somme des carrés de ses éléments.
Par exemple, sommeT((3,2,4)) doit renvoyer 29.
Il est demandé d’utiliser un parcours par éléments.
Exercice 6.4 (Croissant) Ecrire la fonction verifCroissant qui prend en paramètre un tuple et
renvoie True si le tuple est trié par ordre croisssant et False sinon.
Par exemple, sommeT((3,2,4)) doit renvoyer False.
Il est demandé d’utiliser un parcours par indices.
Exercice 6.5 (Parcours set) On demande d’écrire les instructions suivantes :

• créer un ensemble ens1 avec comme éléments : 'banane', 'fraise' et 'pamplemousse',
• ajouter l’élément 'kiwi',
• supprimer l’élément 'banane',
• faire un parcours sur les éléments de l’ensemble ens1 pour les afficher.
Exercice 6.6 (Tables de multiplication) Ecrire une fonction table(n) renvoyant un tuple
composé des 10 premiers multiples de n.
Exercice 6.7 (Liste triée sans doublon) On se donne une liste maListe d’entiers quelconques,
certains d’entre eux étant présents en plusieurs exemplaires. Ecrire, en une seule ligne, l’instruction
permettant de supprimer les doublons et de trier cette liste.
Exercice 6.8 (Plusieurs informations) Ecrire une fonction minMaxMoy qui reçoit une liste d’en-
tiers et qui renvoie le minimum, le maximum et la moyenne de cette liste.
Que renvoie minMaxMoy([10, 17, 14, 22, 12, 15]) ?
Exercice 6.9 (Distance) Ecrire une fonction distance qui, étant donnés deux points
(x1,y1) et (x2,y2) reçus en paramètres sous forme de tuples, calcule et renvoie la distance eucli-
dienne entre ces deux points.
Rappel : la distance entre deux points de coordonnées (x1 ; y1 ) et (x2 ; y2 ) est donnée par :
q
(x2 − x1 )2 + (y2 − y1 )2
Exercice 6.10 (Décodage) On se donne une liste qui encode une séquence t. Chaque élément
de cette liste est un tuple de deux éléments : le nombre de répétitions successives de l’élément x
dans t, et l’élément x lui-même. Les éléments successifs répétés forment la séquence t. Ecrire une
fonction decompresse, qui reçoit une telle liste en paramètre et renvoie la séquence t sous forme
d’une nouvelle liste.
Exemple :
>>> m a L i s t e = [(4 ,1) , (2 ,2) , (2 , ' test ') , (3 ,3) , (1 , ' b o n j o u r ') ]
>>> d e c o m p r e s s e( m a L i s t e)
[1 , 1 , 1 , 1 , 2 , 2 , ' test ' , ' test ' , 3 , 3 , 3 , ' b o n j o u r ']

Représentation des entiers relatifs
Exercice 7.1 (Représentation en complément à 2)

1) Quelle est la valeur décimale de chacun des nombres binaires suivants (représentés sur 8 bits) :
00001010 11110011
2) Calculer l’opposé des entiers suivants (codés en binaire sur 8 bits) :
01011010 11100000
Exercice 7.2 (Entiers relatifs) Soit le nombre binaire A codé sur 5 bits : A = (01110)2 .
1) Effectuer le complément à 2 de A.
2) Quelle est la valeur en base 10 de A ? Quelle est la valeur en base 10 du complément à deux de
A.
3) Effectuer la somme (en numération binaire) du nombre A et de son complément à deux.
4) Les nombres entiers relatifs sont maintenant codés sur 6 bits. Après avoir codé en binaire (−18)10
et (12)10 , effectuer leur somme et montrer que le résultat binaire vaut (−6)10 .
Exercice 7.3 (Sur 8 bits)

1) Déterminer la représentation sur 8 bits de −92, selon la convention du complément à 2.
2) Déterminer les représentations en base 10 de (01010101)2 et (10101010)2 , codés selon la conven-
tion du complément à 2.
Exercice 7.4 (Sur 16 bits) Coder selon la convention du complément à 2 sur 16 bits le nombre
(−357)10 .
Exercice 7.5 (Vrai ou faux) La chaîne 10001001 code la valeur

1) +137 en base 10
2) 8A en base 16
3) −9 selon la convention de la valeur signée sur 8 bits
4) +137 selon la convention du complément à 2 sur 8 bits
5) −119 selon la convention du complément à 2 sur 8 bits
6) 211 en base 8

Chaînes de caractères
>>> c = ' bon \ njour ' >>> str (4)

>>> print ( c ) '4 '
bon >>> t = ( " xyz " , 2.3 , 10)
jour >>> str ( t )
>>> d = ' bon \ tjour ' " ( ' xyz ', 2.3 , 10) "
>>> print ( d ) >>> print ( " yo yo " , end = '\ n ')
bon jour yo yo
>>> c == d >>> print (1 , 2 , 3 , sep = '+ ' , end = '= ')
False 1+2+3=
>>> t = ' b o n j o u r ' >>> print (6 , 5 , 4 , sep = '\ n ' , end = '* ')
>>> 'a ' in t 6
False 5
>>> ' jour ' in t 4*
True
>>> ' bon ' + ' jour ' >>> m . split ()

' bonjour' [ ' B o n j o u r ' , 'à ' , ' vous ']
>>> p = ' 1234 ' >>> m [11] = 't '
>>> p [2] + p [3] T y p e E r r o r : ' str ' object does not s u p p o r t
' 34 ' item a s s i g n m e n t
>>> ' bon ' *2 >>> m . r e p l a c e( 'v ' , 't ')
' bonbon ' # r e n v o i e une copie modifi é e de m
>>> m = ' B o n j o u r à vous ' ' B o n j o u r à tous '
>>> m [2] >>> m
'n ' ' B o n j o u r à vous ' # m n ' est pas modifi é
>>> m [ -1] >>> mots = [ " rouge " ," vert " ," bleu " ]
's ' >>> " " . join ( mots )
>>> m [:8] ' rouge vert bleu '
' Bonjour ' >>> " et " . join ( mots )
' rouge et vert et bleu '
Exercice 8.3 (Huit petits canetons (G. Swinnen)) Dans un conte américain, huit petits
canetons s’appellent respectivement Jack, Kack, Lack, Mack, Nack, Oack, Pack et Qack.
Ecrire une fonction générant tous ces noms à partir des deux chaînes suivantes :
prefixes = "JKLMNOPQ" et suffixe = ’ack’
La fonction ne devrait être composée que de trois ou quatre lignes.
Exercice 8.4 (Table de multiplication) Ecrire une fonction Table(n) écrivant dans la console
10 lignes donnant la table du nombre n passé en argument :
1) avec un seul print mais sans utiliser la méthode format,
2) avec un seul print et la méthode format.
Exercice 8.5 (Ecriture en miroir) Ecrire une fonction miroir(maChaine) affichant la chaine
maChaine avec les caractères dans l’ordre inverse.
Par exemple, miroir("Coucou comment vas tu ?") renvoie "? ut sav tnemmoc uocuoC"
Exercice 8.6 (Palindrome) Ecrire une fonction EstPalindrome(maChaine) et renvoyant en sortie

True ou False suivant que la chaine maChaine est un palindrome ou pas. Rappelons qu’un palindrome
est une chaîne de caractères se lisant dans les deux sens ; par exemple "RADAR".

Exercice 8.7 (Affectation de groupes) Ecrire une fonction affectationGroupes attendant en
entrée une chaîne mot et affichant en sortie la valeur 1, 2 ou 3 suivant que la première lettre de mot
est comprise entre A et F inclus, entre G et P inclus ou entre Q et Z inclus.
Exercice 8.8 (Reconnaissance de caractères)

1) Ecrire une fonction EstMaj(car) permettant d’identifier si le caractère car passé en argument
est en majuscule. Cette fonction renverra un booléen.
2) Ecrire une fonction NbMaj(c) comptant le nombre de majuscules dans une chaîne de caractères
c donnée.
Exercice 8.9 (Niveau de sécurité d’un mot de passe) Définir une fonction
securite(chaine) permettant de vérifier le degré de sécurité d’un mot de passe selon les critères
suivants. Le mot de passe comporte :
• au moins 10 caractères, • au moins 1 majuscule,

• au plus 16 caractères, • au moins 2 chiffres.
La fonction affichera un message indiquant si le mot de passe est valide ou une raison de non
validité.
Exercice 8.10 (Suppression de caractères) Ecrire une fonction suppression(chaine) qui af-
fiche une chaîne de caractères passée en argument après en avoir supprimé les voyelles et les espaces.
Exercice 8.11 (Modification de caractères) Ecrire une fonction modifCaractere(chaine) qui

affiche une chaîne de caractères après avoir remplacé tous les espaces par le caractère -.
Il est demandé d’utiliser la méthode join.
Exercice 8.12 (Mot mystère) Définir une fonction motMystere(maChaine) qui affiche la chaîne
maChaine modifiée en remplaçant toutes les voyelles par le caractère _.
On veillera à gérer les caractères accentués.
Exercice 8.13 (Codage de César) Ecrire une fonction codage(maChaine, n) qui prend en ar-
gument une chaîne de caractères et décale ses lettres de n crans dans l’alphabet. Par exemple,
codage("bac",3) renvoie "edf". On utilisera pour cela les fonctions ord et chr qui permettent la
conversion des caractères en code ASCII. Ecrire également une fonction de décodage.

Sites web statiques - HTML et CSS
Exercice 9.1 (Ma première page HTML) Saisir dans un éditeur de texte (Notepad++ par
exemple) le texte suivant.
<! D O C T Y P E html >

< html >
< head >
< meta c h a r s e t= " utf -8 " >
< title > Ma premi è re page </ title >
</ head >
< body >
Quel c o n t e n u int é r e s s a n t !
</ body >
</ html >
Choisir un répertoire qui sera utilisé dans tous les exercices et y sauvegarder le fichier en lui donnant
le nom index1.html, puis ouvrir le fichier avec un navigateur Internet.
On va ensuite un peu enrichir notre page Web.
Modifier le titre de l’onglet de navigation en NSI et ajouter :
• un titre Num é rique et Sciences informatiques entre des balises <h1 > .
• un premier bloc délimité par des balises < div > qui contient deux paragraphes délimités par les
balises <p > : dans le 1e paragraphe, on peut lire Voici quelques informations concernant
cette nouvelle sp é cialit é et dans le second : Image à ajouter .
• un 2e bloc qui contient le titre Chapitres de niveau <h3 > suivi d’une liste (non ordonnée) de 3
éléments : IHM Web , Repr é sentation des donn é es et Histoire de l ' informatique .
• un 3e bloc qui contient le titre Nombre d ' heures par semaine de niveau <h3 > suivi de la table
suivante dont il faut compléter la 3e ligne avec Terminale puis 2 puis 6 :
< table id = " t a b l e H e u r e s " >
<tr >
<th > Classe </ th > <th > Projet </ th > <th > Total </ th >
</ tr >
<tr >
<th > Premi è re </ th >
< td class = " m o n A n n e e" > 1 </ td >
< td class = " m o n A n n e e" > 4 </ td >
</ tr >
<tr >
...
</ tr >
</ table >
Sauvegarder le fichier index1.html, puis l’ouvrir avec un navigateur Internet.

N’oublier pas de valider votre page sur http : // validator . w3 . org / .
Exercice 9.2 (Ma première page avec CSS) Saisir dans l’éditeur de texte le texte suivant.
body { background - color : # FAF0E6 ; }
h1 { color : brown ; text - align : center ;}
ul { list - style - type : circle ; }
table , td , th , tr { border : 1 px solid RGB (165 , 42 , 42) ;}
th { font - style : italic ;}
td , th , tr { p a d d i n g : 8 px ;}
# t a b l e H e u r e s { background - color : # F5DEB3 ; }
. m o n A n n e e { color : red ;}
Sauvegarder le fichier en lui donnant le nom monStyle.css.

Sauvegarder index1.html sous le nom index.html, ajouter la ligne permettant le lien avec la feuille
de style monStyle.css.
index.html contient donc les lignes suivantes entre les balises <head>.
< meta c h a r s e t= " utf -8 " >

< title > NSI </ title >
< link rel = " s t y l e s h e e t" type = " text / css " href = " m o n S t y l e. css " >
Observer le résultat dans le navigateur. Faire le lien entre chaque ligne du fichier css et les modi-
fications observées. Observer les différentes manières de définir les couleurs.
Exercice 9.3 (Une autre page) Il s’agit de créer une seconde page html (liée au même fichier
cinlinecss) avec comme titre pour l’onglet de navigation Num é ration . Cette page doit contenir :
• un titre Convertisseur entre des balises <h1 > .
• un premier bloc délimité par des balises < div > qui contient la phrase Voici un outil de
conversion des nombres d é cimaux , binaires et hexad é cimaux .
• un 2e bloc qui contient 3 lignes ; chaque ligne (délimité par des balises <p > ) est composé de 3
éléments :
– une étiquette délimitée par des balises < label >
– une zone de saisie : < input type = " text " >
– un bouton : < input type = " button " value = " Convertir " >
<p > < label for = " b10 " > D é cimal : </ label >
< input type = " text " class = " nb " id = " b10 " >
< input type = " button " value = " C o n v e r t i r " > </p >
<p > < label for = " b2 " > B i n a i r e : </ label >
...
<p > < label for = " b16 " > Hexad é cimal : </ label >
Après avoir complété la ligne relative à la base 2, sauvegarder le fichier en lui donnant le nom
convertisseur.html. Valider la page puis la visualiser dans le navigateur.
Ajouter dans le fichier css les lignes suivantes et observer l’effet obtenu.
label {
/* Pour ê tre s û rs que toutes les é t i q u e t t e s ont la m ê me taille et
sont c o r r e c t e m e n t align é es */
d i s p l a y: inline - block ;
width : 150 px ;
text - align : right ;
}
/* Pour les champs de saisie */

input { margin - right : 10 px ;}
. nb { width : 120 px ; }
On peut valider ce fichier css à l’adresse http : // jigsaw . w3 . org / css - validator / .
Remarque : L’idée du convertisseur est adaptée de la page
http : // www . mathartung . xyz / isn / TP / TPhtml / tp4 . html .

Exercice 9.4 (Liens et images) On voudrait pouvoir accéder à la page convertisseur . html
lorsqu’on clique sur l’élément Repr é sentation des donn é es de la liste des chapitres.
Pour ce faire, dans la page index . html , on va créer un lien :
on remplace la ligne <li> Représentation des données </li> par
<li> <a href = "convertisseur.html"> Représentation des données </a> </li>
Ajouter un bloc délimité par des balises < div > contenant une ligne Retour à la page d ' accueil
qui permet de revenir à la page index . html .
Créer un sous-répertoire Images et y copier le fichier NSI . png .
Remplacer Image à ajouter par
< img id = " ImageNSI " src = " Images / NSI . png " alt = " Cours NSI " / > .
Ouvrir index . html dans le navigateur. L’image prend beaucoup de place ! Pour remédier à cela,
ajouter la ligne suivante dans le fichier css :
/* Pour d é finir les d i m e n s i o n s de l ' image */

# I m a g e N S I { width : 300 px ; height : auto ; }
Pour terminer, ajouter dans le css :

• input {font-size : 14pt}
• une ligne pour que le texte dans les balises < div > soit de taille 18 pt ;
• une ligne pour la couleur des liens (par défaut et visités) soit orange.
Vérifier les deux pages html sur http : // validator . w3 . org / et le fichier css sur
http : // jigsaw . w3 . org / css - validator / .
La conversion en tant que telle des nombres d’une base à l’autre sera faite dans le chapitre
"JavaScript". To be continued ...

Fichiers
Consignes
• Dans votre dossier NSI, créer un dossier nommé Fichiers. Les fichiers textes et les scripts
Python des exercices suivants doivent être enregistrés dans ce dossier.
• Dans Notepad (ou Notepad++), enregistrer les fichiers textes avec l’encodage UTF-8.
Exercice 10.1 (Ecriture)

1) Saisir le script ci-dessous et vérifier le résultat obtenu.
f i c h i e r = open ( " Test . txt " ," w " , e n c o d i n g = " utf -8 " )
f i c h i e r. write ( " Ceci est un essai " )
f i c h i e r. close ()
2) Ecrire un script permettant de rajouter au fichier Test.txt la phrase :

Le résultat obtenu est bien le bon.
Vérifier le résultat obtenu.
3) Ecrire un script permettant de rajouter au fichier Test.txt et sur une nouvelle ligne, la phrase
Il aurait fallu aller à la ligne. Vérifier le résultat obtenu.
Exercice 10.2 (Lecture avec la méthode read)

1) Saisir le script ci-dessous et exécuter le. Comparer avec le contenu du fichier Test.txt.
f i c h i e r = open ( " Test . txt " ," r " , e n c o d i n g = " utf -8 " )
c o n t e n u = f i c h i e r. read ()
print ( c o n t e n u)
2) Ecrire une fonction desMots permettant d’afficher le cinquième mot, puis les quatorzième, quin-
zième et seizième mots sur une même ligne et séparés par un espace, du fichier Test.txt. Utiliser
la méthode split sur la chaîne de caractères contenu.
3) La méthode read() peut également être utilisée avec un argument. Celui-ci indiquera combien
de caractères doivent être lus, à partir de la position déjà atteinte dans le fichier. Par exemple,
pour lire les six premiers caractères du fichier Test.txt, on tape :
c o n t e n u = f i c h i e r. read (6)
print ( c o n t e n u)
S’il ne reste pas assez de caractères au fichier pour satisfaire la demande, la lecture s’arrête tout
simplement à la fin du fichier. De plus, si la fin du fichier est déjà atteinte, read() renvoie une
chaîne vide.
Ecrire une fonction desCaracteres permettant d’afficher les caractères quinze à vingt-six du
fichier Test.txt.

Exercice 10.3 (Lecture avec les méthodes readline et readlines) Au lieu de lire tout le
fichier d’un coup avec la méthode read(), on peut également extraire les lignes du fichier séparément
les unes des autres. Pour cela, on utilise soit la méthode readline() soit la méthode readlines().
La première méthode lit, à partir de la position déjà atteinte, une seule ligne du fichier et y incluant
le caractère de fin de ligne. Quant à la seconde méthode, elle transfère toutes les lignes restantes
dans une liste de chaînes.
Par exemple, pour afficher séparément les deux lignes du fichier Test.txt, on tape
f i c h i e r= open ( " Test . txt " ," r " , e n c o d i n g = " utf -8 " )
print ( f i c h i e r. r e a d l i n e () )
print ( f i c h i e r. r e a d l i n e () )
tandis que pour afficher les deux lignes du fichier Test.txt dans une liste, on tape
print ( f i c h i e r. r e a d l i n e s () )
1) Saisir les deux scripts précédents et exécutez-les. Observer les résultats obtenus.
2) Ecrire une fonction deuxiemeMot permettant d’afficher le deuxième mot de chacune des deux
lignes du fichier Test.txt.
Exercice 10.4 (Proverbes)

1) Dans Notepad++, taper le texte suivant et le sauvegarder dans un fichier nommé Proverbes.txt
(on prendra garde à l’encodage).
A la guerre comme à la guerre .
C h a s s e z le n a t u r e l il r e v i e n t au galop .
Les bons c o m p t e s font les bons amis .
Fais ce que dois a d v i e n n e que pourra .
Faute de grives on mange des merles .
La nuit tous les chats sont gris .
Les chiens ne font pas des chats .
Les petits r u i s s e a u x font les g r a n d e s rivi è res .
Qui veut la fin veut les moyens .
Qui vole un oeuf vole un boeuf .
Tous les go û ts sont dans la nature .
2) Combien de lignes comporte ce fichier ? Ecrire une fonction nbLignes renvoyant le nombre de
lignes d’un fichier dont le nom est passé en paramètre. La tester avec le fichier
Proverbes.txt.
3) Ecrire une fonction proverbe attendant en entrée un entier n et renvoyant le proverbe situé à la
ligne numéro n. La fonction affichera un message d’erreur si le nombre n n’est pas valide.
4) Combien de mots comporte chacun des proverbes ? Ecrire une fonction motProverbe prenant
deux entiers n et m en paramètres et renvoyant le mot numéro m du proverbe à la ligne n. Si
les valeurs de n ou m ne remplissent pas les conditions voulues, on affichera un message d’erreur
dans la console.

Exercice 10.5 (Base de données)
1) Créer un fichier texte Scientifiques.txt avec le contenu suivant :
D e s c a r t e s Ren é fran ç aise 1596 -1650
Cauchy A u g u s t i n fran ç aise 1789 -1857
F o u r i e r Joseph fran ç aise 1768 -1830
R i e m a n n B e r n h a r d a l l e m a n d e 1826 -1866
Galois E v a r i s t e fran ç aise 1811 -1832
Gauss Carl a l l e m a n d e 1777 -1855
Euler L e o n h a r d suisse 1707 -1783
G ö del Kurt am é r i c a i n e 1906 -1978
Turing Alan b r i t a n n i q u e 1912 -1954
N o e t h e r Emmy a l l e m a n d e 1882 -1935
H i l b e r t David a l l e m a n d e 1862 -1943
L e b e s g u e Henri fran ç aise 1875 -1941
L a g r a n g e Joseph - Louis fran ç aise 1736 -1813
P o i s s o n Denis fran ç aise 1781 -1840
B e r n o u l l i J a c q u e s suisse 1654 -1705
Boole George b r i t a n n i q u e 1815 -1864
Bayes Thomas b r i t a n n i q u e 1702 -1761
Newton Isaac b r i t a n n i q u e 1643 -1727
Pascal Blaise fran ç aise 1623 -1662
C h a s l e s Michel fran ç aise 1793 -1880
H e r m i t e C h a r l e s fran ç aise 1822 -1901
C o r i o l i s Gaspard - G u s t a v e fran ç aise 1792 -1843
L e i b n i z G o t t f r i e d a l l e m a n d e 1646 -1716
E i n s t e i n Albert a l l e m a n d e 1879 -1955
Cantor Georg a l l e m a n d e 1845 -1918
2) Ecrire une fonction permettant de lire la première ligne du fichier,

3) Ecrire une fonction permettant d’ajouter un scientifique ; on rajoutera en particulier les deux
personnes suivantes :
• Pierre-Simon Laplace (1749-1827), nationalité française,
• Leonardo Fibonacci (1175-1250), nationalité italienne.
4) Ecrire une fonction renvoyant, si elle existe, la fiche d’un scientifique recherché par son nom ;
si elle n’existe pas, on indiquera dans la console que ce scientifique est absent de la base de
données,
5) Ecrire une fonction renvoyant, si elles existent, le nombre de fiches de scientifiques d’une natio-
nalité donnée, puis toutes ces fiches (on indiquera uniquement le nom, le prénom et les dates,
ces dernières étant mises entre parenthèses) ; s’il n’y en a pas, on indiquera dans la console qu’il
n’y a pas de scientifiques de cette nationalité dans la base.

Algorithmes de recherche séquentielle et de tri
Exercice 11.1 (Recherche séquentielle) On considère un tableau T de n valeurs et on aimerait

avoir un algorithme permettant de savoir si une valeur donnée x se trouve bien dans le tableau.
1) Supposons dans un premier temps que x est bien au moins une fois présent dans le tableau et
cherchons sa première occurrence.
a) Ecrire un algorithme simple qui permet de résoudre ce problème.
b) A quoi correspond le pire des cas ? En déduire la complexité de l’algorithme.
c) A quoi correspond le meilleur des cas ?
2) Considérons à présent le cas général, c’est-à-dire que l’on n’est pas sûr que x appartienne au
tableau.
a) Modifier l’algorithme de la question 1)a) pour résoudre le problème proposé. On renverra
uniquement l’emplacement de la première occurrence si x est présent dans le tableau.
b) Cela modifie-t-il quelque chose au niveau de la complexité ?
c) Comment modifier l’algorithme de la question 2)a) pour qu’il puisse renvoyer l’emplacement
de toutes les occurrences de x lorsque celui-ci est présent dans le tableau.
Exercice 11.2 (Recherche min/max) Dans cet exercice, on se donne un tableau T de n nombres.
1) Ecrire un algorithme permettant de trouver la valeur minimale m de ce tableau ainsi que sa place
p dans ce tableau.
2) Combien de comparaisons effectue cet algorithme ? Quelle est sa complexité ?
3) Mêmes questions pour la valeur maximale M du tableau et sa place P dans ce tableau.
Exercice 11.3 (Moyenne)

1) Ecrire un algorithme prenant en entrée un tableau T de n nombres et retournant la moyenne de
ce tableau.
2) Déterminer la complexité de cet algorithme.
Exercice 11.4 (Tri par sélection à la main) En précisant les étapes, à l’aide d’un tri par
sélection, trier par ordre croissant le tableau suivant.
7 2 3 0 -2 2 -1 5
Exercice 11.5 (Tri par insertion à la main) En précisant les étapes, à l’aide d’un tri par
insertion, trier par ordre croissant le tableau suivant.
1 4 -2 0 4 5 2
Exercice 11.6 (Tri par sélection) On se donne un tableau T de n nombres. Une méthode pour
trier ce tableau par ordre croissant consiste à chercher le minimum, à le mettre en première position
et à recommencer ainsi sur le reste du tableau.
1) Ecrire un algorithme pour trier le tableau par ordre croissant par cette méthode. Quelle est sa
complexité ?
2) Comment modifier cet algorithme pour trier le tableau par ordre décroissant ? La complexité
est-elle modifiée ?
3) Justifier sa terminaison.
4) Décrire un invariant de boucle pour prouver la correction de cet algorithme.
Exercice 11.7 (Minimum) Ecrire une fonction Python chercheMin qui renvoie le minimum d’une
liste L (non vide) de nombres.

Exercice 11.8 (Implémentation tri par sélection) Proposer une implémentation en langage
python de cet algorithme.
Exercice 11.9 (Implémentation tri par insertion) Proposer une implémentation en langage
python de cet algorithme.
Exercice 11.10 (Vitesse d’exécution) Le code python suivant permet de déterminer le temps
d’exécution des instructions entre les deux time.time().
import time , random
t = time . time ()
# cr é e une liste de 10000 e n t i e r s al é a t o i r e s entre 0 et 10000

L = [ random . r a n d i n t (0 ,10000) for i in range ( 1 0 0 0 0 )]
random . s h u f f l e( L ) # m é lange la liste L
dt = time . time () -t
# a f f i c h e la duré e au centi è me pr è s
print ( " Le temps d ' ex é cution fut de {:.2 f } s " . format ( dt ) )
1) Proposer un code python qui permet de déterminer le temps d’exécution d’un tri par sélection
d’un tableau tab de grande taille (il est prudent de commencer avec 10000).
2) Faire de même pour un tri par insertion et comparer.

Dictionnaires
Exercice 12.1 (Console) Observer les résultats obtenus dans la console.
>>> dico = {}
>>> dico [ ' cup '] = ' tasse '
>>> dico [ ' cat '] = ' chat '
>>> dico [ ' cup ']
' tasse '
>>> dico
{ ' cat ': ' chat ' , ' cup ': ' tasse '}
>>> dico2 = { " melon " :4 , " poire " :9 , " citron " :2}
>>> dico2 [ " citron " ] = 5
>>> dico2
{ ' citron ': 5 , ' melon ': 4 , ' poire ': 9}
>>> len ( dico2 )
3
>>> del ( dico2 [ ' melon ' ])
>>> dico2
{ ' citron ': 5 , ' poire ': 9}
>>> ' poire ' in dico2
True
>>> dico3 = { x : x **2 for x in range (4) }
>>> dico3
{0: 0 , 1: 1 , 2: 4 , 3: 9}
>>> dico4 = { cle : val for cle , val
... in zip ([ 'a ' , 'b ' , 'c ' ] ,( ' alpha ' , ' beta ' , ' gamma ') ) }
>>> dico4
{ 'a ': ' alpha ' , 'b ': ' beta ' , 'c ': ' gamma '}
Exercice 12.2 (Repertoire) On donne le dictionnaire suivant.

repertoire = {"Caroline": "0612345678", "Jules": "0687654321", "Martin": "0765432198",
"Tom" : "0777666555"}
Ecrire les instructions correspondant aux demandes suivantes.
1) Comment accéder au téléphone de Jules ?
2) Comment savoir si "Fanny" est enregistrée dans le répertoire ?
3) Modifier le numéro de "Martin", il se termine par un 9 et non un 8.
4) Ajouter "Raoul" dont le numéro est 0789898989.
5) Supprimer "Tom" du repertoire.
6) Afficher les noms présents dans le répertoire en faisant un parcours par clés.
7) Afficher les numéros du répertoire qui commencent par "07" en faisant un parcours par valeurs.
8) Ecrire une fonction affiche qui prend en paramètre un dictionnaire D et une liste L et qui affiche
les couples clé/valeur de D dont les clés sont dans L.
Ainsi, si LNoms = ["Caroline", "Martin"], affiche(repertoire, LNoms) doit afficher
C a r o l i n e a pour num é ro 0 6 1 2 3 4 5 6 7 8
Martin a pour num é ro 0 7 6 5 4 3 2 1 9 9
Exercice 12.3 (Nombre de jours du mois) On se donne les deux listes suivantes :
Jour = [31,28,31,30,31,30,31,31,30,31,30,31] et
Mois = ['Janvier','Février','Mars','Avril','Mai','Juin','Juillet','Août','Septembre',
'Octobre','Novembre','Décembre']
Définir un dictionnaire nbJMois associant à chaque mois le nombre de jours correspondant.

Exercice 12.4 (Ventes) On dispose d’un dictionnaire associant à des noms de commerciaux
d’une société le nombre de ventes qu’ils ont réalisées. Par exemple :
ventes = { " Fortin " :21 , " Donjon " :18 , " L a p o r t e" :12 , " Martin " :21}
1) Ecrire une fonction total qui prend en entrée un tel dictionnaire et renvoie le nombre total de
ventes dans la société.
2) Ecrire une fonction estMeilleurVendeur qui prend en entrée un tel dictionnaire et renvoie le nom
du vendeur ayant réalisé le plus de ventes. Si plusieurs vendeurs sont ex-aequo sur ce critère, la
fonction devra retourner le nom de l’un d’entre eux.
Exercice 12.5 (Magasin en ligne) On donne le tableau suivant indiquant le nom des produits
et le prix correspondant :
Nom du produit Prix TTC (en e)

Sabre laser 229
Etoile de ninja 29,95
Cape 75
Baguette 35
Chapeau 12
Bandeau 5,50
Balai 130
1) Construire un dictionnaire bdPrix correspondant au tableau ci-dessus.

2) Définir une fonction dispo(monProduit, dico) renvoyant True si le produit monProduit est pré-
sent dans le dictionnaire dico de prix et False sinon.
3) Définir une fonction prixMoyen(dico) qui calcule le prix moyen des produits proposés dans le
dictionnaire dico (qui contient au moins un produit).
4) Définir une fonction IntervallePrix(dico, m, M) qui renvoie l’ensemble des produits du dic-
tionnaire dico dont le prix est compris entre m et M.
5) Le panier est un concept omniprésent dans les sites marchands. En Python, le panier du client
sera représenté par un dictionnaire Panier de type dict[str : int] avec :
• le nom des produits comme clé,
• la quantité d’achat comme valeurs associées.
Donner une expression Python correspondant à l’achat de deux sabres lasers, de trois étoiles de
ninja et d’un bandeau.
6) Définir une fonction tousDispo(dPanier, dPrix) qui à partir du panier d’achat dPanier et d’un
dictionnaire des prix dPrix, renvoie True si tous les produits sont disponibles ou False sinon.
7) Définir une fonction Total(dPanier, dPrix) renvoyant le total à payer du panier dPanier à partir
des prix du dictionnaire dPrix (on vérifiera si tous les articles sont disponibles).
Exercice 12.6 (Analyse d’une chaîne) Ecrire une fonction analyse prenant en paramètre une
chaîne de caractère et générant un dictionnaire dont les clés sont chacun des caractères de la chaîne
et les valeurs le nombre de fois où ce caractère est présent dans la chaîne.

Circuits logiques
Exercice 13.1 (Portes NON ET et NON OU)

1) Porte NON ET.
a) Dresser la table de vérité de la fonction booléenne NON ET.
b) Représenter la porte logique correspondante à l’aide d’une porte ET et d’une porte NON.
2) Porte NON OU.
a) Dresser la table de vérité de la fonction booléenne NON OU.
b) Représenter la porte logique correspondante à l’aide d’une porte OU et d’une porte NON.
Exercice 13.2 (Porte OU EXCLUSIF) On rappelle que si A et B sont deux booléens, alors
le booléen S = A OU EXCLUSIF B vaut 1 si A et B ont des valeurs distinctes et 0 sinon.
1) Montrer, à l’aide de tables de vérité, la relation :
A OU EXCLUSIF B = (A ET NON(B)) OU (NON(A) ET B).
2) Représenter la porte correspondante à la fonction booléenne OU EXCLUSIF à l’aide des portes
élémentaires NON, OU et ET.
Exercice 13.3 (Comparateur) On considère la porte logique suivante :
1) Montrer que cette porte correspond à la fonction booléenne EQUIVALENT A.

2) Donner une autre représentation de cette porte à l’aide des portes OU EXCLUSIF et NON.
Exercice 13.4 (Multiplexeur)

1) Montrer, à l’aide de tables de vérité, la relation :
MUX(A,B,Select) = (A ET NON(Select)) OU (B ET Select).
2) Représenter le schéma d’un multiplexeur à l’aide des portes élémentaires NON, OU et ET.

Exercice 13.5 (Additionneur complet) On rappelle que l’additionneur complet
• prend en entrée trois booléens : A : le premier bit à additionner ; B : le second bit à additionner
et Re : la retenue entrante à ajouter ;
• et renvoie deux booléens en sortie : S : le résultat de l’addition et Rs : la retenue sortante.
1) Dresser la table de vérité de l’additionneur complet.
2) Gestion de la retenue sortante Rs.
a) Montrer, à l’aide d’une table de vérité, la relation :
Rs = MUX(A ET B,A OU B,Re).
b) En déduire le schéma d’une porte réalisant la retenue sortante Rs.
3) Gestion du résultat S.
a) Montrer, à l’aide d’une table de vérité, la relation :
S = MUX(Z,NON(Z),Re), où Z = MUX(A,NON(A),B).
b) En déduire le schéma d’une porte réalisant le résultat S.
Exercice 13.6 (Additionneur multi-bits)

1) Additionneur 2 bits.
a) Réaliser les additions binaires suivantes sur 2 bits :
01 + 10 11 + 10 01 + 11 11 + 11
Préciser le résultat S et la retenue sortante Rs.
b) Expliquer comment réaliser un additionneur 2 bits à partir d’additionneurs complets. Sché-
matiser le circuit correspondant.
2) Comment procéder pour réaliser un additionneur 64 bits ?

Sites web statiques - Javascript
Exercice 14.1 (Conversion) Reprendre la page convertisseur.html liée à la feuille de style

monStyle.css (du chapitre HTML).
Le but de l’exercice est que lorsqu’on appuie sur un des boutons convertir, le nombre saisi dans
la zone de saisie correspondante soit converti dans les 2 autres bases.
Pour ce faire, on va associer une fonction JavaScript à chaque bouton. Plus précisément, il faut ajou-
ter un attribut onclick à chaque bouton. Lorsque l’utilisateur cliquera sur un bouton, la fonction
correspondante sera exécutée.
On complète le code html relatif aux boutons de la façon suivante :
<p > < label for = " b10 " > D é cimal : </ label >
< input type = " button " value = " C o n v e r t i r" o n c l i c k= " c o n v N b D e c () ; " >
</p >
<p > < label for = " b2 " > B i n a i r e : </ label >
< input type = " button " value = " C o n v e r t i r" o n c l i c k= " c o n v N b B i n () ; " >
</p >
<p > < label for = " b16 " > Hexad é cimal : </ label >
< input type = " button " value = " C o n v e r t i r" o n c l i c k= " c o n v N b H e x a () ; " >
</p >
Créer un sous-répertoire JS.

Dans Notepad++, créer un nouveau fichier, avec l’encodage utf-8 et le langage javascript. Puis
l’enregistrer dans le dossier JS sous le nom convertisseur (l’éditeur ajoutera automatiquement
l’extension .js).
Pour faire le lien entre la page web et le fichier javascript, rajouter dans la partie délimitée par les
balises <head> de la page convertisseur.html la ligne suivante :
<script src="JS/convertisseur.js"></script>.
Recopier le code javascript suivant dans ton fichier convertisseur.js :
f u n c t i o n c o n v N b D e c ()
{
b i n a i r e = d o c u m e n t. g e t E l e m e n t B y I d ( " b2 " ) ;
h e x a d e c i m a l = d o c u m e n t. g e t E l e m e n t B y I d ( " b16 " ) ;
h e x a d e c i m a l. value = p a r s e I n t( b10 . value ,10) . t o S t r i n g (16) ;

b i n a i r e. value = p a r s e I n t( b10 . value ,10) . t o S t r i n g (2) ;
}
f u n c t i o n c o n v N b H e x a ()
{
d e c i m a l = d o c u m e n t. g e t E l e m e n t B y I d ( " b10 " ) ;
b i n a i r e = d o c u m e n t. g e t E l e m e n t B y I d ( " b2 " ) ;
d e c i m a l. value = p a r s e I n t( b16 . value ,16) . t o S t r i n g () ;

b i n a i r e. value = p a r s e I n t( b16 . value ,16) . t o S t r i n g (2) ;
}
La function convNbBin() est à ajouter.

Quelques commentaires :
• La méthode JavaScript getElementById() permet de repérer un objet du document qui a un

identifiant donné, ici une zone de texte, et d’en récupérer sa valeur grâce à la propriété value.
• La méthode nb.toString([maBase]) convertit le nombre nb dans la basemaBase (paramètre
optionnel, par défaut 10) et renvoie la chaîne de caractères correspondante.
Exemples :
var a = 5 ;
a . t o S t r i n g () ; // r e n v o i e "5"
a . t o S t r i n g (2) ; // r e n v o i e "101"
• La fonction parseInt(maChaine,maBase) convertit la chaîne maChaine] représentant un nombre
écrit dans la base maBase en entier écrit en base 10.
Exemples : parseInt(110,2) renvoie 6 et parseInt(110,10) renvoie 110.
Finalement, on va ajouter dans le css la mise en majuscules du texte (pour les lettres de la base
16) :
.nb { width : 120px ; text-transform : uppercase; } au lieu de .nb {width : 120px ; }
Remarque : on aurait pu éviter de définir la classe nb et utiliser plutôt la syntaxe :
input[type='text'] { width : 120px ; text-transform : uppercase;}
Vérifier la page convertisseur.html sur http://validator.w3.org/ et le fichier css sur

http://jigsaw.w3.org/css-validator/.
Exercice 14.2 (Liste d’élèves) Reprendre la page index.html liée à la feuille de style
monStyle.css (du chapitre HTML).
Le but est d’ajouter un bouton qui lorsqu’on appuie dessus, rend visible un bloc délimité par des
balises <div> et qui contient la liste des élèves.
Pour ce faire, il faut :
• ajouter un bouton grâce à la syntaxe suivante :
<div > < button o n c l i c k= " a f f i c h e L i s t e () " > Voir la liste des é l è ves
</ button > </ div >
• ajouter un bloc délimité par des balises <div> dont l’identifiant est divListeEleves et qui
contient la liste ordonnée suivante :
1) Aurore Attention
2) Bob Bidule
3) Clara Catastrophe
4) David Dépêche
• dans le fichier css, déclarer ce bloc invisible en ajoutant la ligne suivante qu’il faut compléter :
... {display : none ;}
• écrire la fonction javascript qui rend le bloc visible et l’inclure dans l’entête du fichier index.
html (alternative à l’utilisation d’un fichier externe).
Pour terminer
• Tout en bas de la page, ajouter un lien interne Retour en haut de la page qui permet de
revenir au titre délimité par les balises <h1>.
• Dans le css, ajouter une ligne pour que le bouton ait une marge extérieure inférieure de 10px
et pour que son texte soit de taille 14.
Vérifier la page index.html sur http://validator.w3.org/ et le fichier css sur

http://jigsaw.w3.org/css-validator/.

Exercice 14.3 (Voir et cacher) Améliorer la fonctionnalité du bouton pour que lorsqu’on a
cliqué dessus, le texte change en Cacher la liste des élèves.
Si on clique à nouveau sur le bouton, la liste doit effectivement être cachée et le bouton doit de
nouveau afficher Voir la liste des élèves.
Indication : pour récupérer le texte d’un bouton (délimité par des balises <button>), il faut utiliser
la propriété innerHTML de l’élément obtenu grâce à getElementById.
Exercice 14.4 (Validité de la saisie) Retour à la page convertisseur.html et son fichier

javascript associé. Le but de l’exercice est de vérifier ce que l’utilisateur a entré dans une zone de
saisie. Plus précisément, on veut vérifier que l’utilisateur a bien entré un nombre en base 2 dans
le champ associé. En cas d’erreur, on voudrait que la couleur d’arrière-plan du champ de saisie
soit modifié et qu’un message alerte l’utilisateur. (On pourrait procéder de même pour vérifier la
validité des nombres entrés en base 10 ou en base 16.)
Il s’agit donc d’adapter la fonction convNbBin().
Indications :
• parseInt() renvoie NaN en cas d’erreur.
• La fonction isNaN() permet de déterminer si une valeur est NaN.

Algorithmes de recherche dichotomique
Exercice 15.1 (Recherche sol) On souhaite déterminer si le mot « sol » est présent dans la liste
de mots suivante :
bal, zéro, trou, pile, tas, file, auto, frite, bol, cil, gel, vent, vrai, air.
Appliquer l’algorithme de dichotomie en complétant le tableau d’avancement fourni qui reprend les
notations du cours.Conclure.
no étape min max m T [m] T [m] = val T [m] > val

1 1 14
2
3
4
5
Exercice 15.2 (Recherche 1020) Soit T un tableau avec les nombres de 1 à 1024 rangés par
ordre croissant.
1) Si on parcourt T de manière séquentielle, combien faut-il d’étapes pour déterminer si 1020 est
un élément de T ?
2) En déduire le nombre de comparaisons nécessaires.
3) Reprendre ces questions en utilisant l’algorithme de dichotomie et en complétant le tableau
d’avancement ci-dessous qui reprend les notations du cours.
On notera que, dans ce cas, T [m] = m.
TA = max − min + 1 : c’est la taille du tableau dans lequel on cherche val.
no étape min max TA m T [m] = val T [m] > val

1 1 1024 1024
2
3
4
5
6
7
8
9
Exercice 15.3 (Les bonbons) Votre voisin vous propose de jouer au jeu « C bon les bonbons ? »
Il pense à un nombre entier compris entre 10 et 99. À vous de deviner ce nombre afin de gagner les
bonbons !
Chaque fois que vous proposez une valeur, votre voisin vous indique
• si votre proposition correspond au nombre à déterminer ;
• sinon, si votre proposition est strictement inférieure ou strictement supérieure au bon nombre.
Quelle est la meilleure stratégie à adopter pour gagner les bonbons ?
Déterminer le nombre maximal de tentatives intelligentes pour répondre au problème.

Exercice 15.4 (Nombre d’itérations) Adapter l’algorithme de dichotomie pour qu’il renvoie
le nombre d’itérations nécessaires pour déterminer si la valeur est présente ou pas.
Exercice 15.5 (Commentaires) Pour chacun des codes Python ci-dessous, compléter les com-
mentaires.
• Les paramètres a et b sont des nombres entiers positifs.
• Le paramètre T est un tableau de nombres entiers triés par ordre croissant.
def f1 (a , b ) : def f2 (T ,a , b ) : def f3 (T ,a , b ) :

""" """ """
??? ??? ???
""" """ """
return ( a + b ) /2 return T [( a + b ) //2] return T [ a ]== b
Exercice 15.6 (Comparaison) Ecrire le code Python d’une fonction booléenne qui indique si la
valeur médiane d’un tableau de n nombres entiers est strictement supérieure ou non à un nombre
donné.
La fonction se nomme medianeStrSup et prend comme paramètres un tableau trié T et un nombre
entier valeur.

Représentation des caractères et des nombres réels
Exercice 16.1 (Nombres réels 1) Donner la valeur décimale du nombre −1, 0100112 × 23 .
Exercice 16.2 (Nombres réels 2) La norme IEEE 754 est la norme la plus employée pour la
représentation des nombres à virgule flottante dans le domaine informatique. La première version
de cette norme date de 1985.
Le format dit "simple précision" et le format dit "double précision". Le format "simple précision"
utilise 32 bits pour écrire un nombre flottant alors que le format "double précision" utilise 64 bits.
La norme IEEE 754 utilise :
• 1 bit de signe (1 si le nombre est négatif et 0 si le nombre est positif)
• des bits consacrés à l’exposant (8 bits pour la simple précision et 11 bits pour la double
précision) - l’exposant est systématiquement décalé afin d’obtenir uniquement des valeurs
positives : il faut ajouter à l’exposant 127 en simple précision et 1023 en double précision.
• des bits consacrés à la mantisse (23 bits pour la simple précision et 52 bits pour la double
précision)
Coder le nombre 6,875 avec la norme IEEE 754 en simple précision.
Exercice 16.3 (Nombres réels 3)

1) Quelle est la représentation binaire du nombre décimal réel 6,125 ?
2) Conversion en virgule flottante IEEE 754 (32 bits : signe 1 bit, exposant 8 bits, mantisse 23
bits).
Quelle est la valeur décimale des représentations binaires suivantes :
a) 0100 0000 1111 0000 0000 0000 0000 0000
b) 1100 0010 0000 1110 0000 0000 0000 0000
Exercice 16.4 (Nombres réels 4)

1) Convertir en binaire (0, 1)10 .
2) Déterminez la représentation au format simple précision de (0, 1)10 en binaire.
3) Dans la console, taper 0.1+0.2. Qu’observe-t-on ?
Exercice 16.5 (Nombres réels 5) Déterminer la représentation au format simple précision de

1/3 en binaire.
Exercice 16.6 (Codage des caractères) En code ASCII, (41)16 correspond à 'A' et (33)16
correspond à '3'. Coder le message suivant :
B A C 2 1 3
41 33
Exercice 16.7 (Conversions 1) A l’aide d’une table ASCII, convertir en texte les informations
suivantes codées en ASCII (hexadécimal) : 4E 53 49 20 65 73 74 20 75 6E 65 20 22 65 78 63 65
6C 6C 65 6E 74 65 22 20 46 6F 72 6D 61 74 69 6F 6E 2E
Exercice 16.8 (Conversions 2) Coder en Unicode UTF-8, sous forme hexadécimale, le texte :
Année 2019.
Exercice 16.9 (Conversions 3) Trouver le texte représenté en ASCII binaire par la suite de
bits : 01000011001001110110010101110011011101000010000001100110011000010110001101101001
0110110001100101.

Exercice 16.10 (Produits financiers) Dans un fichier comptable, le descriptif de chaque compte
comporte trois zones codées de la manière suivante :
• le numéro de compte (codé sur un octet)
• le libellé du compte (20 caractères ASCII sur un octet chacun)
• le solde du compte (réel sur 32 bits en IEEE 754).
Donner en hexadécimal la codification du compte contenant :
204PRODUITS_FINANCIERS_520,50
le souligné correspondant à un caractère espace.
Exercice 16.11 (Tailles)

1) Ouvrir un éditeur de texte. Ecrire la phrase suivante :
Bonjour ! Vive le cours de NSI ! ! !
2) Enregistrer ce texte en tant que texte brut (extension .txt) en précisant ANSI comme encodage,
puis fermer le logiciel.
3) Quelle est la taille en octets de ce fichier ? A quoi correspond-elle réellement ?
4) Ecrire la même phrase dans un logiciel de traitement de texte (type Open Office ou Word) et
observer la taille du fichier. Quelle peut en être l’explication ?
Exercice 16.12 (Cryptage) Lorsque l’on envoie un message sur Internet et qu’on ne veut pas
que ce message puisse être intercepté et compris par une personne autre que le destinataire, on doit
utiliser une méthode (ou un algorithme) de cryptage.
Le principe général est d’altérer le message selon une méthode connue de l’émetteur et du récep-
teur et d’envoyer sur le réseau le message ainsi modifié. Bien entendu, seul le récepteur doit être
en mesure de décrypter le message reçu pour retrouver le message initial, c’est-à-dire avant sa
transformation par l’opération de cryptage.
Certains algorithmes de cryptage reposent sur l’utilisation d’une clé qui est une séquence de bits
quelconque connue uniquement de l’émetteur et du destinataire du message. Le message crypté
envoyé sur le réseau est obtenu en transformant le message initial à l’aide de cette clé (selon une
méthode connue de l’émetteur et du récepteur) de même que le décryptage par le destinataire est
obtenu en transformant le message crypté à l’aide de cette clé.
Un algorithme de cryptage très simple consiste à crypter le message en utilisant une clé c de 8 bits
et en transformant chaque octet m du message par l’octet m XOR c. Le destinataire effectue la même
opération : il transforme chaque octet m' qu’il a reçu par l’octet m' XOR c pour retrouver l’octet
du message initial. Cette méthode peut naturellement être généralisée pour une longueur de clé
quelconque, et pas uniquement de 8 bits.
Dans cet exercice, on s’intéresse au cryptage d’un texte codé en ASCII (donc avec des caractères
codés sur 7 bits) à l’aide d’une clé de 7 bits.
1) On veut envoyer le mot yop. Donner, à l’aide de la table ASCII, la séquence binaire correspondant
à ce mot.
2) On utilise la clé 55. Quel sera alors le message envoyé après cryptage (en binaire et en texte) ?
3) Vérifier qu’après décryptage, le destinataire retrouve bien le message initial.
4) Prouver à l’aide d’une table de vérité que le destinataire peut toujours retrouver le message
initial à partir de la clé et du message crypté.
5) En pratique, une longueur de clé de 7 bits est insuffisante. On utilise des clés d’au moins 32 ou
64 bits. Pourquoi ?
6) Programmer en python les fonctions de cryptage et décryptage.
En Python, l’opérateur XOR est ^. Tester dans la console 1^0, qui renvoie 1 et 55^121, qui renvoie
78.

Traitement de données en tables
Exercice 17.1 (Indexation de table 1)

1) Ouvrir un éditeur de texte et taper les lignes ci-dessous. Sauver le fichier sous le nom
Election.csv. Par ailleurs, écrire (à la main) les données sous forme de tableau.
nom,prenom,nbVoix
Dupond,Emile,514
Dupont,Chloe,632
Dupons,Camille,421
Flavier,Jean,123
2) Taper le code Python suivant.

import csv
with open ( ' E l e c t i o n. csv ') as m o n F i c h i e r :
table1 = list ( csv . reader ( monFichier , d e l i m i t e r= ' , ') )
Remarque : Il serait possible de lire notre fichier sans utiliser le module csv. Si nous utilisons le
module csv, c’est qu’il permet de faciliter l’écriture de nos programmes.
a) Observer le résultat obtenu dans la console.

>>> table1
[[ ' nom ' , ' prenom ' , ' nbVoix '] ,
[ ' Dupond ' , ' Emile ' , ' 514 '] ,
[ ' Dupont ' , ' Chloe ' , ' 632 '] ,
[ ' Dupons ' , ' C a m i l l e ' , ' 421 '] ,
[ ' F l a v i e r ' , ' Jean ' , ' 123 ' ]]
>>> type ( table1 )
< class ' list ' >
b) Comment accéder à la donnée 'Emile' ?

c) Comment accéder à la donnée 'Dupons' ?
d) Comment déterminer le nombre de lignes du tableau ?
e) Comment déterminer le nombre de colonnes du tableau ?
Exercice 17.2 (Indexation de table 2) Taper le code Python suivant.
import csv
with open ( ' E l e c t i o n. csv ') as m o n F i c h i e r :
table2 = list ( csv . D i c t R e a d e r ( m o n F i c h i e r) )
1) Observer le résultat obtenu dans la console.

>>> table2
[{ ' nbVoix ': ' 514 ' , ' nom ': ' Dupond ' , ' prenom ': ' Emile '} ,
{ ' nbVoix ': ' 632 ' , ' nom ': ' Dupont ' , ' prenom ': ' Chloe '} ,
{ ' nbVoix ': ' 421 ' , ' nom ': ' Dupons ' , ' prenom ': ' C a m i l l e '} ,
{ ' nbVoix ': ' 123 ' , ' nom ': ' F l a v i e r ' , ' prenom ': ' Jean ' }]
>>> type ( table2 )
< class ' list ' >
2) Comment accéder à la donnée 'Emile' ?

3) Comment accéder à la donnée 'Dupons' ?
4) Comment déterminer le nombre de lignes du tableau ?
5) Comment déterminer le nombre de colonnes du tableau ?

Exercice 17.3 (Entiers) Pour convertir les données de la colonne nbVoix en des entiers, on peut
taper :
# U t i l i s a t i o n d ' une é c r i t u r e " c o m p a c t e"
for ligne in table2 : ligne [ ' nbVoix '] = int ( ligne [ ' nbVoix ' ])
A la console, on obtient :
>>> table2
[{ ' nbVoix ': 514 , ' nom ': ' Dupond ' , ' prenom ': ' Emile '} ,
{ ' nbVoix ': 632 , ' nom ': ' Dupont ' , ' prenom ': ' Chloe '} ,
{ ' nbVoix ': 421 , ' nom ': ' Dupons ' , ' prenom ': ' C a m i l l e '} ,
{ ' nbVoix ': 123 , ' nom ': ' F l a v i e r ' , ' prenom ': ' Jean ' }]
Quel est l’intérêt d’utiliser une liste de dictionnaires plutôt qu’une liste de listes ?
Exercice 17.4 (Recherche simple) Soit le code Python suivant.

def v a l E s t P r e s e n t e 1 ( tab , val ) :
for ligne in tab :
if val in ligne :
return True
return False
1) Qu’obtient-on si on tape :
valEstPresente1(table1, 'Camille')
valEstPresente1(table1, 'Laura')
2) Ecrire une fonction valEstPresente2 dans le cas où le fichier a été lu sous forme de liste de
dictionnaires.
Exercice 17.5 (Recherche plus élaborée)

1) Ecrire une fonction recherche qui retourne la liste des lignes dans lesquelles le prénom commence
par un 'C' et le nombre de voix est strictement supérieur à 300. On supposera que le fichier a
été lu sous forme de liste de dictionnaires.
2) Définir directement cette liste par compréhension.
Exercice 17.6 (Recherche doublons) Ecrire une fonction rechercheDoublons qui retourne un
tuple constitué d’une part, de la liste des lignes différentes (sans doublon) et d’autre part, de la
liste des lignes qui sont répétées.
On testera la fonction avec table1 (sans doublon) et avec table3 (avec doublon), obtenue en répétant
une des lignes. Par exemple, table3 sera obtenue à partir du fichier ElectionD.csv contenant les
lignes suivantes :
nom,prenom,nbVoix
Dupond,Emile,514
Dupont,Chloe,632
Dupons,Camille,421
Dupont,Chloe,632
Flavier,Jean,123
Exercice 17.7 (Tri) Voici ce qu’on peut lire sur la page

https://www.w3schools.com/python/ref_list_sort.asp
Python List sort() Method
# E x a m p l e 1 - Sort the list a l p h a b e t i c a l l y

>>> cars = [ ' Ford ' , ' BMW ' , ' Volvo ']
>>> cars . sort ()
>>> cars
[ ' BMW ' , ' Ford ' , ' Volvo ']

Definition and Usage
The sort() method sorts the list ascending by default.
You can also make a function to decide the sorting criteria(s).
Syntax : list.sort(reverse=True|False, key=myFunc)
Parameter Values :
Parameter Description
reverse Optional. reverse=True will sort the list descending. Default is reverse=False
key Optional. A function to specify the sorting criteria(s)
More examples
# E x a m p l e 2 - Sort the list d e s c e n d i n g
>>> cars . sort ( r e v e r s e= True )
>>> cars
[ ' Volvo ' , ' Ford ' , ' BMW ']
# E x a m p l e 3 - Sort the list by the length of the values

# A f u n c t i o n that r e t u r n s the length of the value
def myFunc ( val ) :
return len ( val )
>>> cars . sort ( key = myFunc )
>>> cars
[ ' BMW ' , ' Ford ' , ' Volvo ']
# E x a m p l e 4 - Sort a list of d i c t i o n a r i e s based on

# the " year " value of the d i c t i o n a r i e s
# A f u n c t i o n that r e t u r n s the ' year ' value :

def myFunc ( dict ) :
return dict [ ' year ']
>>> cars = [{ ' car ': ' Ford ' , ' year ': 2005} ,\
... { ' car ': ' BMW ' , ' year ': 2019} ,\
... { ' car ': ' Volvo ' , ' year ': 2011}]
>>> cars . sort ( key = myFunc )
>>> cars
[{ ' car ': ' Ford ' , ' year ': 2005} ,
{ ' car ': ' Volvo ' , ' year ': 2011} ,
{ ' car ': ' BMW ' , ' year ': 2019}]
# E x a m p l e 5 - Sort the list by the length of the values and r e v e r s e d
# A f u n c t i o n that r e t u r n s the length of the value

def myFunc ( val ) :
return len ( val )
>>> cars . sort ( r e v e r s e= True , key = myFunc )
>>> cars
[ ' Volvo ' , ' Ford ' , ' BMW ']
1) (Cas simple) Ecrire une fonction qui trie le tableau par ordre alphabétique décroissant par
rapport à la 1e colonne (nom) lorsque les données sont stockées sous forme de liste de listes.
2) (Cas général) Ecrire une fonction qui trie le tableau par nombre de voix croissant. Plus préci-
sément, on demande une fonction lorsque les données sont stockées sous forme de liste de listes
et une fonction pour une liste de dictionnaires.

Exercice 17.8 (Fusion simple) Soit le fichier Electionbis.csv dont le contenu est donné ci-
dessous.
nom,prenom,nbVoix
Prince,Georges,421
Casir,Abdel,854
Dupons,Camille,421
On veut créer une table avec les lignes issues de Election.csv et de Electionbis.csv sans doublon.
Exercice 17.9 (Fusion et bibliothèque pandas) Soit le fichier Age.csv dont le contenu est
donné ci-dessous.
nom,prenom,age
Dupond,Emile,29
Filant,Marc,34
Dupont,Chloe,54
Dupons,Camille,38
Pour les lignes de Election.csv et Age.csv qui ont le nom et le prénom en commun, on veut créer
un tableau qui contient les informations des deux fichiers (en n’indiquant qu’une seule fois le nom
et le prénom par ligne).
Pour faire cette fusion, le plus simple est d’utiliser la bibliothèque pandas qui n’est pas par défaut
dans Edupython.
La bibliothèque pandas est très utilisée pour tout ce qui touche au traitement des données.
Voici la procédure d’installation (sous Windows) : dans EduPython, sélectionner
menu Outils - Outils - installation d'un nouveau module.
Une fenêtre d’invite de commande (cmd) s’ouvre et il faut choisir le mode d’installation. Choisir
conda et indiquer le nom du module à importer (ici, pandas).
import pandas
table1 = pandas . r e a d _ c s v( " e l e c t i o n. csv " )
>>> table1
nom prenom nbVoix
0 Dupond Emile 514
1 Dupont Chloe 632
2 Dupons Camille 421
3 Flavier Jean 123
On remarque qu’une colonne a été ajoutée par rapport aux données : les nombres présents dans
cette colonne sont appelés des index. Chaque ligne du tableau a un index (première ligne : index
0, deuxième ligne index 1...).
Il est possible de récupérer certaines données du tableau, par exemple, certaines lignes, certaines
colonnes ou bien encore des valeurs uniques. Pour cela, il suffit d’utiliser l’instruction
loc[indexLigne,nomColonne] avec les index des lignes et les noms des colonnes.
Pour récupérer
• les données d’une colonne pour toutes les lignes, on remplace indexLigne par :
• les données de toutes les colonnes d’une ligne particulière, en remplaçant nomColonne par :
Il est possible de trier le tableau en fonction des valeurs d’un descripteur. Il suffit d’utiliser l’ins-
truction sort_values. Il est aussi possible de fusionner des tables ayant au moins une colonne en
commun grâce à l’instruction merge.

Observer les résultats obtenus à la console.
import pandas
table1 = pandas . r e a d _ c s v( " e l e c t i o n. csv " )
>>> i n f o P r e n o m= table1 [ ' prenom ']

>>> i n f o P r e n o m
0 Emile
1 Chloe
2 Camille
3 Jean
Name : prenom , dtype : object
>>> i n f o V a l= table1 . loc [2 , ' prenom ']

>>> i n f o V a l
'Camille'
>>> i n f o V o i x= table1 . loc [: , ' nbVoix ']

>>> i n f o V o i x
0 514
1 632
2 421
3 123
Name : nbVoix , dtype : int64
>>> i n f o L i g n e= table1 . loc [1 ,:]

>>> i n f o L i g n e
nom Dupont
prenom Chloe
nbVoix 632
Name : 1 , dtype : object
>>> s o u s T a b l e= table1 . loc [[0 ,1] ,[ ' nom ' , ' nbVoix ' ]]
>>> s o u s T a b l e
nom nbVoix
0 Dupond 514
1 Dupont 632
>>> r e s u l t a t C o n d = table1 . loc [ table1 [ " nbVoix " ] >300 ,[ " nom " ," prenom " ]]
>>> r e s u l t a t C o n d
nom prenom
0 Dupond Emile
1 Dupont Chloe
2 Dupons C a m i l l e
>>> t r i N b V o i x= table1 . s o r t _ v a l u e s ( by =[ " nbVoix " ])

>>> t r i N b V o i x
nom prenom nbVoix
3 Flavier Jean 123
2 Dupons C a m i l l e 421
0 Dupond Emile 514
1 Dupont Chloe 632
>>> t a b l e A g e= pandas . r e a d _ c s v( " age . csv " )

>>> t a b l e C o m p l e t e = pandas . merge ( table1 , t a b l e A g e)
>>> t a b l e C o m p l e t e
nom prenom nbVoix age
0 Dupond Emile 514 29
1 Dupont Chloe 632 54
2 Dupons C a m i l l e 421 38

Système d’exploitation Linux
Les exercices 1 et 2 sont adaptés du TD de l’IUT Montpellier - Architecture (V. Poupet)

Si vous n’avez pas d’ordinateur avec Linux comme système d’exploitation, il y a différentes possi-
bilités pour utiliser des simulations.
• en ligne, par exemple avec un simulateur codé en javascript tel que :
https : // vfsync . org /
• sur un ordinateur sur lequel vous avez les droits administrateurs, en créant une machine virtuelle
Linux
– via le logiciel virtualbox.
– directement à partir de Windows11.
On rappelle que répertoire est synonyme de dossier (folder en anglais). Le répertoire courant
est celui dans lequel on se trouve.
Pour réutiliser une commande précédente, on peut utiliser la flèche vers le haut.
Exercice 18.1 (Commandes de base) Dans cet exercice, nous allons nous intéresser aux com-
mandes permettant de manipuler l’arborescence de fichiers du système.
• ls (list) permet de lister le contenu d’un répertoire (par défaut, le répertoire courant). On peut
lui passer en argument le chemin du répertoire à observer. Il existe de nombreuses options pour
modifier la présentation du résultat, parmi lesquelles :
⋄ -l qui affiche des informations plus détaillées (droits d’accès, taille, propriétaire),
⋄ -R qui parcourt les répertoires récursivement.
• cd (change directory) change le répertoire courant. Si la commande est lancée sans argument,
c’est le répertoire personnel de l’utilisateur ( home ) qui devient le répertoire courant. L’argument
est le nouveau répertoire dans lequel on veut se placer, qui peut être donné de manière absolue
ou relative. La notation .. désigne le répertoire parent d’un répertoire (on peut utiliser cette
notation de manière répétée, ainsi ../.. désigne le parent du parent).
• pwd (print working directory) affiche le répertoire courant.
• mkdir (make directory) sert à créer un répertoire dont le nom est donné en argument.
• touch permet de créer un fichier vide (le nom du fichier à créer est passé en argument).
• mv (move) permet de déplacer un fichier ou répertoire. Cette commande prend deux arguments :
le fichier source et sa destination. C’est également cette commande qui permet de renommer un
fichier (ou un répertoire) en le "déplaçant" vers un autre nom (par exemple
mv titi . txt toto . txt ).
En outre, mv * monDossier permet de déplacer tous les fichiers du répertoire courant vers le
répertoire monDossier .
• cp (copy) copie un fichier ou un répertoire d’un emplacement vers un autre. La syntaxe est
similaire à celle de la commande mv (source puis cible). L’option -R permet d’effectuer une copie
récursive dans le cas où la source est un répertoire.
• rm (remove) supprime le ou les fichiers ou répertoires passés en argument. Pour supprimer un
répertoire, il faut ajouter l’option -r qui indique que la suppression doit-être effectuée récursi-
vement.
• file donne des informations sur le contenu d’un fichier (format des données, encodage...).

Observer le résultat des commandes suivantes.
cd
touch hello . txt
ls
mkdir DossierXXX
mkdir DossierXXX / SousDos
ls
touch DossierXXX / aurevoir . txt
ls
cd DossierXXX
ls
cd SousDos
cd
cd DossierXXX / SousDos
cd ..
Exercice 18.2 (Premiers essais)

1) Se placer dans le répertoire personnel puis créer un répertoire nommé NSIOS et aller dans ce
répertoire.
2) Dans le répertoire NSIOS , créer un fichier vid . txt . Renommer ensuite ce fichier en vide . txt .
3) Copier le fichier vide . txt deux fois en donnant respectivement le nom copie1 . txt et
copie2 . txt .
4) Tout en restant dans le répertoire NSIOS , créer un répertoire test dans votre répertoire person-
nel. Déplacer ensuite tous les fichiers de NSIOS dans le nouveau répertoire test .
5) Déplacer le répertoire test (et ce qu’il contient) dans NSIOS .
Afficher le contenu de NSIOS d’abord de manière simple puis de manière à voir tous les fichiers
contenus dans les sous-répertoires.
6) Supprimer le répertoire test et tout ce qu’il contient.
Exercice 18.3 (Quelques autres outils)

• cat (catenate) affiche le contenu de son entrée dans sa sortie. L’utilisation usuelle est de donner
en arguments une liste de fichiers, la commande affiche alors à la suite les contenus de ces fichiers
dans la sortie standard. Cependant, si la commande est lancée sans paramètres, c’est l’entrée
standard (entrée au clavier) qui est affichée sur la sortie standard (affichage à l’écran).
• less permet de visualiser le contenu d’un fichier dans le terminal. Il est possible de parcourir le
fichier avec les flèches haut et bas du clavier, de rechercher un mot en appuyant sur / (puis n
pour le résultat suivant et N pour le précédent). Appuyez sur Q pour quitter.
• head et tail permettent d’afficher les n premières ou dernières lignes respectivement d’un fi-
chier. Le nombre de lignes est passé en option (par exemple : head -10 toto . txt affiche les 10
premières lignes du fichier toto . txt ).
• grep parcourt des lignes de texte et n’affiche que les lignes contenant un chaîne de caractères
donnée en premier argument. Cette chaîne de caractères peut être une suite de lettres ( " tre " )
ou une expression régulière.
Les expressions régulières sont des "motifs", plus précisément des formules qui représentent
des chaînes de caractères. Le second argument peut être un fichier (dans ce cas le programme
cherche le motif dans les lignes du fichier). S’il n’y a pas de second argument, c’est sur l’entrée
standard que le motif est cherché.
Exemples :
– Si on veut chercher toutes les lignes commençant par "a", il faut indiquer que l’on veut le
début de la ligne, avec le chapeau :
grep '^a' fichier.txt

– Si on veut chercher toutes les lignes finissant par "rs", il faut indiquer que l’on veut la fin
de la ligne, avec le dollar :
grep 'rs$' fichier.txt
• wc (word count) compte le nombre de lignes, de mots et de caractères dans le fichier passé en
argument (ou l’entrée standard si aucun argument n’est donné).
Il est possible de combiner les actions de plusieurs fonctions, en redirigeant la sortie d’une commande
vers l’entrée de la suivante. On utilise alors le symbole | entre les deux commandes. Il est également
possible de rediriger le résultat d’une commande vers le contenu d’un fichier avec > ou >> (le premier
écrase le contenu existant, tandis que le second ajoute le résultat à la suite du fichier) ou à l’inverse
d’utiliser le contenu d’un fichier comme entrée avec < .
1) Dans le répertoire personnel, créer répertoire nommé Exo3 .
2) Dans le répertoire Exo3 , créer deux fichiers nommés respectivement toto . txt et tutu . txt .
3) Taper la commande cat > poeme . txt et taper quelques lignes de texte (en passant à la ligne
plusieurs fois). Quitter avec un passage à la ligne puis Ctrl-D.
4) Copier le fichier poeme . txt en poesie . txt .
5) Oberver l’effet de la commande cat -n poeme . txt > poesie . txt
Regarder le contenu du fichier poesie . txt en tapant cat poesie . txt
6) Afficher la liste des fichiers du répertoire Exo3 dont le nom commence par un t en tapant la
commande ls t * .
7) Créer un fichier nommé fruits . txt contenant les mots suivants (un mot par ligne) :
abricot - airelle - amande - ananas - avocat - banane - cassis - cerise - citron - clémentine - datte
- figue - fraise - framboise - griotte - groseille - kaki - kiwi - mandarine - melon - mirabelle -
mûre - myrtille - nectarine - noisette - noix - orange pamplemousse - pastèque - pêche - pistache
- poire - pomme - prune - raisin
Ecrire une commande pour trouver les noms de fruits se terminant par ne .
8) Ecrire une commande qui permet, à partir du fichier fruits . txt , de créer un fichier nommé
fruits6 . txt contenant les 6 premières lignes de fruits . txt . Vérifier la présence du fichier
fruits6 . txt et son contenu.
9) Ecrire une commande qui permet, à partir du fichier fruits . txt , de créer un fichier nommé
fruitsMix . txt contenant les lignes 9 à 14 de fruits . txt .
10) A partir du fichier fruits . txt , créer un fichier fruitsALE . txt contenant tous les noms de fruits
qui commencent par "a" suivis de tous ceux qui se terminent par "le".
Ecrire une commande pour déterminer le nombre de mots.
11) Quels sont les noms de fruits comportant 8 lettres de la forme .. st ... e ?
Exercice 18.4 (Modification des droits) chmod permet de changer les permissions de lecture,
d’écriture et d’exécution d’un fichier ou d’un répertoire pour le propriétaire, son groupe et les
autres. Il existe 3 syntaxes différentes pour définir des droits, dans les 3 cas le résultat est le même.
chmod [options] 777 [fichier_ou_répertoire]

ou chmod [options] +rwx ugo [fichier_ou_répertoire]
ou chmod [options] rwx rwx rwx [fichier_ou_répertoire]
On ne peut modifier les droits sur les fichiers et répertoires que si on est le propriétaire du fichier
ou si on dispose des droits root . On va étudier le fonctionnement en mode octal, chmod est suivi
de trois chiffres, chacun d’eux permettent de données des droits sur le propriétaire, le groupe et les
autres. Par défaut, le créateur d’un fichier ou d’un dossier devient automatiquement le propriétaire.

Exemple
chmod 756 [ fichier_ou_r é pertoire ]
• Le chiffre de gauche (ici, 7) donne les permissions au propriétaire
• Le chiffre du centre (ici, 5) donne les permissions au groupe
• Le chiffre de droite (ici, 6) donne les permissions à tous les autres utilisateurs
Chaque permission dispose d’une valeur différente : lecture = 4 ; écriture = 2 ; exécution = 1
Par exemple, pour donner le droit de lecture et d’exécution, on va additionner 4 + 1 = 5.
Si on fait chmod 555 [ fichier_ou_r é pertoire ] cela aura pour effet de mettre le droit de lecture
et d’exécution au propriétaire, au groupe et aux autres.
Autre exemple : si on veut donner tous les droits au propriétaire d’un fichier, on va respectivement
additionner 4 + 2 + 1 = 7. Si on ne veut donner que le droit de lecture au groupe et aux autres,
donc la lecture = 4, cela donne comme commande finale :
chmod 744 [ fichier_ou_r é pertoire ]
1) Utiliser la commande touch suivi d’un nom de fichier ( nsi500 par exemple) pour créer un
fichier vide.
2) Utiliser la commande ls avec l’option -l pour visualiser les droits du fichier nsi500 .
3) Utiliser la commande chmod 000 nsi500 pour modifier les droits du fichier puis ls -l .
4) Essayer d’effacer le fichier nsi500 .
5) Utiliser la commande chmod 541 nsi500 pour modifier les droits du fichier puis ls -l .
Exercice 18.5 (Script shell)

1) Créer un fichier fifi . sh qui contient les lignes suivantes :
#!/bin/bash
nb="$1"
echo "Nombre=$nb"
grep "^a" fruits.txt > $nb.txt
Remarques
• Les caractères # ! sont un marqueur spécial qui désigne un type de fichier, ici un script shell
exécutable. Ils sont suivis du chemin vers le programme qui interprète les commandes de ce
script. Ensuite, cet interpréteur de commande exécute les commandes du script.
• Il ne faut pas mettre d’espace dans l’instruction nb="$1".
2) Rendre le fichier exécutable.
3) Exécuter le script en tapant : ./ fifi . sh 5
Qu’observe-t-on ?

Exercices variés Python - Série 1
Exercice 19.1 (Somme) En utilisant la fonction range pour générer les nombres 50, 52, 54, ...,
écrire un programme qui calcule la somme :
50 × 1 + 52 × 2 + 54 × 3 + 56 × 4 + 58 × 5 + ... + 100 × 26
Exercice 19.2 (2 chaînes et 1 liste) On donne les chaînes de caractères : mot1 = "efg" et
mot2= "a5". Ecrire une fonction permettant de créer la liste
['ea', 'e5', 'fa', 'f5', 'ga', 'g5'] à partir des chaînes mot1 et mot2.
Indication : on pourra utiliser deux boucles imbriquées.
Exercice 19.3 (Paires) Ecrire une fonction qui prend deux listes li1 et li2 en paramètres et
retourne la liste de toutes les paires (a,b) telles que a est un élément de li1 et b est un élément de
li2.
Par exemple, creerPaires(['a','b','c'], [1,2]) renverra
[('a', 1), ('a', 2), ('b', 1), ('b', 2), ('c', 1), ('c', 2)].
Exercice 19.4 (Compter les lettres) Ecrire une fonction compteLettres qui admet comme
argument une chaîne de caractères et qui renvoie un dictionnaire contenant le nombre d’occurrences
de chacun des caractères utilisés dans la chaîne.
Exercice 19.5 (Les lunes) Définir le dictionnaire lunes représenté ci-dessous. Ce dictionnaire
stocke le nombre de satellites de chaque planète.
clé ’Mercure’ ’Venus’ ’Terre’ ’Mars’ ’Jupiter’ ’Saturne’ ’Uranus’ ’Neptune’
valeur 0 0 1 2 63 61 27 11
Ecrire un programme permettant de :
• modifier le dictionnaire précédent pour corriger une erreur qui s’est glissée dans l’énoncé. La
planète Neptune comporte en fait 13 satellites.
• afficher le nombre de lunes de la Terre,
• afficher la liste des planètes,
• afficher le nombre total de lunes.
Exercice 19.6 (Echange clés/valeurs) Ecrire une fonction qui échange les clés et les valeurs
d’un dictionnaire (ce qui permettra par exemple de transformer un dictionnaire anglais/français en
un dictionnaire français/anglais). On suppose que le dictionnaire ne contient pas plusieurs valeurs
identiques.
Exercice 19.7 (Max clés) Ecrire une fonction maxDic qui prend en paramètre un dictionnaire
(dont les valeurs sont des nombres) et renvoie la clé correspondant à la plus grande valeur.
Par exemple, maxDic({'a': 3, 'b': 10, 'c': 0, 'd': 5}) renverra 'b'.
Exercice 19.8 (Tri clés) Ecrire une fonction triCles qui prend un dictionnaire (dont les valeurs
sont des nombres) et renvoie la liste des clés du dictionnaire par ordre de valeurs décroissantes dans
le dictionnaire.
Par exemple, triCles({'a': 3, 'b': 5, 'c': 0, 'd': 10}) renverra ['d','b','a','c'].
Exercice 19.9 (Liste mystère) Que contient la variable L après l’instruction suivante ?
L=[n**2 if n%2==0 else n**3 for n in range(11)]

Exercice 19.10 (Moyenne des notes) Le fichier notes.txt contient les notes obtenues par des
étudiants pour le cours de NSI. Chaque ligne du fichier ne contient qu’une note. Ce fichier est
enregistré dans le répertoire de travail courant.
Créer un script Python qui lit chaque ligne de ce fichier, extrait les notes sous forme de float.
Terminer le script en calculant et affichant la moyenne des notes.
Indication : si on tape help(float), on peut lire :
convert a string or number to a floating point number, if possible.
Ainsi, float(5) renvoie 5.0 et float("3.5") renvoie 3.5.
Exercice 19.11 (Trouver un nombre) Ecrire un programme qui permet de trouver un nombre
mystère qui répond à toutes les conditions suivantes :
• Il est composé de 3 chiffres.
• Il est strictement inférieur à 300.
• Il est pair.
• Deux de ses chiffres sont identiques.
• La somme de ses chiffres est égale à 7.

Réseaux
Exercice 20.1 (Matériel) Attribuer les définitions suivantes à l’élément auquel elles corres-
pondent.
1) Permet de relier les moyens informatiques entre eux

2) Permet l’accès au réseau sans utiliser de fil de câblage
3) Contient les logiciels et stocke les données des ordinateurs du réseau pédagogique
4) Permet le transfert des données vers un autre réseau
5) Permet l’impression d’un document issu exclusivement de l’ordinateur du CDI
6) Permet l’impression d’un document issu de n’importe quel ordinateur du réseau
7) Permet la numérisation d’un document
Exercice 20.2 (Questions de cours) Répondre brièvement à chaque question.
1) Qu’est-ce qu’un modem ?

2) Qu’est-ce qu’un protocole réseau ?
3) Qu’est-ce qu’une adresse IP et à quoi sert-elle ?
4) Qu’est-ce qu’un DNS ?
5) Quel est le rôle du routeur ?
6) Qu’est ce qui caractérise une imprimante réseau (reliée directement au réseau) par rapport à
une imprimante standard (reliée au réseau via un ordinateur) ?
7) L’utilisation de la fibre optique élimine les problèmes de court-circuit, pourquoi ?
8) Pourquoi un message est-il fragmenté en de petits paquets avant d’être envoyé sur Internet ?
9) Dans un réseau, les ordinateurs doivent-ils avoir tous le même système d’exploitation (SE) pour
pouvoir communiquer entre eux ?

10) Comment appelle-t-on l’ensemble de programmes utilisé par les ordinateurs d’un réseau pour
communiquer entre eux ? Donner un exemple.
11) Qu’est-ce qu’un réseau informatique et quelle est son utilité ?
12) Que signifie : LAN, WAN, Internet ?
13) Que signifie : http, FTP, TCP/IP ?
14) Quelles sont les parties représentant une adresse IP ?
Exercice 20.3 (QCM)

1) Parmi les applications suivantes, lesquelles sont sensibles aux pertes occasionnelles ?
(3 réponses correctes)
a) Voix sur IP, téléphonie
b) Vidéos en ligne
c) Transactions bancaires
d) Transfert de fichiers, téléchargement
e) Commande à distance de systèmes industriels
2) Dans le protocole du bit alterné, au bout de combien d’envois l’émetteur est-il certain que les
données qu’il désire envoyer au récepteur seront bien arrivées à celui-ci ?
a) 1 b) 2 c) 4 d) Autre
Exercice 20.4 (Bit alterné) On imagine deux systèmes, A et B, utilisant le protocole du bit
alterné. Le chronogramme ci-dessous représente le transport de trois unités de données entre les
deux.
Quelles seront la valeur du compteur associé à la troisième unité de données, et les valeurs des deux
variables chez l’émetteur et le récepteur ? 0, 1 ou 2 ?
Exercice 20.5 (Page Web) On ouvre un navigateur Web à l’URL ci-dessous :

http ://www.monsite.fr/rep/fichier.html.
1) Quels seront les protocoles de service utilisés par le navigateur ?

2) Quels seront les messages échangés entre notre machine et les autres serveurs impliqués ?

Exercice 20.6 (Vrai ou faux ?) Justifier dans le cas où c’est faux.
1) Les liaisons Internet se font seulement via des lignes de cuivre.

2) Les routeurs facilitent l’acheminement d’un message sur Internet.
3) Un pare-feu est un système qui permet de se connecter à un réseau local.
4) Un moteur de recherche nous permet d’envoyer et de recevoir nos messages.
5) Dans un réseau, les ordinateurs doivent être tous des PC.
6) Un WAN est un réseau local.
7) Un LAN est un réseau local.
Exercice 20.7 (Invite de commandes) Pour accéder à l’invite de commandes sous Windows :
faire un clic droit sur le menu D é marrer , choisir Ex é cuter puis taper cmd .
Remarque : à partir de Windows 10, l’invite de commande par défaut ( cmd . exe ) a été remplacée
par l’utilitaire Windows PowerShell.
Taper, dans l’invite de commande, la commande ipconfig / all .
1) Relever l’adresse MAC de la carte réseau Ethernet.
2) Relever l’adresse IP, le masque de sous-réseau de la carte réseau. Indiquer si le mode d’adressage
est en mode automatique ou manuel. Donner la durée de validité des paramètres IP. Donner
également l’adresse du serveur DHCP.
3) Déterminer l’adresse IP du réseau du lycée.
4) Relever l’adresse IP de la passerelle par défaut (default gateway) qui est le routeur par lequel
l’ordinateur est connecté à Internet.
5) Relever l’adresse IP du serveur DNS.
Pour tester la communication entre deux machines, il faut utiliser la commande ping . Par exemple,
la commande ping 172.1.1.99 permet de vérifier que votre PC communique avec le poste 172.1.1.99.
1) Tester la communication avec un autre PC de la salle.
2) Tester la communication avec le site www . google . fr . Relever l’adresse IP du serveur qui héberge
le site.
La commande tracert sous Windows (ou traceroute sous Linux), suivie d’une adresse IP, affiche
les routeurs chemin parcouru par les datagrammes de notre ordinateur jusqu’à celui dont l’adresse
IP est indiquée. Il est ainsi possible de dresser une cartographie des routeurs présents entre une
machine source et une machine destinataire. Elle est notamment utilisée pour détecter un éventuel
point défaillant dans le réseau.
1) Taper la commande tracert www . google . com . Indiquer les adresses IP de départ et d’arrivée.
Donner le nombre de routeurs traversés.
2) Aller sur https : // gsuite . tools / traceroute . Sur cette page, on peut lire : "To track and map
the full path of an IP packet - This tool is based on Linux open-source utilities traceroute."
Indiquer dans quel pays se situe le serveur hébergeant le site. Tester par exemple avec
www . google . fr , www . marmiton . fr et www . lyc - descartes - montigny . ac - versailles . fr .
nslookup (Name System Look Up) est un outil permettant d’interroger un serveur DNS.
1) Taper la commande nslookup . Donner l’adresse IP du serveur DNS du réseau du lycée.
2) Entrer ensuite www . google . fr . Donner l’adresse du serveur qui héberge le site web.
3) Même chose pour le site www . wikipedia . org . Taper quit pour sortir.

Algorithmes gloutons
Exercice 21.1 (Introduction - rendu de monnaie)

Partie 1 : Comment rendre la monnaie ?
On s’intéresse à comment rendre la monnaie à la caisse d’un supermarché en utilisant le moins
de pièces et billets possibles. On suppose que la monnaie à rendre est une valeur entière (pas de
centimes d’euro) et que la caissière dispose, en quantité infinie, des pièces et billets suivants : 1, 2,
5 et 10 euros.
1) a) Lister toutes les façons de rendre 7 euros en monnaie ?
b) Quel est le rendu de monnaie qui minimise le nombre de pièces utilisées ?
2) En pratique, la caissière procède-t-elle comme à la question 1 pour rendre la monnaie ?
Décrire la méthode générale utilisée pour rendre la monnaie en utilisant le moins de pièces/-
billets.
3) Donner le rendu de monnaie de 27 euros ? Prouver que c’est le "meilleur" rendu de monnaie.
Partie 2 : la méthode de la caissière est-elle toujours celle qui minimise le nombre de pièces ?
Dans cette partie, on suppose que le système monétaire ne contient, en quantité illimitée, que trois
pièces différentes : 1, 3 et 4 euros.
1) En appliquant la méthode de la question 2 de la partie 1, quel est le rendu de monnaie de 6
euros ?
2) Est-ce le rendu de monnaie qui utilise le moins de pièces ? Justifier.
Partie 3 (après le cours) – Implémenter l’algorithme de rendu de monnaie du cours en Python.
Exercice 21.2 (Location de voitures) On considère le problème de la location d’une unique

voiture. Des clients formulent un ensemble de demandes de location avec, pour chaque demande,
le jour du début de la location et le jour de restitution du véhicule. Notre but ici est d’affecter le
véhicule de manière à satisfaire le maximum de clients possibles.
Voici un tableau synthétisant les demandes faites par 6 clients.
Clients A B C D E F
Jour de début de location 4 11 2 9 6 1
Jour de fin de location 7 15 5 12 10 14
1) On peut représenter les demandes de location de chaque client par un segment dont les extrémités
ont pour abscisses le jour de début et de fin de location. Ainsi, le client A serait représenté par :
Ajouter à ce graphique la représentation des clients B, C, D, E et F.

2) a) Les clients E et D peuvent-ils tous les deux louer la voiture ? Comment cela se traduit-il sur
le graphique précédent ?
b) Et pour les clients C et D ?
3) Trois élèves proposent une méthode "gloutonne" pour trouver la solution optimale au problème :
• Glouton 1 : on choisit le client qui demande à louer le plus tôt, puis, parmi les clients
restants, celui qui demande à louer le plus tôt et dont la demande ne se chevauche pas avec
celle des clients déjà choisis, et ainsi de suite... jusqu’à ce qu’on ne puisse plus ajouter de
clients.

• Glouton 2 : on choisit le client dont la durée de location est la plus courte, puis, parmi
les clients restants, celui dont la durée de location est la plus courte et qui ne se chevauche
pas avec les clients déjà choisis, et ainsi de suite... jusqu’à ce qu’on ne puisse plus ajouter de
clients.
• Glouton 3 : on choisit le client qui ramène le véhicule le plus tôt, puis, parmi les clients
restants, celui qui le ramène le plus tôt et qui ne se chevauche pas avec les clients déjà choisis,
et ainsi de suite... jusqu’à ce qu’on ne puisse plus ajouter de clients.
a) Donner la solution obtenue en appliquant chacun des trois algorithmes gloutons.
Quel algorithme donne la solution optimale ?
b) Démontrer que l’algorithme glouton de la question précédente donne toujours une solution
optimale, quel que soit le nombre de clients et leurs dates de location.
Exercice 21.3 (Problème du sac à dos) Ali Baba est enfin parvenu à entrer dans la caverne
des 40 voleurs, mais il ne pourra pas emporter toutes leurs richesses : il n’est capable de porter que
M kilogrammes dans son sac à dos.
Devant lui se trouvent des trésors en quantité illimitée dont les valeurs (prix et masse unitaires)
sont données dans le tableau ci-dessous :
Objets A B C D
Masse en kg 15 10 6 2
Prix en euros 240 200 114 20
1) Ali est très pressé et décide de remplir son sac avec les objets dont le prix est le plus élevé...
jusqu’à ce qu’il ne puisse plus mettre d’objets dans son sac. Donner la composition du sac d’Ali
lorsqu’il applique sa méthode sur un sac de capacité M = 11 kg.
2) Etudier les compositions d’un sac de capacité M = 27 kg : la méthode d’Ali pour remplir son
sac est-elle celle qui lui permet d’emporter le plus d’argent ? Justifier.
3) Proposer une méthode gloutonne plus efficace que celle d’Ali. Appliquer votre méthode à un sac
de capacité M = 13 kg. Est-ce la solution optimale ? Justifier.
4) Les objets volés par Ali sont en fait des sacs remplis de poudres précieuses : Ali n’est pas obligé
de prendre la totalité de l’objet mais peut n’en prendre qu’une partie. La méthode gloutonne
proposée à la question 3 donne-t-elle alors la solution optimale ?

Exercice 22.1 (Console) Observer les résultats suivants obtenus à la console.
>>> listeA =[2]*6

>>> listeA
[2 , 2 , 2 , 2 , 2 , 2]
>>> listeB =[1 ,2]*5
>>> listeB
[1 , 2 , 1 , 2 , 1 , 2 , 1 , 2 , 1 , 2]
>>> m a t r i c e C =[[1 ,2 ,3] ,[4 ,5 ,6]]
>>> m a t r i c e C [0]
[1 , 2 , 3]
>>> m a t r i c e C [0][1]
2
>>> m a t r i c e C [1][2]
6
Exercice 22.2 (Une matrice) On considère la matrice :

 
−3 1 0
A =  1 −1 2 
 
0 −3 5
1) Créer une liste nommée a représentant la matrice A.

Indication : Pour représenter une matrice en informatique, on utilise une liste dont tous les
items sont des listes. Chaque item est une liste contenant tous les coefficients d’une ligne.
2) Ecrire une fonction valabs(liste) qui retourne une nouvelle liste composée des items de la
liste liste sans leur signe. liste ne doit pas être modifiée.
Aide : on pourra utiliser la fonction abs(x) qui donne la valeur absolue du nombre x (c’est-
à-dire la valeur x sans son signe).
3) A l’aide de la fonction valabs(liste), construire une liste b par compréhension représentant
une matrice dont tous les coefficients sont égaux à ceux de A sans leur signe.
4) Créer une fonction somme(matrice) qui calcule la somme des coefficients d’une matrice.
Exercice 22.3 (Des dictionnaires) L’instruction suivante crée un tableau réunissant quelques
informations sur les clients d’un magasin. Pour plus de lisibilité, chaque ligne est un dictionnaire.
clients = [
{ ' nom ': ' G i l b e r t ' , ' prenom ': ' Jean ' , ' age ': ' 54 ' , ' genre ': 'm '} ,
{ ' nom ': ' Dupont ' , ' prenom ': ' Pierre ' , ' age ': ' 34 ' , ' genre ': 'm '} ,
{ ' nom ': ' Sylla ' , ' prenom ': ' Anne ' , ' age ': ' 48 ' , ' genre ': 'f '}
]
1) Ecrire une fonction qui affiche tous les clients dont l’âge est inférieur à 50. Qu’obtient-on ?
2) Ecrire une fonction qui affiche tous les clients de genre 'm'. Qu’obtient-on ?

Exercice 22.4 (Tableau mystérieux) Qu’obtient-on après l’exécution du script suivant ?
def t a b l e a u M y s t e r i e u x () :
monTab = [[0] * 9 for i in range (9) ]
for l in range (1 ,10):
for c in range (1 ,10):
monTab [l -1][ c -1] = l + c
return monTab
tab = t a b l e a u M y s t e r i e u x ()
print ( tab )
Exercice 22.5 (Tableau mystérieux - la suite) A partir du tableau tab obtenu dans l’exercice
précédent, qu’obtient-on après l’exécution du script suivant ?
def f M y s t e r e( nomTabl , tabl , nb ) :

for li in tabl :
if nb in li :
nli = tabl . index ( li )
ncol = li . index ( nb )
print ( nb , ' est dans ' , nomTabl , '[ ' , nli , ' ][ ' , ncol , '] ' , sep = ' ')
f M y s t e r e( ' tab ' ,tab ,5)
Exercice 22.6 (Base de données) L’entreprise KiStokTout possède une base de données dans
laquelle elle enregistre les informations personnelles de ses clients :
nom, prénom, adresse, âge, taille (en cm), poids (en kg).
Elle initialise cette base de données par la ligne suivante :
r e g i s t r e = [1 ,{ ' nom ': ' HILUM ' , ' pr é nom ': ' Mohan ' , ' a d r e s s e ': ' 224 avenue \
des fleurs 75001 Paris ' , ' age ' :67 , ' taille ' :178 , " poids " :81}]
où 1 est le numéro de ligne dans la base de données.

1) a) Quel est le type de la variable registre ?
b) Quel est le type de registre[0] ?
c) Quel est le type de registre[1] ?
2) a) Que retourne l’instruction registre[1]['nom'] ?

b) Quel est le type de registre[1]['nom'] ?
Exercice 22.7 (QCM) Pour chaque question, une seule réponse est correcte parmi les quatre
proposées.
1) Pour construire une table de 7 lignes et 7 valeurs remplie de 1, on utilise la syntaxe :
a) [1] * 7 for i in range(7) c) [[1] * 7 for i in range(7)]
b) for i in range(7)[1] * 7 d) [for i in range(7)[1] * 7]
2) On dispose d’une liste L = [[1,2,3],[4,5,6],[7,8,9]]. La valeur de L[1][2] est :

a) 2 b) 5 c) 6 d) 8
3) Après l’instruction L = [[i,i+1] for i in range(2)], la valeur de L est :

a) [[0,1],[1,2]] b) [[1,2],[2,3]] c) [0,1,1,2] d) [1,2,2,3]

4) On construit une matrice avec le code suivant :
[3 * [0] for i in range (3) ]
for i in range (3) :
m a t r i c e[ i ][ i ] = i + 1
m a t r i c e [0][ i ] = m a t r i c e [0][ i ] + i + 1
m a t r i c e[ i ][2] = m a t r i c e[ i ][2] + i + 1
Quel est le résultat obtenu ?

a) [[1,2,4],[0,2,2],[0,0,6]].
b) [[2,2,4],[0,2,2],[0,0,4]].
c) [[1,2,4],[0,2,4],[0,0,6]].
d) [[2,2,4],[0,2,2],[0,0,6]].
Exercice 22.8 (Variables) Quelles sont les valeurs des variables a et b ?

Vérifier avec l’interpréteur Python.
a = ((1 , 2 , 3) , (4 , 5 , 6) , (7 , 8 , 9) ) [1]
b = a [2]

Assembleur
Sources : document d’accompagnement du programme de NSI et site de David Roche :

https://pixees.fr/informatiquelycee/n_site/nsi_prem_sim_cpu.html
Il existe plusieurs langages assembleurs. Pour les exercices, on va travailler avec un simulateur
nommé AQA, développé par Peter L Higginson, et utiliser sa syntaxe. Les notations seront donc
un peu différentes de celles du cours et nous aurons accès à plusieurs registres (R0 à R12).
Sur la page http://peterhigginson.co.uk/AQA/info.html, on peut lire :
The AQA Instruction Set :
• LDR Rd, <memory ref> : Load the value stored in the memory location specified by
<memory ref> into register d.
• STR Rd, <memory ref> : Store the value that is in register d into the memory location spe-
cified by <memory ref>.
• ADD Rd, Rn, <operand2> : Add the value specified in <operand2> to the value in
register n and store the result in register d.
• SUB Rd, Rn, <operand2> : Subtract the value specified by <operand2> from the value in register
n and store the result in register d.
• MOV Rd, <operand2> : Copy the value specified by <operand2> into register d.
• CMP Rn, <operand2> : Compare the value stored in register n with the value specified by
<operand2>.
• B <label> : Always branch to the instruction at position <label> in the program.
• B<condition> <label> : Conditionally branch to the instruction at position <label> in the
program if the last comparison met the criteria specified by the <condition>.
Possible values for <condition> and their meaning are : EQ : Equal to, NE : Not equal to, GT :
Greater than, LT : Less than.
• HALT : Stop the execution of the program.
<operand2> can be #nnn or Rm to use either a constant or the contents of register Rm.
Exemples
• LDR R1,78 : Place la valeur stockée à l’adresse mémoire 78 dans le registre R1 (par souci de
simplification, nous continuons à utiliser des adresses mémoire codées en base 10).
• STR R3,125 : Place la valeur stockée dans le registre R3 en mémoire vive à l’adresse 125.
• ADD R1,R0,#128 : Additionne le nombre 128 (une valeur immédiate est identifiée grâce au
symbole #) et la valeur stockée dans le registre R0, place le résultat dans le registre R1.
• SUB R0,R1,R2 : Soustrait la valeur stockée dans le registre R2 de la valeur stockée dans le
registre R1, place le résultat dans le registre R0.
• MOV R0, R3 : Place la valeur stockée dans le registre R3 dans le registre R0.
• B 45 : Nous avons une structure de rupture de séquence, la prochaine instruction à exécuter
se situe en mémoire vive à l’adresse 45.
CMP R0 , # 23
• BEQ 78
Si la valeur stockée dans le registre R0 est égale à 23, la prochaine instruction à exécuter se
situe à l’adresse mémoire 78.

Exercice 23.1 (Lire) Expliquer les instructions suivantes
1) ADD R0, R1, #42

2) LDR R5,98
CMP R4 , # 18
3) BGT 77
4) STR R0,15
5) B 100
Exercice 23.2 (Ecrire) Ecrire des instructions en assembleur :
1) Additionner la valeur stockée dans le registre R0 et la valeur stockée dans le registre R1, le résultat
est stocké dans le registre R5.
2) Placer la valeur stockée à l’adresse mémoire 878 dans le registre R0.
3) Si la valeur stockée dans le registre R0 est égale à 42 alors la prochaine instruction à exécuter se
situe à l’adresse mémoire 85.
Exercice 23.3 (Comparer) Les instructions assembleur B, BEQ, BNE, BGT et BLT n’utilisent pas
directement l’adresse mémoire de la prochaine instruction à exécuter, mais des "labels". Un label
correspond à une adresse en mémoire vive. L’utilisation d’un label évite donc d’avoir à manipuler
des adresses mémoires en binaire ou en hexadécimale.
Comparer le programme écrit en Python et le même programme écrit en assembleur :
x = 4 MOV R0 , # 4
y = 8 STR R0 ,30
if x == 10: MOV R0 , # 8
y = 9 STR R0 ,75
else : LDR R0 ,30
x = x +1 CMP R0 , # 10
z = 6 BNE else
MOV R0 , # 9
STR R0 ,75
B endif
else :
LDR R0 ,30
ADD R0 , R0 , # 1
STR R0 ,30
endif :
MOV R0 , # 6
STR R0 ,23
HALT
A quoi correspondent les adresses mémoires 23, 75 et 30 ?
Exercice 23.4 (Premier essai) Le simulateur AQA, composé d’une RAM et d’un CPU, est basé
sur une architecture de von Neumann.
Adresse : http://www.peterhigginson.co.uk/AQA/.

On distingue différentes parties dans le simulateur.
• A droite, on trouve la mémoire vive ("main memory"). Chaque cellule de la mémoire possède
une adresse (de 000 à 199), ces adresses sont codées en base 10.
• Au centre, on trouve le CPU avec, du haut vers le bas :
– le bloc "registre" ("Registers") : nous avons 13 registres (R0 à R12) + 1 registre (PC)
qui contient l’adresse mémoire de l’instruction en cours d’exécution ;
– le bloc "unité de commande" ("Control Unit") qui contient l’instruction machine en cours
d’exécution (au format hexadécimal) ;
– le bloc "unité arithmétique et logique" ("Arithmetic and Logic Unit").
Nous ne nous intéresserons pas aux autres composants de la partie CPU.
• A gauche, on trouve la zone d’édition ("Assembly Language"), c’est dans cette zone que nous
allons saisir nos programmes en assembleur.
Dans la partie "éditeur" ("Assembly Language"), saisir les lignes de codes suivantes.
MOV R0 , # 42
STR R0 ,150
HALT
Une fois la saisie terminée, cliquez sur le bouton "submit". Vous devriez voir apparaitre des nombres
"étranges" dans les cellules mémoires d’adresses 000, 001 et 002 :

L’assembleur a fait son travail, il a converti les 3 lignes de notre programme en instructions ma-
chines, la première instruction machine est stockée à l’adresse mémoire 000 (elle correspond à MOV
R0,#42 en assembleur), la deuxième à l’adresse 001 (elle correspond à STR R0,150) et la troisième
à l’adresse 002 (elle correspond à HALT).
Par défaut, le contenu des différentes cellules de la mémoire est en base 10 (entier signé). A l’aide
du bouton "OPTIONS" situé en bas dans la partie gauche du simulateur, passer à un affichage en
binaire ("binary").
Vous devriez obtenir ceci :
Chaque cellule de la mémoire comporte ici 32 bits.

A l’adresse mémoire 000, on peut remarquer que l’octet le plus à droite, (00101010)2 , est bien égal
à (42)10 .
Repasser à un affichage en base 10 afin de faciliter la lecture des données présentes en mémoire
(bouton "OPTION"->"signed").
Pour exécuter notre programme, il suffit maintenant de cliquer sur le bouton "RUN". Vous allez voir
le CPU "travailler" en direct grâce à de petites animations. Si cela va trop vite (ou trop doucement),
vous pouvez régler la vitesse de simulation à l’aide des boutons "«" et "»". Un appui sur le bouton
"STOP" met en pause la simulation, si vous ré-appuyez une deuxième fois sur ce même bouton
"STOP", la simulation reprend là où elle s’était arrêtée.
Une fois la simulation terminée, vous pouvez constater que la cellule mémoire d’adresse 150, contient
bien le nombre 42 (en base 10). Vous pouvez aussi constater que le registre R0 a bien stocké le nombre
42.
ATTENTION : pour relancer la simulation, il est nécessaire d’appuyer sur le bouton "RESET" afin
de remettre les registres R0 à R12 à 0, ainsi que le registre PC (il faut que l’unité de commande
pointe de nouveau sur l’instruction située à l’adresse mémoire 000). La mémoire n’est pas modifiée
par un appui sur le bouton "RESET", pour remettre la mémoire à 0, il faut cliquer sur le bouton
"OPTIONS" et choisir "clr memory". Si vous remettez votre mémoire à 0, il faudra cliquer sur le
bouton "ASSEMBLE" avant de pouvoir exécuter de nouveau votre programme.
Exercice 23.5 (Modification) Modifier le programme précédent pour qu’à la fin de l’exécution,
on trouve le nombre 54 à l’adresse mémoire 50. On utilisera le registre R1 à la place du registre R0.
Tester vos modifications en exécutant la simulation.

Algorithmes kNN
Exercice 24.1 (Classification n°1) Dans la figure ci-dessous, on connaît la classe de 6 points
(cercles pleins bleus et croix rouges). On souhaite classer les points (4 ;3) et (1,5 ;2,8) en se basant
sur la classe du point le plus proche.
Exercice 24.2 (Classification n°2) On considère des points représentés par un cercle ou une
croix, représentés sur la figure ci-dessous.
Les coordonnées d’un point sont ses attributs, et sa représentation graphique (cercle ou croix) est
sa classe. Ainsi le point K a pour attributs (3 ;4) et pour classe croix.
• En appliquant l’algorithme 1-NN, attribuer une classe parmi cercle ou croix aux points suivants :
A(1 ;8), B(5 ;5), C(6 ;3), D(6 ;8) et E(9 ;6).
• Même chose avec l’algorithme 3-NN.
• Même chose avec l’algorithme 5-NN.
Exercice 24.3 (Classification n°3) Dans la figure, les points appartiennent à 2 classes appelées
A et B. L’ordre de sélection des points est indiqué par les indices situés à côté de chacun. Les points
1 à 4 sont déjà classés ; on applique donc l’algorithme en commençant avec le point 5.
1) Appliquer la méthode des kPPV avec k=3. Ecrire la classe résultante à côté de chaque point.

2) Montrer par un exemple que le résultat de la classification dépend de l’ordre de présentation
des exemples.
Exercice 24.4 (Classification et programme Python) On considère des points caractérisés

par une abscisse, une ordonnée et une couleur ("rouge" ou "vert"). Ainsi le point A(-3,4.7,"rouge")
a pour abscisse -3, pour ordonnée 4.7 et pour couleur "rouge".
La fonction suivante a pour but de renvoyer la couleur d’un nouveau point, sous forme d’une chaîne
de caractères, en fonction des coordonnées du point et de la couleur de son plus proche voisin. La
décision se fait selon l’algorithme 1-NN.
1) Compléter cette fonction sachant qu’elle attend en entrée :
• une liste de points existants, tous définis par trois valeurs (abscisse, ordonnée, couleur) de
type (float, float, string),
• un nouveau point, aussi défini par trois valeurs (abscisse, ordonnée, None).
def c l a s s e 1 n n( listePoints , point ) :

d i s t a n c e M i n = float ( ' inf ') # valeur m a x i m a l e d ' un f l o t t a n t
voisin = None # i n i t i a l i s a t i o n du voisin
for j in range (...) :
# f o n c t i o n d i s t a n c e r e n v o y a n t la d i s t a n c e ( float ) entre 2 points
d = d i s t a n c e( point , l i s t e P o i n t s [ j ])
if d < ... :
...
...
return ...
2) Ecrire la fonction distance qui prend en entrée deux points et renvoie la distance entre ces deux
points.
3) Faire tourner le programme avec les données de l’exercice 1.
4) Généraliser pour déterminer la couleur d’un point en se basant sur les k points les plus proches
(k impair). On suppose toujours qu’il y a deux couleurs possibles.
Faire tourner avec les données de l’exercice 2.

Exercice 25.1 (Somme alternée) Ecrire un programme qui réalise les étapes suivantes, en
utilisant les variables a de type liste d’entiers et res de type entier :
1) Créer une liste a qui contient les entiers de 1 à 10.
2) Soit n =len(a). Calculer la somme a[0] − a[1] + a[2] − a[3] + . . . a[n − 1] dans res.
Exercice 25.2 (Somme alternée n°2) Reprendre l’exercice précédent en lui ajoutant une liste
b pour enregistrer le calcul des termes intermédiaires, c’est-à-dire :
b[0] = a[0]
b[1] = a[0] − a[1]
b[2] = a[0] − a[1] + a[2]
..
.
b[n − 1] = a[0] − a[1] + a[2] + . . . a[n − 1]
Exercice 25.3 (Mettre de l’ordre) Dans chaque cas, tester la fonction avec la liste suivante :
['toto','bonjour','a','oui','non'].
1) Ecrire une fonction ordre1 qui prend en argument une liste de mots et modifie la liste en
ordonnant les mots en fonction du nombre de lettres de chaque mot. La fonction ne renvoie rien.
2) Ecrire une fonction ordre2 qui prend en argument une liste de mots et renvoie la liste des mots
ordonnée en fonction du nombre de lettres de chaque mot. La liste passée en paramètre ne doit
pas être modifiée.
Exercice 25.4 (Fusion de listes) Ecrire une fonction fusion qui prend deux listes en paramètres
et retourne une nouvelle liste obtenue en alternant les éléments des deux listes, par exemple merge
([1,3], [2,4]) renvoie [1,2,3,4].
Si une liste est plus longue que l’autre, ses éléments sont ajoutés à la fin du résultat. Par exemple
fusion([1,3], [2,4,5,6]) renvoie [1,2,3,4,5,6].
Exercice 25.5 (Divisibilité) Ecrire un programme qui calcule le plus petit entier divisible par
tous les nombres de 1 à 10.
Exercice 25.6 (Triangle de Pascal) Le triangle de Pascal est une présentation des coefficients
binomiaux sous forme de triangle.
Les premières lignes sont données par
1
11
12 1
13 31
14 641
15 10 10 5 1
...
La première ligne est 1. Pour les autres lignes, le j e élément (sauf le dernier) de la ligne i est la
somme des j e et (j − 1)e éléments de la ligne i − 1. Le dernier élément est 1.
Ecrire la fonction tp qui prend un entier n en paramètre et affiche les n premières lignes du triangle
de Pascal.

Exercice 25.7 (Etudiants) Ecrire une fonction qui prend en entrée une chaîne de caractères
comprenant, sur chaque ligne, trois champs séparés par des caractères ’ ;’ (un numéro d’étudiant,
un nom et un prénom) et retourne un dictionnaire dont les clés sont les numéros d’étudiants lus et
les valeurs sont, pour chaque numéro d’étudiant, une chaîne correspondant à la concaténation des
prénom et nom de la personne. On pourra tester la fonction avec la chaîne suivante :
c h a i n e E t u d i a n t s = ''' 2 1 3 6 1 5 2 0 0 ; B E S N I E R; JEAN
2 1 3 5 6 5 4 8 8 ; DUPOND ; MARC
2 1 4 6 6 5 5 5 5 ; DURAND ; JULIE '''
Exercice 25.8 (Meilleure moyenne) Ecrire une fonction qui prend en entrée un dictionnaire
associant à un nom une liste de notes et qui retourne la liste des noms des personnes qui ont la
moyenne la plus élevée (s’il y a des ex-aequo, cette liste contiendra plusieurs éléments, sinon, elle
n’en contiendra qu’un) et la moyenne correspondante.
On pourra utiliser le dictionnaire suivant pour tester la fonction ainsi écrite :
notes = {"Anne": [1, 5, 12], "John": [15, 16, 19], "Paul": [5, 12], "Nicolas": []}
Exercice 25.9 (Atteindre une somme fixée) On cherche à atteindre le total de 100 dans une
liste de nombres. On considère une liste de n entiers compris entre 1 et 99 (inclus).
Par exemple, la liste de n = 20 entiers :
[16,2,85,27,9,45,98,73,12,26,46,25,26,49,18,99,10,86,7,42]
qui a été obtenue au hasard par la commande :
liste20 = [randint(1,99) for i in range(20)].
On cherche différentes manières de trouver des nombres de la liste dont la somme fait exactement
100.
1) Ecrire une fonction sommeDeuxConsecutifs100(liste) qui teste s’il existe deux éléments consé-
cutifs de la liste dont la somme vaut 100. La fonction renvoie True ou False (mais elle peut
aussi afficher les nombres et leur position, pour vérification). Pour l’exemple donné la fonction
renvoie False.
2) Ecrire une fonction sommeDeux100(liste) qui teste s’il existe deux éléments de la liste, situés à
des positions différentes, dont la somme vaut 100. Pour l’exemple donné la fonction renvoie True
et peut afficher les entiers 2 et 98 (aux rangs 1 et 6 de la liste).
3) Ecrire une fonction sommeSuite100(liste) qui teste s’il existe des éléments consécutifs de la liste
dont la somme vaut 100. Pour l’exemple donné, la fonction renvoie True et peut afficher 25, 26,
49 (aux rangs 11, 12 et 13).
Exercice 25.10 (Diviseurs)

1) On considère le code Python de la fonction d suivante :
def d ( n ) :
L = [1]
for nombre in range (2 , n +1) :
if n % nombre == 0:
L . append ( nombre )
return L
Quel est le résultat de l’appel d(4) ? Puis de l’appel d(10) ? Que fait la fonction d ?
2) Un diviseur non-trivial d’un entier n est un diviseur de n différent de 1 et de n. Écrire une
fonction DNT, d’argument n, utilisant d(n) et renvoyant la liste des diviseurs non-triviaux de
l’entier n.
3) Écrire une fonction SommeCarresDNT, d’argument n, renvoyant la somme des carrés des diviseurs
non-triviaux de l’entier n.
4) Ecrire la suite des instructions permettant d’afficher tous les nombres entiers inférieurs à 1000
et égaux à la somme des carrés de leurs diviseurs non-triviaux. Que peut-on conjecturer ?

Exercice 25.11 (Vérification d’un carré magique) Un carré magique est un arrangement
de nombres différents, généralement entiers, dans un tableau dont la somme des éléments sur les
lignes, les colonnes et les diagonales sont identiques. On note n la taille des lignes et des colonnes,
et on parle de carré magique d’ordre n.
Les tableaux de valeurs sont stockés dans des listes de listes, de telle sorte que T[i][j] permettra
d’accéder à l’élément de la ligne i et de la colonne j.
Le but de l’exercice est d’écrire des fonctions permettant de vérifier qu’un tableau passé en argument
est bien un carré magique.
Dans un premier temps, la fonction de vérification doit calculer la somme de chaque ligne, de chaque
colonne et de chaque diagonale en stockant le résultat dans une liste, puis on effectue la vérification
du carré magique.
1) Ecrire une fonction verifCarre1(T), qui vérifie dans ces conditions si le tableau T correspond à
un carré magique ou non.
2) Déterminer la complexité de la fonction en comptant le nombre d’additions et de comparaisons
réalisées dans le meilleur et le pire des cas en fonction de n.
3) Proposer une nouvelle fonction verifCarre2(T) pour améliorer ses performances et donner la
complexité dans le meilleur et le pire des cas

Réseaux - Filius
Les exercices sont adaptés d’un document de travail proposé par Jean-Philippe Toureau, lui-même
inspiré du guide réalisé par Daniel Garmann.
Filius dispose de 3 modes : design (marteau), simulation (flêche verte) et documentation (crayon).
Pour les clients, nous prendrons des Portables et pour les serveurs, nous prendrons des Ordinateurs.
Pour voir la configuration d’un poste, double-clic ou clic droit puis configure.
Exercice 26.1 (Lien direct)

• Relier 2 portables en lien direct
• Nommer le premier portable M0.10. Observer l’adresse IP 192.168.0.10 et le masque 255.255.255.0.
• Nommer le second portable M0.11. Modifier son adresse IP en 192.168.0.11.
Exercice 26.2 (Echange de données)

• Passer en mode simulation
• Cliquer sur le poste M0.10 et installer Ligne de commande (cliquer sur le nom du logiciel puis sur
la flèche verte vers la gauche puis appliquer les modifications).
• Cliquer sur Ligne de commande pour l’ouvrir et faire un ping vers 192.168.0.11 (c’est-à-dire taper
la commande ping 192.168.0.11). On observe que le lien entre M0.10 et M0.11 devient vert un
court instant, illustrant l’échange de données.
• Faire un clic droit sur M0.10 pour afficher les données échangées. On remarque que seule la
couche Internet est utilisée.
• Faire un ipconfig (c’est-à-dire ouvrir l’invite de commande et taper la commande ipconfig)
Exercice 26.3 (Switch)

• Relier 3 ordis à un switch
• Définir comme IP 192.168.0.10, 192.168.0.11 et 192.168.0.12.

Exercice 26.4 (Client-Serveur)
• Installer sur le serveur un Serveur Générique (cliquer ensuite sur l’application Serveur Géné
rique, vérifier que le port est à 55555 et le démarrer).
• Sur un des portables, installer un client Générique. Cliquer ensuite sur l’application Client G
énérique, connecter le client au serveur (indiquer son adresse IP) puis envoyer un message au
serveur.
• Observer les échanges. On remarque que la couche de transport est utilisée cette fois.
Exercice 26.5 (Routeur)

• Ajouter un second réseau local avec 3 nouveaux ordinateurs reliés à un switch.
• Définir des IP allant de 192.168.1.10 à 192.168.1.12.
• Connecter les 2 réseaux à l’aide d’un routeur dont les cartes d’interface seront configurées avec les
IP 192.168.0.1 (pour les ordinateurs de gauche) et 192.168.1.1 (pour les ordinateurs de droite).
Tester la connexion entre les postes 0.10 et 1.10 avec la commande ping. Que se passe-t-il ?
Normalement, vous devez obtenir un message Destination inaccessible parce que le message a
besoin de quitter le réseau local et que nous n’avons pas encore configuré la passerelle entre les
différents postes.
Exercice 26.6 (Passerelle)

• Pour chacun des 3 ordinateurs de gauche, indiquer 192.168.0.1 pour la passerelle (gateway en
anglais).
• Pour chacun des 3 ordinateurs de droite, indiquer 192.168.1.1 pour la passerelle.
• Tester à nouveau la connexion entre les postes 0.10 et 1.10.
• Essayer d’accéder au Serveur0.12 via un ping depuis le poste 1.10 (après avoir installé un client
générique et établi la connexion avec le serveur).

Exercice 26.7 (Simulation du web) Avec Filius nous pouvons simuler et analyser les processus
impliqués dans la communication entre un navigateur et un serveur distant.
Pour cela, le réseau créé à l’exercice précédent suffit. Nous garderons le serveur 0.12 et comme
client, nous prendrons le poste 1.10 sur lequel sera installé un navigateur.
• Sur le serveur 0.12, installer un serveur web et un éditeur de texte.
• Utiliser l’éditeur de texte pour ouvrir le fichier index.html qui se trouve sur le répertoire root
/webserver. Le modifier pour qu’il affiche une des pages créées lors des exercices sur le langage
HTML. Sauvegarder.
• Sur le bureau de votre serveur web, lancer l’application serveur web avec un double-clic. Appuyer
sur Démarrer.
• Aller sur le bureau du poste 1.10 et installer un navigateur web. Le lancer et essayer de se
connecter au serveur 0.12 en tapant l’URL http://192.168.0.12 dans la barre d’adresse du
navigateur puis Afficher.
Normalement, la connexion s’établit mais en fait ce n’est pas comme ça que l’on s’adresse à un
serveur. En réalité on contacte un serveur à l’aide d’une URL et non d’une adresse IP. Un serveur
de noms de domaine (ou DNS) va traduire l’une en l’autre.
Exercice 26.8 (Serveur DNS)

• Ajouter un nouveau serveur d’adresse IP 192.168.2.10 et comme passerelle 192.168.2.1.
• Le nombre d’interfaces du routeur doit donc passer à 3. Pour le faire, il faut aller dans le tableau
general du routeur puis appuyer sur le bouton Gérer les connexions et renseigner pour la
nouvelle branche du routeur l’adresse IP 192.168.2.1
• Pour permettre à tous les postes d’utiliser les services du DNS, il faut ajouter l’adresse IP du
DNS dans la configuration de tous les ordinateurs du réseau.
• Sélectionner le serveur DNS 2.10 et y installer l’application DNS server. La lancer avec un double
clic.
• Donner au serveur web une URL classique et la communiquer au DNS pour qu’il puisse la
traduire en adresse IP. Plus précisément, prendre comme nom de domaine www.NSI.com et comme
adresse IP 192.168.0.12 puisqu’il est hébergé sur le serveur 0.12. Appuyer sur le bouton Ajouter.
• Activer le DNS en appuyant sur le bouton Démarrer.
• Tester la connexion à partir du poste 1.10 en demandant d’accéder à l’URL
http://www.NSI.com.
• Installer Ligne de commande sur le serveur DNS et taper la commande host www.NSI.com. On
observe que le DNS fait son travail en fournissant l’adresse IP du serveur web.

Sites web dynamiques et PhP
Exercice 27.1 (Premier script PHP)

1) Ecrire les codes HTML et CSS de la page index.html suivante :
Le formulaire a pour cible le script conversionEuroDollar.php et passe trois paramètres en

méthode GET :
• valeur qui indique la somme à convertir et qui est défini par un champ textuel requis, de
taille 20 et limité à six caractères,
• taux qui indique le taux de conversion euro vers dollar (combien de dollars on reçoit pour un
euro) et qui est défini par un champ textuel requis, de tailles 20 et limité à cinq caractères,
• devise qui indique la devise (euro ou dollar) de la somme à convertir et qui est défini par
des boutons radios.
2) Le fichier conversionEuroDollar.php contient un code partiel du script PHP gérant le formulaire
de la question 1.
a) Indiquer les lignes correspondantes à du code HTML et à du code PHP.
b) Expliquer les lignes 13 à 15, puis les lignes 17 à 19.
c) Compléter la ligne 21 afin qu’elle indique la date et l’heure auxquelles ont été effectuées la
simulation.
d) A quoi correspondent les lignes 23 à 32 ? Compléter les puis tester le formulaire.
3) Compléter le script conversionEuroDollar.php de façon à ce qu’il puisse afficher la page suivante :
4) Toutes les données issues d’un formulaire sont des chaînes de caractères mais PHP procède à des
transtypages automatiquement pour gérer les calculs ou autres. Toutefois, il se peut qu’il puisse
y avoir des problèmes si les données fournies ne peuvent pas être transtypées correctement.
a) Saisir dans le champ valeur la donnée 200a et une valeur numérique dans le champ taux.
Qu’observe-t-on ?
b) Saisir à présent une valeur numérique dans le champ valeur et la donnée 0,453 dans le
champ taux. Qu’observe-t-on ?

c) Compléter le script conversionEuroDollar.php de façon à ce qu’il affiche la page de la ques-
tion 3 si les données saisies dans le formulaire sont correctes et la page suivante dans le cas
contraire :
Indication : La fonction is_numeric détermine si une variable est un nombre ou une chaîne
numérique. Par exemple, si on souhaite tester si la variable val est bien un nombre, on
pourra utiliser le code suivant.
if (is_numeric($val)) {
...
}
else {
echo "erreur";
}
Exercice 27.2 (Conversion de grandeurs) Les codes CSS, JavaScript et PHP seront écrits
dans des fichiers externes.
1) Ecrire le code HTML de la page suivante :
Lorsque l’on clique sur l’un des boutons radios, la page est complétée par le formulaire choisi
qui est constitué d’un champ textuel requis et de deux listes déroulantes.
Par exemple, en cliquant sur le bouton radio aire, on obtient la page suivante :
2) Ecrire un script PHP permettant de gérer les différents formulaires de conversion. Il testera en
particulier la validité de la donnée saisie dans le champ textuel et renverra un message d’erreur
le cas échéant. Par exemple, dans le cas où la donnée saisie est correcte, il permettra d’afficher
la page

et, dans le cas contraire, la page
Exercice 27.3 (Gestion de fichier) On reprend le fichier Proverbes.txt qui contient onze
proverbes de sept mots.
Indication : On donne un extrait de code qui peut être utile pour l’exercice.
$P = $_GET['proverbe'];
$F = fopen('Proverbes.txt','r');
for($i=1;$i<=$P;$i++){
$ligne = trim(fgets($F));
}
fclose($F);
$mots = explode(' ',$ligne);
1) Ecrire le code du formulaire suivant :
La première liste déroulante indiquera le numéro du proverbe et la seconde liste déroulante

indiquera tout si l’on veut tout le proverbe ou le numéro d’un mot dans le proverbe. Lorsque
l’on cliquera sur le bouton Valider, il faudra une confirmation de validation.
2) Ecrire un script PHP gérant le formulaire et renvoyant la page
si l’on a demandé tout le proverbe, ou la page
si l’on a demandé un mot particulier dans le proverbe.

Exos Complet 1 e

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Exos Complet 1 e

Transféré par

Droits d'auteur :

Formats disponibles

Première NSI - Exercices

Table des matières

1 Introduction à Python - Série 1 2

2 Introduction à Python - Série 2 5

3 Représentation des nombres entiers naturels 7

7 Représentation des entiers relatifs 15

9 Sites web statiques - HTML et CSS 18

11 Algorithmes de recherche séquentielle et de tri 24

14 Sites web statiques - Javascript 30

15 Algorithmes de recherche dichotomique 33

16 Représentation des caractères et des nombres réels 35

17 Traitement de données en tables 37

18 Système d’exploitation Linux 42

19 Exercices variés Python - Série 1 46

22 Exercices variés Python - Série 2 53

25 Exercices variés Python - Série 3 62

27 Sites web dynamiques et PhP 68

Première NSI - Lycée Descartes - V. de Clippel 1

>>> 11/4 >>> 11%4

Exercice 1.2 (Console 2) Observer les résultats obtenus dans la console.

1) Quelle est la différence entre les variables a et alpha ?

Exercice 1.3 (Console 3) Observer les résultats obtenus dans la console.

1) Quel est le type de la variable msg ? Comment vérifie-t-on cela ?

# Bloc 1 # Bloc 2 # Bloc 3 # Bloc 4

Première NSI - Lycée Descartes - V. de Clippel 2

Exercice 1.6 (Range) On considère les programmes suivants.

# Programme 1 # Programme 2 # Programme 3

Dans chaque cas, que vaut a après l’exécution ?

Exercice 1.10 (Année bissextile)

Première NSI - Lycée Descartes - V. de Clippel 3

from turtle import *

Exercice 1.14 (Triangle) Ecrire un programme qui trace un triangle équilatéral.

Première NSI - Lycée Descartes - V. de Clippel 4

Fonction double() def double () :

Qu’obtient-t-on si on tape double() à la console ?

1) Ecrire un script affichant la somme disponible sur le compte au bout de 20 ans.

Première NSI - Lycée Descartes - V. de Clippel 5

1 from turtle import *

1) Ecrire un programme permettant de tracer un carré de côté 100 avec la tortue.

Première NSI - Lycée Descartes - V. de Clippel 6

Exercice 3.1 (Conversions 1) Convertir en base 10 :

Exercice 3.2 (Conversions 2)

Exercice 3.3 (Conversions 3) Convertir les nombres suivants

Exercice 3.4 (Conversions 4) Convertir les nombres suivants :

Exercice 3.5 (Opérations 1) Effectuer les opérations suivantes en binaire :

Exercice 3.6 (Multiplication par 2)

Exercice 3.9 (Couleurs) Compléter le tableau ci-dessous.

Composants (rouge vert bleu)

Première NSI - Lycée Descartes - V. de Clippel 7

2) Que se cache-t-il derrière la loi Mystere ?

Première NSI - Lycée Descartes - V. de Clippel 8

Exercice 4.1 (Console) Observer les résultats obtenus dans la console.

Première NSI - Lycée Descartes - V. de Clippel 9

print ( " liste1 : " , liste1 )

Première NSI - Lycée Descartes - V. de Clippel 10

Exercice 5.2 (Listes aléatoires)

On veillera à coder ces fonctions en une ligne.

Exercice 5.4 (Coïncidences)

Exercice 5.5 (Différences) Ecrire une fonction nbIndicesDifferents(tab1,tab2) qui prend en

Première NSI - Lycée Descartes - V. de Clippel 11

l i s t e F r e q = [ elem /100 for elem in l i s t e E f f]

Première NSI - Lycée Descartes - V. de Clippel 12

>>> tuple1 = () # tuple vide