 

Question 1


Réponse enregistrée

Noté sur 0,50

Retirer la marque

Soient les instructions suivantes

A ←6

B←2

C←1

Si A>0 Alors

Si B<>0 Alors

C ← A-B

Sinon

C ← C+A

FinSi

Sinon

C ← C-B

FinSi

Donner la valeur de C à la fin du traitement

C= 4

Question 2
Réponse enregistrée

Noté sur 0,50

Retirer la marque

Quelle est la syntaxe correcte pour la déclaration d'une constante ?

Veuillez choisir une réponse.

PI : 3.12
PI = 3.12

PI ← 3.12

Question 3
Réponse enregistrée

Noté sur 0,50

Retirer la marque

A quel moment faut-il utiliser la boucle POUR ?

Veuillez choisir une réponse.

Lorsqu'il faut e!ectuer une répétition pour une condition donné
Lorsqu'il faut e!ectuer une répétition avant de vérifier une condition
Lorsqu'on connaît le nombre de répétition à réaliser.

Question 4
Réponse enregistrée

Noté sur 0,50

Retirer la marque

6- La structure conditionnelle alternative :

Veuillez choisir une réponse.

Exécute un bloc d'instructions quand la condition est vérifiée sinon elle exécute un autre bloc
d'instructions quand elle ne l'est pas.
Exécute un bloc d'instructions quand la condition est pas vérifiée, dans le cas contraire, elle ne fait rien.
Définit trois blocs d'instructions di!érents parmi lesquels elle exécute un seul.

Question 5
Réponse enregistrée

Noté sur 0,50

Retirer la marque

Soient les instructions suivantes

A ← VRAI

B ← FAUX

C ← VRAI

SI (A OU NON(A) = VRAI) ET (NON(C) OU B =VRAI) ALORS

E←2

F←3

FinSi

SI (A ET C = VRAI) OU (C ET B = FAUX) ALORS

E←4

F←2

D ← VRAI

FinSi

Que retourne F ?

F= 2

Question 6
Réponse enregistrée

Noté sur 0,50

Retirer la marque

Dans quel cas parle-t-on de variable en informatique ?

Veuillez choisir une réponse.

Lorsqu'on doit stocker provisoirement des valeurs ;
Lorsqu'on ne doit pas récupérer des valeurs ;

Lorsqu'on ne doit pas récupérer des résultats ;

Question 7
Réponse enregistrée

Noté sur 0,50

Retirer la marque

Laquelle de ces déclarations est correcte ?

Veuillez choisir une réponse.

v1 : Chaîne
Réel : v1
v1 = Booléen

Question 8
Réponse enregistrée

Noté sur 0,50

Retirer la marque

Soient les instructions suivantes

Val1 ← 9

TANTQUE val1<10 FAIRE

Val1 ← Val1 + 2

FINTANTQUE

A#cher val1

Que vaut val1 à la fin de cette structure itérative ?

val1 = 15

Question 9
Réponse enregistrée

Noté sur 0,50

Retirer la marque

Soient les instructions suivantes

Val1 ← 1

TANTQUE val1 >0 FAIRE

Val1 ← Val1 - 3

FINTANTQUE

A#cher val1

Que vaut val1 à la fin de cette structure itérative ?

val1 = -2

Question 10
Réponse enregistrée

Noté sur 0,50

Retirer la marque

Soient les instructions suivantes

Var

N, i, Som : Entier

Debut

N←6

Som ← 0

POUR i ← 1 A N FAIRE

Som ← Som + i

FIN

A#cher "La somme est : ", Som

FIN

Quelle est le résultat qu'on aura dans Som?

Som = 21

Question 11
Réponse enregistrée

Noté sur 1,00

Retirer la marque

Toutes les réponses ne doivent pas avoir des espaces, ni de ponctuation et elles doivent être en

minuscule.

Utiliser les sous algorithmes

Énoncé :

Ecrire un algorithme qui calcule et a#che la résistance d'un composant électronique en

utilisant la loi d'Ohm : U = R x I

U : Tension en V

R : Résistance en Ω

I : Intensité en A

Cet algorithme doit avoir trois sous algorithme à savoir :

Une procédure recup : permettra de récupérer les valeurs

Une fonction calculres : permettra de calculer la résistance

Une procédure a#cheresu : permettra d'a#cher le résultat

Solution

procédure recup({ S } U,I : réel )

Début

a#cher "Entrer la tension"

Saisir U

a#cher "Entrer l'intensité"

Saisir I

Fin

//*************************

fonction calculres({ E } U,I : réel ): réel

var

res : réel

Début

res ← U/I

renvoyer res

Fin

//************************

procédure a#cheresu({ E }R: réel )

Début

a#cher "Résistance =", R ," Ohms"

Fin

//****************************

Algorithme Résistance

Procédure recup({S}U,I : réel)

Fonction calculres({E} U,I : réel) : réel

procédure a#cheresu({E} R : réel)

Var

TENSION, INTENSITE , RES : Réel

Début

recup(TENSION,INTENSITE)

RES ← calcuires(TENSION,INTENSITE)

a#cheresu(RES)

Fin

Question 12
Réponse enregistrée

