Numérique et Science Informatique Révisions des notions de première Notions indispensables pour la terminale

Numérique et Science Informatique Révisions des notions de première

Notions indispensables pour la terminale

1

partie : révision de la programmation python.

➢ Liste – Chaîne de caractère - tuple et dictionnaire Révisions de base pour les listes :

• Ecrire une liste contenant les éléments : 7,6,12,5,2

• Afficher le 2^ème élément de cette liste

• Ajouter à la fin de la liste la valeur : 6

• Enlever à la liste l’élément : 2

• Enlever à la liste son 1^er élément

• Remplacer le 3^ème élément par la valeur 8

• Afficher tous les éléments de la liste en utilisant une boucle for qui parcourt les indices de la liste puis une autre boucle for qui parcourt les éléments de la liste

• Ecrire une liste par compréhension des 20 premiers entiers au carré et afficher-là.

• Ecrire une liste contenant 10⁶ éléments compris entre 1 et 10 000 (utiliser le module randint de la librairie random ) Ne pas afficher cette liste.

Révisions de base pour les tuples :

• Ecrire un tuple des valeurs 7,6,12,5,2

• Afficher le 2^ème élément de ce tuple

• Remplacer le 3^ème élément par la valeur 8

• Enlever au tuple la valeur 2

• Quelle particularité des tuples est mis en évidence avec les deux questions précédentes ? Avec quel autre type de données retrouve-t-on le même phénomène ?

• Afficher tous les éléments du tuple en utilisant une boucle for Révisions de base pour les chaînes de caractères

• Ecrire une chaine de caractères au choix.

• Afficher le 2^ème élément de la chaine

• Modifier le 3^ème caractère de la chaine par un caractère au choix.

Révisions de base pour les dictionnaires

• Ecrire un dictionnaire qui a pour clés les prénoms des élèves de la classe et comme valeur correspondante à chaque clé le nom. On se limitera à 5 entrées.

• Afficher la valeur d’une clé (celle que vous voulez)

• Ajouter au dictionnaire, un couple clé/valeur correspondant au prénom/nom de votre enseignant.

• Supprimer alors cette nouvelle donnée (merci de ne pas exprimer une joie incommensurable au moment de la supprimer)

• Ecrire une boucle qui permet l’affichage de toutes les clés. Puis de toutes les valeurs. Puis des couples clé/valeurs.

Exercices

Exercice 1 *

On dispose ici de deux tableaux de même longueur. Il s'agit de calculer le nombre de différences entre les deux tableaux. Par exemple avec :

tab_1 = ['a', 'g', 'u', 'u', 'c', 'o', 'p', 'l', 'm', 'v', 'p']

tab_2 = ['a', 'g', 's', 'u', 'c', 'k', 'p', 'l', 't', 'v', 'p']

il y a trois différences entre les deux tableaux : aux indices 2, 5 et 8. Question 1 :

Compléter la fonction compter_differences ci-dessous qui prend en paramètre deux tableaux tab_1 et tab_2 de même longueur et renvoie le nombre de différences entre les deux tableaux.

Question 2 : Pour quelle raison était-il difficilement envisageable d'effectuer un parcours par élément ?

def compter_differences(tab_1, tab_2):

compteur = ...

for ... in range(...) : if ... != ...:

compteur = ... + ...

return ...

Exercice 2 *

La factorielle d'un entier n, positif ou nul, vaut :

• le produit des entiers de 1 à n si n est supérieur ou égal à 1,

• 1 si n est égal à 0.

Question 1 :

Compléter la fonction factorielle ci-dessous qui prend en paramètre un entier n >= 0 et renvoie la factorielle de ce nombre.

On réfléchira à la valeur initiale de la variable facto.

Question 2 :

Compléter l'instruction ci-dessous afin d'obtenir un tableau avec les 51 premières factorielles, c'est à dire ce tableau :

