Initiation Hardware
(matériel)
RAM CPU Mémoire fixe ou
Mémoire vive Processeur mémoire de stockage
(mémoire (Central :
volatile) Processing Unit) : Disque dur
(Random • Vitesse (GHz) Clé USB
Access • Nombre de CD/DVD/Blu-Ray
Memory) cœurs (core)/ Disquette
threads Bande magnétique
• Constructeurs : CMOS (BIOS)
• Vitesse plus rapide que Intel, AMD, …
mémoire fixe (MHz) Apple, (Cyrix,
• Capacité en octets Motorola, etc)
(Gigaoctets ou Go, • Multiples
Mégaoctets ou Mo) Générations • Vitesse moins rapide que
• 1 octet = 8 bits (Binary selon RAM
Digit) constructeurs • Capacité plus grande en
• Multiple générations : octets (Gigaoctets ou Go,
SDRAM, DDR1, DDR2,…, Mégaoctets ou Mo)
DDR5
GPU
Mémoire cache CPU
(Graphic Processing
Mémoire vive de plus
Unit)
faible capacité mais
-Prend en charge les
plus rapide que RAM
calculs et opérations
-Plusieurs niveaux (L1,
graphiques
L2)
-Peut être intégré au
- Intégré au processeur
processeur
- Non remplaçable
- Mémoire graphique
- Stocke les données
(vive)
les plus utilisées
- Vitesse
- Nombre de coeurs
Périphériques d’entrée
:
- Clavier Coprocesseur
Périphériques Périphériques
- Souris - Prend en charge
réseau : de sortie :
- Manette de jeu d’autres types
- Carte réseau - Ecran
- Scanner d’opérations (ex :
- Routeur - Imprimante
- Tablette graphique coprocesseur
- Switch/Hub - Haut-parleur
- Stylet arithmétique)
… …
- Capteurs - Peut être intégré au
… processeur
Initiation algorithmique
Algorithme : séquence logique d’instructions destinée à
accomplir une tâche
Doit avoir un début et une fin
Doit être claire et précise
Il peut y avoir plusieurs manières de réaliser une tâche, mais
on doit chercher la manière optimale et la plus simple possible
Doit tenir compte des contraintes (matérielle, temps, …)
L’algorithme doit être conçu avant d’écrire le programme
Variable :
Contient des valeurs qui peuvent changer au cours du déroulement de
l’algorithme (ex : x=5)
Reçoit les valeurs entrées par l’utilisateur (initialisation)
Reçoit les valeurs calculées pendant l’exécution de l’algorithme et à
afficher à l’utilisateur (initialisation)
A un type défini :
Numérique : entier, décimal, … (base 10, hexadécimal, …)
Chaîne de caractères (texte)
Booléenne : a pour valeur VRAI ou FAUX
Tableau (ou matrice) : liste de plusieurs variables accessibles par un indice
(peut avoir plusieurs dimensions)
Doit avoir une portée bien définie (globale, locale, constante)
Opérateurs :
Permettent d’effectuer des opérations entre les variables
Agissent sur tous les types (numérique, chaîne de caractères,
…)
Ont une ordre de priorité prédéfinie (qu’on peut changer)
Opérateurs arithmétiques :
Opérateur Description
= Assignement (ex : a=5)
+ Addition
- Soustraction
* Multiplication
/ Division
% Modulo (reste de division : A % B = reste de A/B)
Peuvent agir sur d’autres types autre que numérique (ex:
chaîne de caractères)
Ont une priorité prédéfinie (qu’on change avec les
parenthèses)
Opérateurs de comparaison :
Opérateur Description
== égalité
!= Différent de
< Inférieur à
> Supérieur à
<= Inférieur ou égal à
>= Supérieur ou égal à
Peuvent agir sur d’autres types autre que numérique (ex:
chaîne de caractères)
Opérateurs logiques :
Opérateur Description
ET (VRAI) ET (VRAI) = VRAI, (VRAI) ET (FAUX) = FAUX
OU (VRAI) OU (VRAI) = VRAI, (VRAI) OU (FAUX) = VRAI, (FAUX) OU
(FAUX)=FAUX
NON NON (VRAI) = FAUX, NON (FAUX) = VRAI
Combinable pour définir la priorité (sinon priorité par défaut)
CONDITION :
FAUX
Condition
VRAI
Instruction
FAUX
Condition
VRAI
Instruction Instruction
TEST DE VALEUR D’UNE VARIABLE :
Test de la Valeur 3
Valeur 1 valeur de la
variable
Valeur 2
Instruction Instruction Instruction
Pas de limite sur le nombre de valeurs qu’on peut tester
BOUCLES :
Test de condition en premier
Condition VRAI Instruction
FAUX
Instruction en premier :
Instruction
L’utilisation de
chaque
type de boucle dépend du
contexte de la tâche à
VRAI
Condition réaliser
FAUX Faire attention aux
boucles infinies
Exercices
Exercice 1 : trouver un mot de passe
Ecrire un algorithme qui doit trouver un mot de passe composé de
6 chiffres (0 à 9). Chaque combinaison doit être testée et
l’algorithme ne se termine que si le mot de passe est trouvé.
Début
Début
Initialiser variable
Mot_de_passe=‘’000000’’
Début
Initialiser variable
Mot_de_passe=‘’000000’’
Tester si
Mot_de_passe est
le bon mot de
passe
Début
Initialiser variable
Mot_de_passe=‘’000000’’
Tester si
Mot_de_passe est Mot_de_passe=Mot_de_passe+1
le bon mot de NON
passe
OUI
FIN
Début
Initialiser variable
Mot_de_passe=‘’000000’’
Tester si
Mot_de_passe est Mot_de_passe=Mot_de_passe+1
le bon mot de NON
passe
OUI
FIN
Exercice 2 : un jeu qui consiste à deviner un nombre
Le joueur doit trouver un nombre choisi au hasard par l’ordinateur.
A chaque tentative, l’ordinateur affiche « Trop grand » si le nombre
entré par le joueur est supérieur au nombre à trouver, ou « trop
petit » si c’est inférieur au nombre à trouver.
Le jeu s’arrête quand le joueur a trouvé le nombre.
Début
Assigner N= nombre choisi
au hasard par l’ordinateur
Saisir M= nombre entré par
le joueur
Afficher « Trop
M>N VRAI grand »
FAUX
Afficher « Trop M<N
petit » VRAI
FAUX
FIN
Afficher « GAGNE ! »
Exercice 3 : amélioration de l’exercice 2
L’ordinateur enregistre le nombre de tentatives effectuées par le
joueur et affiche ce nombre quand le nombre à tester est trouvé.
Assigner N= nombre choisi Nombre de tentatives
Début au hasard par l’ordinateur T=0
Saisir M= nombre entré par
le joueur
T=T+1
VRAI Afficher « Trop
M>N grand »
FAUX
Afficher « Trop VRAI
petit » M<N
FAUX
Afficher « GAGNE ! »
FIN
Afficher Nombre de
tentatives : T
Exercice 4 : amélioration des exercice 3 et 2
Si après 5 tentatives de trouver le nombre choisi au hasard, le jeu
s’arrête et l’ordinateur affiche « PERDU »
Assigner N= nombre choisi Nombre de tentatives
Début au hasard par l’ordinateur T=0
Saisir M= nombre entré par
le joueur
T=T+1
VRAI Afficher « Trop FAUX
M>N grand »
FAUX T==5
Afficher « Trop
M<N petit » VRAI
VRAI
FAUX Afficher
« PERDU »
Afficher « GAGNE ! »
Afficher Nombre de FIN
tentatives : T
Exercice 5 : tables de multiplication
Afficher toutes les tables de multiplication de 1 à 10 :
1x1=1
1x2=2
1x3=3
1x4=4
1x5=5
1x6=6
1x7=7
1x8=8
1x9=9
1x10=10
2x1=2
2x2=4
etc etc
Début
Boucle dans une boucle :
boucle imbriquée
N=1 - Pas de limite pour le
nombre de boucles
M=1 imbriquées mais
augmente le temps
d’exécution, on doit
chercher à réduire le
Afficher NxM nombre de boucles au
minimum nécessaire
M=M+1
FAUX M>10
FAUX
VRAI
VRAI
N>10 FIN
N=N+1
Exercice 6 : A à la puissance B
Calculer la valeur de A à la puissance B en multipliant A le nombre
de fois spécifié par B. A et B étant des entiers entrés par
l’utilisateur
Début
Saisir A et B
N=1
R=A
R=R*A
N=N+1
FAUX VRAI FIN
N==B Afficher R
Exercice 7 : Menu du jour
Il s’agit de définir le menu du jour pour chaque jour de la semaine
avec 3 entrées, 3 plats et 3 desserts (donc 27 combinaisons
possibles) :
Entrées : salade, charcuterie, pâtes
Plats : poisson, viande, légumes
Desserts : gâteau, glace, fruit
Afficher toutes les combinaisons possibles pour 27 jours.
Tableau_entrees*0+=‘’salade’’, Tableau_entrees*1+=‘’charcuterie’’,
etc etc
Début
Tableau_entrees=[‘’salade’’,’’charcuterie’’,’’pâtes’’]
Tableau_plats=[‘’poisson’’,’’viande’’,’’légumes’’]
FIN
Tableau_desserts=[‘’gateau’’,’’glace’’,’’fruit’’}
n=1
VRAI
i=0
i>2
FAUX
j=0
k=0 FAUX i=i+1
j>2 VRAI
Afficher
Menu_jour[n]=Tableau_entrees[i]+Tableau_plats[j]+
Tableau_desserts[k]
FAUX
n=n+1 k=k+1 k>2 j=j+1
VRAI
3 boucles imbriquées,
indices des tableaux de 0
à 2 (3 éléments)
Fonctions et procédures
Fonctions et procédures :
Ensemble d’instructions réalisant une tâche secondaire
précise qu’on utilise ou qu’on répète souvent pour réaliser la
tâche principale (cet ensemble devient une instruction à part
entière)
La fonction envoie une valeur de retour alors que la
procédure n’en envoie pas (le terme fonction peut aussi
désigner une procédure)
Permet d’éviter de réécrire ou de dupliquer du code (risque
d’erreur et difficulté lors de la modification/mise à jour).
