###### tags: `prolog`
# TP Prolog - s04 - ISC IL 3a
## Baudin Valentin et Braillard Simon
## Exercice 1
```prolog=
factorial1(N, F) :-
N > 0,
factorial1(N, 1, F).
factorial1(1, F, F).
factorial1(N, Acc, F) :-
N1 is N-1,
Acc1 is N*Acc,
factorial1(N1, Acc1, F).
```
#### Output:
```
| ?- > factorial1(4, G).
G = 24 ?
```
## Exercice 2
### a)
```prolog=
% Avec accumulateur
listSum1(Ls, S) :-
listSum1(Ls, 0, S).
listSum1([], S, S).
listSum1([L|Ls], Acc, S) :-
Acc1 is Acc+L,
listSum1(Ls, Acc1, S).
```
#### Output:
```
| ?- > listSum1([1, 2, 3], F).
F = 6
yes
| ?-
```
### b)
```porlog=
% Sans accumulateur
listSum([], 0).
listSum([L|Ls], S) :-
listSum(Ls, S1),
S is S1+L.
```
#### Output:
```
| ?- > listSum([1, 2, 3], F).
F = 6
yes
| ?-
```
## Exercice 3
### a)
`concat1` traite correctement les questions.
`concat2` traite correctement les questions, mais provoque un stack overflow si on cherche toutes les solutions.
`concat3` traite correctement les questions car appelle `concat1`
### b)
`concat1` traite correctement les questions si la réponse est yes. Cependant, lorsque la réponse attendue est no, un overflow peut se produire. De plus, provoque un stack overflow si on cherche toutes les solutions.
`concat2` traite correctement les questions.
`concat3` traite correctement les questions car appelle `concat2`
### c)
C'est le `concat1`qui est le plus efficace.
## Exercice 4
```prolog=
counterAB(FileName) :-
catch(
go(FileName),
E,
print1(E)
).
go(FileName) :-
open(FileName, read, StreamId),
get_char(StreamId, AtomChar),
countChar(StreamId, AtomChar, A, B),
write('le fichier '),
write(FileName),
write(' contient '),
write(A),
write(' a et '),
write(B),
write(' b'),
close(StreamId).
countChar(_, end_of_file, 0, 0).
countChar(StreamId, 'a', A, B) :-
get_char(StreamId, AtomChar1),
countChar(StreamId, AtomChar1, A1, B),
A is A1 + 1.
countChar(StreamId, 'b', A, B) :-
get_char(StreamId, AtomChar1),
countChar(StreamId, AtomChar1, A, B1),
B is B1 + 1.
countChar(StreamId, AtomChar, A, B) :-
AtomChar \= 'b',
AtomChar \= 'a',
AtomChar \= end_of_file,
get_char(StreamId, AtomChar1),
countChar(StreamId, AtomChar1, A, B).
print1(E):-
write('Oups, erreur I/O : '),
write(E).
```
### Fichier AB
Dans ce fichier, il y a 48 a et 10 b.
```raw!
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non risus. Suspendisse lectus tortor, dignissim sit amet, adipiscing nec, ultricies sed, dolor. Cras elementum ultrices diam. Maecenas ligula massa, varius a, semper congue, euismod non, mi. Proin porttitor, orci nec nonummy molestie, enim est eleifend mi, non fermentum diam nisl sit amet erat. Duis semper. Duis arcu massa, scelerisque vitae, consequat in, pretium a, enim. Pellentesque congue. Ut in risus volutpat libero pharetra tempor. Cras vestibulum bibendum augue. Praesent egestas leo in pede. Praesent blandit odio eu enim. Pellentesque sed dui ut augue blandit sodales. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Aliquam nibh. Mauris ac mauris sed pede pellentesque fermentum. Maecenas adipiscing ante non diam sodales hendrerit.
```
### Output
```raw!
| ?- > counterAB('ab.txt').
le fichier ab.txt contient 48 a et 10 b
```
Et en cas d'erreur :
```raw!
| ?- > counterAB('ab.55t').
Oups, erreur I/O : error(existence_error(source_sink,ab.55t),open/3)
```
## Exercice 5
### a)
Le prédicat compare si 2 listes contiennent les mêmes éléments (pas besoin d'avoir le même ordre). Pour cela, elle prend le 1er élément de la liste Rs et l'enlève à Ls (s'il existe). Si à la fin les 2 listes sont vides, les listes avaient le même contenu à la base.
### b)
```prolog=
% --- p(+Ls, ?Rs): ...
p(Ls, [E|Rs]) :-
append(As, [E|Bs], Ls),
append(As, Bs, Xs),
p(Xs, Rs).
p([], []).
```
### c)
```prolog=
% --- p(+Ls, ?Rs): ...
p(Ls, [E|Rs]) :-
append(As, [E|Bs], Ls),
append(As, Bs, Xs),
p(Xs, Rs).
p([], []).
p1(Ls, Rs) :-
nonvar(Ls),
p(Ls, Rs).
p1(Ls, Rs) :-
var(Ls),
p(Rs, Ls).
```
### d)
```prolog=
% --- p(+Ls, ?Rs): ...
p(Ls, [E|Rs]) :-
select(E,Ls,Xs),
p(Xs, Rs).
p([], []).
p1(Ls, Rs) :-
nonvar(Ls),
p(Ls, Rs).
p1(Ls, Rs) :-
var(Ls),
p(Rs, Ls).
```
{"metaMigratedAt":"2023-06-17T11:24:02.174Z","metaMigratedFrom":"Content","title":"TP Prolog - s04 - ISC IL 3a","breaks":true,"contributors":"[{\"id\":\"8c5c3788-11df-452f-9374-6e1552e561a2\",\"add\":1697,\"del\":429},{\"id\":\"eb2933d9-44da-4ddd-b209-34f78dde26fa\",\"add\":3364,\"del\":255}]"}