[1, 1, 2, 6, 24, 120, 720, ... ,

30414093201713378043612608166064768844377641568960512000000000000]

premieres51 = [ ... for ... in .... ]

Exercice 3 *

À un jeu de plateau, il faut lancer un dé cinq fois et calculer un score.

On calcule le score comme suit :

• le score est égal à la somme des dés,

• si le dernier dé est un cinq alors le score est diminué de neuf points,

• si le dernier dé est un six alors le score est doublé.

Compléter la fonction ci-contre qui prend en argument un seul 5- uplet correspondant au lancer de cinq dés et calcule le score

correspondant (Attention : la fonction ne prend PAS en argument cinq entiers !).

Exercice 4 *

On souhaite décorer des chaînes de caractères en leur rajoutant des caractères de décoration aux extrémités. Plus précisément on souhaite leur rajouter les caractères suivants à gauche :

'☆✶✧✲⁕✫_'

Et les mêmes dans l'ordre inverse du côté droit : '_✫⁕✲✧✶☆'

Par exemple, la version décorée de la

chaîne 'bonjour' est '☆✶✧✲⁕✫_bonjour_✫⁕✲✧✶☆'. Question 1 :

Compléter la fonction etoiler_chaines ci-dessous qui prend en paramètre tab un tableau de chaînes de caractères et renvoie un nouveau tableau nv_tab dont les éléments sont les chaînes de caractères de tab en versions étoilées.

Question 2 :

Dans votre définition du tableau nv_tab en compréhension, avez-vous choisi de parcourir tab par indice ou par élément ?

Exercice 5 *

Compléter la fonction fois_deux qui prend en paramètre un tableau de nombres entiers et renvoie un nouveau tableau comportant les mêmes nombres multipliés par deux.

from random import randint def score(des):

score = des[0] + ... + ... + ... + ...

if ... == ... : score = ...

elif ... == ... : score = ...

return ...

def factorielle(n):

facto = ...

for ... in range(..., ...) : facto = ... * ...

return ...

def etoiler_chaines(tab):

nv_tab = [ ... + ... + ... for ... in ... ] return nv_tab

def fois_deux(tab):

nv_tab = [ ... * ... for ... in ... ] return nv_tab

Exercice 6 **

Question 1 :

Compléter la fonction mot_le_plus_long ci-dessous qui prend en paramètre un tableau non vide tab de mots et renvoie un 2-uplet constitué :

• du mot le plus long,

• et de la longueur de ce mot le plus long.

En cas d'égalité entre plusieurs mots ayant la longueur maximale, on renverra celui ayant le plus petit indice.

Question 2 :

Modifier votre fonction pour qu'en cas d'égalité, elle renvoie le mot le plus long ayant le plus grand indice.

Question 3 (facultative) :

Modifier votre fonction pour qu'elle renvoie une liste contenant tous les mots de longueur maximale.

Exercice 7 **

La méthode format de python, qui utilise une syntaxe un peu cryptique, permet de facilement transformer des nombres en chaînes de caractères de longueur donnée (en complétant avec des espaces ou des zéros), afin de faciliter l'alignement sur plusieurs lignes :

#exemple sans formatage

ch = str(12) + '\n' + str(17567) + '\n' + str(3) + '\n' + str(7410) print(ch)

#exemple avec formatage à base d'espaces

ch = '{:05}'.format(12) + '\n' + '{:05}'.format(17567) + '\n' + '{:05}'.format(3) + '\n' + '{:05}'.format(7410)

print(ch)

#exemple avec formatage à base d'espaces

ch = '{:5}'.format(12) + '\n' + '{:5}'.format(17567) + '\n' + '{:5}'.format(3) + '\n' + '{:5}'.format(7410)

print(ch)

On cherche à obtenir une chaîne de caractères correspondant à une table de multiplication d'entiers compris entre 0 et n.