Noté sur 1,00

Retirer la marque

Soit un tableau T ci-dessous

8 15 -9 14 -8 2 0 1 5 15

val ← 0

Pour I← 1 A 10 Faire

T[I] ← val

val ← val + 1

FinPour

A#cher val

Quel sera le résultat obtenu de val :

val = 10

Question 13
Réponse enregistrée

Noté sur 1,00

Retirer la marque

Soit un tableau T ci-dessous

8 15 -9 14 -8 2 0 1 5 15

val ← 0

Pour I← 1 A 10 Faire

T[I] ← val

val ← val + 1

FinPour

A#cher T[10]

Quel sera le résultat obtenu de T[10] :

T[10]= 10

Question 14
Réponse enregistrée

Noté sur 1,00

Retirer la marque

Toutes les réponses ne doivent pas avoir des espaces, ni de ponctuation .

Utiliser les sous algorithmes

Une année bissextile (contient 366 jours) si elle est multiple de 4 et non divisible par 100, sauf les années de

début de siècle (qui se terminent par 00) qui ne sont bissextiles que si elles sont divisibles par 400.

Exemples

1980 et 1996 sont bissextiles car elles sont divisibles par 4

2000 est une année bissextile car elle est divisible par 400

2100 et 3000 ne sont pas bissextiles car elles ne sont pas divisibles par 400.

Ecrire un algorithme qui permet de déterminer si un entier positif donné correspond à une année bissextile ou

non.

Cet algorithme doit avoir trois sous algorithme à savoir :

Une procédure recup : permettra de récupérer l'entier

Une fonction verifbessex : permettra de vérifier si l'année est bissextile ou non

Une procédure a#cheresu : permettra d'a#cher le résultat

Solution

Procédure recup({ S } AN : entier )

Début

a#cher "Entrer un entier"

Saisir AN

Fin

//*************************

Fonction verifbessex({ E } AN : entier ): booléen

var

res : booleen

Début

Si ( AN Mod 400 =0 ) Ou (( AN

Mod 100 <>0 ) ET ( AN Mod 4

=0 )) Alors

res ← vrai

sinon

res ← faux

finsi

renvoyer res

Fin

//************************

Procédure a#cheresu({ E } R : booleen)

Début

Si R=vrai alors

a#cher "Année bissextile"

Sinon

a#cher "Année non bissextile"

Fin

//****************************

Algorithme Résistance

procédure recup({S}AN : entier)

fonction verifbessex({E} AN : entier) : booleen

procédure a#cheresu({E} R : booleen )

Var

ANNE : Entier

RES : boolen

Début

recup(ANNE)

RES ← verifbessex(ANNE)

a#cheresu(RES)

Fin

Question 15
Réponse enregistrée

Noté sur 1,00

Retirer la marque

Soit un tableau T ci-dessous

21 2

2 3 -1

1 -2 2

val ← 1

Pour I← 1 A 3 Faire

Pour J← 1 A 3 Faire

val ← val * T[I,J]

FinPour

FinPour

A#cher val

Quel sera le résultat obtenu de val :

val = -96

Question 16
Réponse enregistrée

Noté sur 10,00

Retirer la marque

Toutes les réponses ne doivent pas avoir des espaces, ni de ponctuation .

Utiliser les sous algorithmes

Une année bissextile (contient 366 jours) si elle est multiple de 4 et non divisible par 100, sauf les années de

début de siècle (qui se terminent par 00) qui ne sont bissextiles que si elles sont divisibles par 400.

Exemples

1980 et 1996 sont bissextiles car elles sont divisibles par 4

2000 est une année bissextile car elle est divisible par 400

2100 et 3000 ne sont pas bissextiles car elles ne sont pas divisibles par 400.

Ecrire un algorithme qui permet de déterminer si un entier positif donné correspond à une année bissextile ou

non.

Cet algorithme doit avoir trois sous algorithme à savoir :

Une procédure recup : permettra de récupérer l'entier

Une fonction verifbessex : permettra de vérifier si l'année est bissextile ou non

Une procédure a#cheresu : permettra d'a#cher le résultat

Solution

Procédure recup({ S } AN : entier )

Début

a#cher "Entrer un entier"

Saisir AN

Fin

//*************************

Fonction verifbessex({ E } AN : entier ): booléen

var

res : booleen

Début

Si ( AN Mod 400 =0 ) Ou (( AN

Mod 100 <>0 ) ET ( AN Mod 4

=0 )) Alors

res ← vrai

sinon

res ← faux

finsi

renvoyer res

Fin

//************************

Procédure a#cheresu({ E } R : booleen)

Début

Si R=vrai alors

a#cher "Année bissextile"

Sinon

a#cher "Année non bissextile"

Fin

//****************************

Algorithme Résistance

procédure recup({S}AN : entier)

fonction verifbessex({E} AN : entier) : booleen

procédure a#cheresu({E} R : booleen )

Var

ANNE : Entier

RES : boolen

Début

recup(ANNE)

RES ← verifbessex(ANNE)

a#cheresu(RES)

Fin

Terminer le test…

Aller à…

© 2022 - Mon université avec moi, partout et à tout

moment.