Leçon 4 

: Gestions
des entrées-sorties et
des listes

Université Virtuelle de Côte d'Ivoire

Juin 2019
 Table des
matières

I - Objectifs 3

II - I. Entrées / sorties 4

1. Entrées et sorties .......................................................................................................................... 4

2. Exercice : Question 1 ..................................................................................................................... 6

3. Exercice : Question 2 ..................................................................................................................... 6

III - Listes 7

1. Présentation des listes .................................................................................................................. 7

2. Prédicats de manipulation de listes .............................................................................................. 8

3. Exercice : Question 1 ................................................................................................................... 11

4. Exercice : Question 3 ................................................................................................................... 11

5. Exercice : Question 4 ................................................................................................................... 11

6. Exercice ....................................................................................................................................... 11

IV - Solutions des exercices 12

 Objectifs

À la fin de cette leçon, l'apprenant sera capable de :

o Présenter les opérations d'entrée-sortie ;
o Présenter la notion de liste ;
o Utiliser les entrée-sorties et les listes dans un programme.

3
 I. Entrées / sorties

I. Entrées / sorties
I
1. Entrées et sorties
1. Présentation

Le Prolog standard ne connaît que l'ASCII. Les entrées/sorties sont primitives.

2. Les caractères de contrôle

\n : Saut de ligne

\t : Tabulation horizontale
\v : Tabulation verticale
\% : Affiche %
\a : bip
\r : Retour au début de la ligne
\\ : Caractère \
\f : Form feed

Exemple : Exemple d'utilisation

write('toto'),write('\n'),write('tata').
?- write("toto").
Affiche les codes ASCI de t, o, t et o :
[116, 111, 116, 111]

3. Les formats de conversion

%t : Affichage d'un terme

%n : Affichage d'un code ASCII
%s : Affichage d'une chaîne de caractères

Exemple : Affichage
writef("ceci %t l'%s %t n et j'affiche X=%t",[est,"exemple numero",45,'toto']).
Cela affiche :
ceci est l'exemple numero 45 n et j'affiche X=toto

4. Lire et écrire des caractères

Le tableau ci-dessous présente des prédicats de lecture et d'écriture de caractères.

4
 I. Entrées / sorties

Prédicats de lecture et d'écriture de caractères

5. Lire et écrire des termes

Le terme est terminé par un point (.).

Prédicats de lecture et d'écriture de termes

5
 I. Entrées / sorties

2. Exercice : Question 1
Écrire un programme qui lit deux nombres et calcule leur somme.
Ci-dessous un exemple d'exécution.

Exemple d'exécution
Un extrait de code que vous pouvez améliorer :
la_somme(X,Y,S):-write('Donner le premier nombre'),nl,read(X), write('Donner le deuxieme nombre'),
nl,read(Y),S is X+Y, write('La somme de '),write(X),write(' et de '), write(Y), write(' est '),write(S).

3. Exercice : Question 2
Écrire un programme qui retourne les nombres pairs d'une liste.

6
 Listes

Listes
II
1. Présentation des listes
1. Présentation