| 0 1 2 3 4 5 6 --- 0 | 0 0 0 0 0 0 0 1 | 0 1 2 3 4 5 6 2 | 0 2 4 6 8 10 12 3 | 0 3 6 9 12 15 18 4 | 0 4 8 12 16 20 24 5 | 0 5 10 15 20 25 30 6 | 0 6 12 18 24 30 36

On ne représentera pas la première ligne ni la première colonne mais juste le tableau intérieur à partir de la ligne et de la colonne de zéros, c'est à dire cela :

0 0 0 0 0 0 0 0 1 2 3 4 5 6 0 2 4 6 8 10 12 0 3 6 9 12 15 18 0 4 8 12 16 20 24 0 5 10 15 20 25 30 0 6 12 18 24 30 36

def mot_le_plus_long(tab):

longueur_max = len( tab[0] ) mot_max = tab[0]

for mot in tab :

if ... > longueur_max : longueur_max = ...

mot_max = ...

return ..., ...

def mots_le_plus_long(tab):

longueur_max = len( tab[0] ) mots_max = [ tab[0] ]

# mots_max (avec un s) est une liste

# pouvant contenir tous les meilleurs mots for i in range(1, len(tab)) :

mot = tab[i]

if ... > longueur_max : longueur_max = ...

mots_max = [ ... ] elif ... == longueur_max : mots_max.append( ... )

return ..., ...

Question 1 :

Quel est le caractère que l'on va devoir mettre à la fin de chaque ligne pour obtenir un saut de ligne : '\n', '/n', '\s' ou '/s' ?

Question 2 :

Compléter la fonction table_de_multiplication ci- contre qui prend en paramètre un entier n tel

que 0<=n<=30 et renvoie une chaîne de caractères correspondant à la table de multiplication des entiers entre 0 et n.

Tester votre fonction ci-dessous :

print(table_de_multiplication(22))

Exercice 8 *

En programmation informatique, une permutation consiste à intervertir les valeurs de deux

variables. Il s'agit d'une opération courante, mais rarement intégrée aux langages de programmation et jeu d'instructions des processeurs.

De nombreux algorithmes, en particulier des algorithmes de tri, utilisent des permutations.

Pour un tableau on peut facilement permuter deux valeurs en utilisant la double affectation (qui utilise sans le montrer des 2-uplets). Par exemple pour permuter les

valeurs 999999999 et 333 d'indices 2 et 8 dans le tableau suivant : tab = [1, 22, 999999999, 4444, 55555, 666666, 7777777, 88888888, 333]

C'est à dire effectuer :

_______________________________________________

| | V | [1, 22, 999999999, 4444, 55555, 666666, 7777777, 88888888, 333]

| Λ |_______________________________________________|

Il suffit d'écrire l'instruction suivante : tab[2], tab[8] = tab[8], tab[2]

Il est primordial de noter qu'une permutation ainsi effectuée est une mutation du

tableau qui ne nécessite pas de créer un nouveau tableau. En conséquence, sur un tableau passé en paramètre à une fonction, une mutation effectuée dans le corps de la fonction mutera le tableau à l'extérieur de la fonction.

Question 1 :

On souhaite inverser un tableau en effectuant des permutations selon le plan suivant :

Sur ce tableau de longueur 7, lorsqu'on souhaite permuter selon ce plan la valeur d'indice i = 2, quel est l'indice j de la valeur qui va être permutée avec elle ?

• j = 7 - 1 - i

• j = 7 - i

• j = 7 + 1 - i

def table_de_multiplication(n):

table = ''

for ... in range(...):

ligne = ''

for ... in range(...):

ligne = ligne + '{:4}'.format(... * ...) table = table + ... + ...

return ...

_______________________

| _______________ | | | _______ | | | | | | | | V V V | | | tab = [ A, B, C, D, E, F, G]

| | | Λ Λ Λ | | |_______| | | | |_______________| | |_______________________|

Question 2 :

Compléter la fonction inverser ci-dessous qui prend en paramètre un tableau tab de longueur quelconque et le mute afin d'inverser toutes ses valeurs.

Exercice 9 ***

On réalise une expérience consistant à demander à plusieurs personnes de placer chacune un jeton sur une table contenant des zones de différentes couleurs. Les chercheurs souhaitent ainsi étudier si le choix de la zone où une personne place son jeton est lié à la couleur des vêtements qu'elle porte.

On vous donne en entrée le nombre de jetons qui ont été déposés, puis, pour chaque jeton, ses coordonnées sur la feuille par rapport à l'origine en haut à gauche, sous la forme d'une abscisse et d'une ordonnée entre −1 000 et 1 000.

Votre programme devra qualifier chaque jeton avec l'un des textes suivants, en fonction de la couleur sur laquelle il se trouve :

• « En dehors de la feuille »

• « Dans une zone jaune »

• « Dans une zone bleue »

• « Dans une zone rouge »

Essayez d'écrire votre programme de sorte qu'il y ait au maximum une condition par possibilité de texte affiché.

Exemple entrée : 4 16 12 30 22 64 62 -5 86

Dans l'exemple, on a 4 jetons, de coordonnées (16 ; 12), (30 ; 22), (64 ; 62) et (-5 ; 86).

Exercice 10 ***

Les habitants adorent les constructions en forme de pyramide ; de nombreux bâtiments officiels ont d'ailleurs cette forme. Pour fêter les 150 ans de la construction de la ville, le gouverneur a demandé la construction d'une grande et majestueuse pyramide à l'entrée de la ville. Malheureusement, en ces périodes de rigueur budgétaire, il y a peu d'argent pour ce projet. Les architectes souhaitent cependant construire la plus grande pyramide possible étant donné le budget prévu.

Votre programme doit d'abord lire un entier : le nombre maximum de pierres dont pourra être composée la pyramide. Il devra ensuite calculer et afficher un entier : la hauteur de la plus grande pyramide qui pourra être construite, ainsi que le nombre de pierres qui sera nécessaire.

def inverser(tab):

for ... in range(...) :

tab[...], tab[...] = tab[...], tab[...]

sortie :

Dans une zone bleue Dans une zone jaune Dans une zone rouge En dehors de la feuille

Exemple 1 entrée : 20 sortie : 3 14

Exemple 2 entrée : 26042 sortie : 42 25585

Exercice 11 ***

Voici une suite :

Pour passer d’une ligne à la suivante, il suffit de lire à haute voix en comptant les nombres ! Par exemple la ligne 1211 est lue « un un (pour 1), un deux (pour 2), deux un (pour 1 1) », la ligne d’après est donc 111221

Cette dernière ligne se lit « trois uns, deux deux, un un » donc la ligne suivante sera 312211.

Programmer une fonction lecture(mot) qui calcule et renvoie la lecture de la chaîne mot.

Par exemple

lecture("1211") renvoie "111221".

• Indications. Vous pouvez utiliser trois variables : une variable qui lit chaque caractère du mot, une variable correspondant au caractère précédent, un compteur à incrémenter si ces deux caractères sont égaux.

• Algorithme. Si vous n’y arrivez pas tout seul, voici les grandes lignes d’un algorithme possible.

Pour chaque caractère du mot :

— si le caractère est le même que le caractère précédent, incrémenter le compteur,

— sinon, rajouter au mot à créer la valeur du compteur suivie du caractère précédent.

À la fin, il faut aussi rajouter au mot à créer la valeur du compteur suivie du caractère précédent.

Question. Trouvez le premier mot qui contient 33.

2

partie : Algorithmique

➢ Détermination de la complexité Exercice 1

Pour chacun des fonctions Ti(n) suivant, déterminer sa complexité asymptotique dans la notation Grand-O.