La liste (séquence ordonnée d'éléments de longueur variable) est la principale structure en Prolog.
Les éléments peuvent être des constantes (atomes ou nombres) ou des termes composés. Pour
l'interpréteur Prolog, la liste peut être :
- une liste vide notée [] ou .() ;
- une liste composée d'un élément de tête et d'un reste comprenant la liste sans le premier élément ;
cette idée se note [T|R].
Les éléments d'une liste sont séparés (comme les arguments) par une virgule « , ».

A partir de chaque élément, on peut accéder au suivant et éventuellement au précédent.

Exemple de liste

Définition
Une liste est un terme composé de foncteur ".'' et d'arité 2 :
le 1er argument est l'élément de tête de la liste ou les premiers éléments de la liste,
le 2ème argument est la queue ou le reste des éléments de la liste.
La liste vide est notée "[]''.

2. Notation

La syntaxe de notation de la liste non vide est :

.(Tete , Queue) ou [ Tete | Queue ]

La notation simplifiée:
.(terme1,.(terme2,.(termen,.(...,liste),...) équivaut à [terme1 , terme2, ... , termen | liste ]

Remarque
Noter la présence d'un "." dans la notation .(Tete , Queue).

Exemple
.(a, .(b, .(c, [])))

7
 Listes

Représentation d'une liste

3. Opérateur pipe ( "|")

L'opérateur pipe ( "|") permet d'extraire la tête et la queue.

bgt?- [a, b] = [X | Y].
X = a, Y = [b]
?- [a] = [X | Y].
X = a, Y = []
?- [a, [b]] = [X | Y].
X = a, Y = [[b]]
?- [a, b, c, d] = [X, Y | Z].
X =4k,jsxlm a, Y = b, Z = [c, d]
?- [[a, b, c], d, e] = [X | Y].
X = [a, b, c], Y = [d, e]

Exemple : Notations équivalentes pour les listes Prolog

'.'(a,'.'(b,'.'(c,[]))) équivaut aux notations suivantes:
- [a|[b|[c|[]]]]
- [a|[b|[c]]]
- [a|[b,c|[]]]
- [a|[b,c]]
- [a,b|[c|[]]]
- [a,b|[c]]
- [a,b,c|[]]
- [a,b,c]

2. Prédicats de manipulation de listes

Somme des éléments d'une liste de nombres : Prédicat somme (L, S)

Algorithme :
- Si L est vide, alors S=0
- Sinon S=la tête de L + la somme des éléments de la queue de L.

Programme :
somme([], 0).
somme([Tete|Queue], S) :- somme(Queue, SQ), S is Tete + SQ.

8
 Listes

Exemple de requête:
?- somme([1,2,3],Som).

Affichage d'une liste avec parenthèses : Prédicat lwrite(L)

Programme :
lwrite(L) :-write('('),lwrite2(L),write(')'), nl.
lwrite2([]) :-write().
lwrite2([Tete|[]]) :-write(Tete). % la queue est vide
lwrite2([Tete|Queue]) :-write(Tete),write(', '),lwrite2(Queue).

Exemple de requête :
?- lwrite([]).
()
?- lwrite([1,2,3]).
(1, 2, 3)

Appartenance : Prédicat in(X, L)

Analyse
- Un élément X fait partie d'une liste L s'il est la tête de liste in(X, [X|_]) ;
- sinon il faut le chercher en queue de liste in(X, [_|Queue] :- in(X, Queue).

Programme:
in(X, [X|_]).
in(X, [_|Queue] :- in(X, Queue).

Exemple de requête:
?-in(5,[3,4,5]).
Yes
?-in(2,[3,4,5]).
No

Longueur d'une liste : Prédicat longueur(L, Lg).

Analyse
- Une liste vide a pour longueur 0 :
longueur([], 0).
- Si non c'est la longueur de queue de la liste +1 :
longueur([_|Queue], Lg) :- longueur(Queue, Lg1), Lg is Lg1 + 1.

Programme :
longueur([], 0).
longueur([_|Queue], Lg) :- longueur(Queue, Lg1), Lg is Lg1 + 1.

9
 Listes

Egalité de deux listes : Prédicat egal(L1, L2)

Analyse
- Deux listes sont égales si leurs têtes sont égales ainsi que leurs queues.

Programme :
egal(L1, L2) :-L1 = L2.
/*ou*/
egal(L, L).

Exemples de requête :
?- egal([1,2,3],[1,2,3,4]).
No
?- egal([1,2,3],[1,2,3]).
Yes

Concaténation de deux listes : Prédicat conc(L1, L2, L)

Analyse
- Si L1 est vide, la liste est L2 :
conc([], L2, L2).
- Si L2 est vide, la liste est L1 :
conc(L1, [], L1).
- Si L1 est non vide, on place la tête de L1 en début de la liste résultat L, et on reprend le traitement
avec les queues de ces deux listes.
conc([Tete|Queue1], L2, [Tete|Queue]) :-conc(Queue1, L2, Queue).

Programme :
conc([], L2, L2).
conc(L1, [], L1).
conc([Tete|Queue1], L2, [Tete|Queue]) :-conc(Queue1, L2, Queue).

Exemple de requête :
?- con([1,2,3],[4,5] ;L).
L=[1,2,3,4,5]
Yes

Prédicats prédéfinis

Tableau de prédicats prédéfinis

10
 Listes

¨Prédicats prédéfinis

3. Exercice : Question 1
[Solution n°1 p 12]

Exercice
Quelle est la tête de la liste suivante : [[le,chat],mange,S] ?

Exercice : Question 2
Quelle est la queue de la liste suivante :[le,chat,mange,[S]] ?

4. Exercice : Question 3
Ecrire un prédicat permettant de faire la somme des éléments de deux listes. Ex [1, 2, 5] + [3, 4, 5] = 20
Voir exemple du cours pour indice.

5. Exercice : Question 4
Ecrire unprogramme pour afficher les éléments d'une liste ? Testez votre code sur la liste contenant les
nombres 5, 10, 15 et 20 dans cet ordre.
Extrait de code :
afficher_liste([X|L]) :- writeln(X), afficher_liste(L).

6. Exercice
Ecrire un programme pour afficher les éléments d'une liste ? Testez votre code sur la liste contenant les
nombres 5, 10, 15 et 20 et le nombre 15.
Extrait de code :
appartient_a(X,[X|_]).
appartient_a(X,[_|L]) :- appartient_a(X,L).

11
 Ressources annexes

Solutions des exercices

> Solution n°1 Exercice p. 11

Exercice
[le,chat]

Question 2
[chat,mange,[S]]

12