1. T1(n) = 6n³ + 10n² + 5n + 2 2. T2(n) = 3 log2 n + 4 3. T3(n) = 2ⁿ + 6n² + 7n 4. T4(n) = 7k + 2 5. T4(n) = 4 log2 n + n 6. T5(n) = 2 log10 k + kn² Exercice 2

Dans cet exercice, vous allez vous même élaborer un algorithme de tri ! 1. Initialiser une liste avec 10 valeurs aléatoires entre 1 et 10.

2. Ecrire un algorithme qui identifie l’index de l’élément avec la plus petite valeur dans la liste, et stocker le dans la variable pluspetitindex.

3. Echangez les deux éléments de la liste : le premier élément (liste[0]) et l’élément à la position pluspetitindex.

4. Tester votre algorithme

5. Imbriquez votre algorithme dans une boucle pour que vous triez la liste par ordre croissant ! 6. Chronométrer de nouveau le temps d’exécution pour une saisie de valeur pour n=10, n=100,

n=1000, n=5000.

7. Tracer un graphe en fonction de n pour le temps d’exécution avec un logiciel de tableur (p.ex. Excel) ou avec la librairie Matplotlib

Exercice 3

Considérer les algorithmes suivants avec un temps d’exécution T(n) pour une longueur de données n. Déterminer leurs complexités asymptotiques respectives, et indiquer quel(s) règle(s) vous aviez appliqués.

Algorithme A1 : T(n) = 3n + 2 Algorithme A2 : T(n) = 6

Algorithme A3 : T(n) = 4n²+ n + 2 Algorithme A4

Exécuter A1;

Exécuter A2;

Exécuter A3;

Algorithme A5 i=1

TANT QUE i<=n FAIRE Exécuter A3;

i=i+1 FIN TANT QUE Exécuter A1;

Algorithme A6 i=1

TANT QUE i<=5 FAIRE Exécuter A1;

i=i+1 FIN TANT QUE

➢ Algorithme de recherche dichotomique

Exercice 1 :

Déroulez cet algorithme à la main en utilisant le tableau t=[1,3,4,6,7,8,10,13,14], on cherche l'élément 4

Exercice 4 :

Codez cet algorithme en python

Vous pouvez utiliser la fonction sort() de python pour générer un tableau trié de n éléments tous différents.

Ajouter un compteur pour comptabiliser le nombre de fois que le tableau est coupé en deux.

Quel est le pire cas ?

Comptabilisez le nombre de fois que le tableau est coupé en deux pour le pire cas.

Essayez avec des tableaux de plus en plus grands. Que constatez-vous ?

Ecrivez un algorithme de recherche simple qui parcourt le tableau et s’arrête lorsqu’il a trouvé la bonne valeur.

Comparez ces deux algorithmes de recherche lorsque vous doublez la taille du tableau. (mesurer le temps d’exécution)

➢ Algorithme glouton

Reprenons la définition d'un algorithme utilisant une stratégie gloutonne : faire à chaque étape un choix localement optimal dans le but d'obtenir à la fin un résultat globalement optimal.

Supposons que vous deviez rendre la monnaie à quelqu'un. Vous disposez de l'ensemble des pièces et billets existants dans la zone euro et en quantité infini . Vous choisissez une stratégie gloutonne : des choix locaux optimaux, étape après étape, devraient produire un résultat global optimal.

A partir de la méthode gloutonne décrite ci-contre, écrivez l'algorithme

correspondant en python.

Algorithme inconnu m=0

p=0

tant que m<k m=m+1 p=p+b fin

Algorithme de recherche dichotomique début, fin, val, mil, N : Entiers

val est la valeur recherchée t : Tableau [0..N] d'entiers classé trouvé : Booléen

DEBUT début ← 0 fin ← longueur(t) trouvé ← faux

Tant que trouvé != vrai et début <= fin:

mil ← partie_entière((début + fin)/2) si t[mil] == val:

trouvé ← vrai sinon: si val > t[mil]:

début ← mil+1 sinon:

fin ← mil-1 FIN

ÉTAPE 1 :

- Somme à rendre : 263 cents.

- Solution locale : 200.

- Pièces utilisées : 1*2€.

ÉTAPE 2 :

- Somme à rendre : 63 cents.

- Solution locale : 50.

- Pièces utilisées : 1*2€ + 1*50cents.

ÉTAPE 3 :

- Somme à rendre : 13 cents.

- Solution locale : 10.

- Pièces utilisées : 1*2€ + 1*50cents +1*10cents.

ÉTAPE 4 : - Somme à rendre : 3 cents.

- Solution locale : 2.

- Pièces utilisées : 1*2€ + 1*50cents +1*10cents +1*2cents ÉTAPE 5 :

- Somme à rendre : 1 cent - Solution locale : 1

- Pièces utilisées : 1*2€ + 1*50cents +1*10cents +1*2cents +1*1cent

On a rendu toute la monnaie, on s'arrête là !

3

partie : Architectures matérielles

Révision de base structure des adresses IP.

Les adresses IP sont de la forme : "a.b.c.d", avec a, b, c et d compris entre 0 et 255 (a, b, c et d sont codés sur 1 octet).

Exemple d'adresse IP: 192.168.0.1

• Réseau de classe A : adresse réseau : a.0.0.0 (avec a qui doit être compris entre 1 et 126)

• Réseau de classe B : adresse réseau : a.b.0.0 (avec a qui doit être compris entre 128 et 191)

• Réseau de classe C : adresse réseau : a.b.c.0 (avec a qui doit être compris entre 192 et 223) Une partie de l’adresse IP permet d’identifier le réseau auquel appartient la machine et l’autre partie de l’adresse IP permet d’identifier la machine sur ce réseau.

Pour différencier la partie de l’adresse IP qui représente le réseau de celle qui représente la machine, il faut utiliser un masque de sous réseau

Ce masque consiste en une adresse dont la représentation binaire est de la forme : 1……1 0…….0, c'est-à-dire une suite de 1 suivi d'une suite de 0.

Par exemple un masque valide est 255.255.248.0

Ce masque permet de "découper" une adresse IP en deux parties. La partie "réseau" (ici les 21 bits de poids forts à 1) et la partie "machine" (les 11 bits de poids faibles à 0).

Ce masque permet donc d'avoir, sur le même réseau, 2¹¹ adresses distinctes.

Exemple :

L’adresse réseau est donc 192.168.128.0

On peut placer dans ce réseau 2¹¹ machines depuis l’adresse 192.168.128.0 à 192.168.135.255.

En effet, on peut aller jusqu’à 255 pour le dernier octet (que des 0 dans le masque soit 1111 1111 = 255), dans l’octet précédent, il y a 3 zéros de disponibles soit 111 = 7, donc on peut aller jusqu’à 135 (128+7)

Attention la 1^ère adresse est l’adresse du réseau, ce n’est donc pas une adresse machine, la 1^ère adresse est donc 192.168.128.1. La dernière adresse est l’adresse de broadcast, elle ne peut pas être attribuée à une machine, la dernière adresse machine est donc 192.168.135.254.

Exercice

Soit l’adresse IP 192.168.10.0 qui utilise le masque de sous-réseau suivant : 255.255.240.0.

Vous devez justifier l’ensemble de vos réponses.

1. Quelle est l’adresse du réseau ?

2. Indiquez la 1^ère adresse et la dernière adresse possibles pour une machine dans ce réseau.

3. Combien de machines hôtes peut-on placer dans ce réseau ? 4. Quel est le type de ce réseau ?

192.168.129.10

& 255.255.248. 0 192.168.128. 0

binaire 1111 1111 . 1111 1111 . 1111 1000 . 0000 0000 décimal 255 . 255 . 248 . 0

Retenons que faire le "et" bit à bit produit les résultats suivants : 1 & 1 = 1 ; 1 & 0 = 0 de même que 0 & 1 = 0