UNIVERISTE MOHAMMED PREMIER

Faculté des Sciences d’Oujda

Oujda - Maroc

Les TD/TP avec corrections

Cours Système d’Exploitation I

Programme : Filière – SMI – S3

Pr. El Mostafa DAOUDI

Département de Mathématiques et
d’Informatique

Année universitaire 2014/2015

Contenu
Enoncés

TD/TP série N° 2 …………………...……………………............................................................................... 3

TD/TP série N° 3 …………………...………………………………………………………………………... 5
TD/TP série N° 4 …………………...……………………………………………………………………..… 7
TD/TP série N° 5 …………………...……………………………………………………………………….. 9

Corrections

TD/TP série N° 3 …………………...……………………............................................................................. 10

TD/TP série N° 4 …………………...………………………………………………………………………. 19
TD/TP série N° 5 …………………...………………………………………………………………………. 28

2
Université Mohammed Premier Année universitaire 2014-2015
Faculté des Sciences Filière SMI
Département de Mathématiques Module : Système d’Exploitation I
et d’Informatique Semestre : S3

TD/TP: Série Numéro 2

Exercice1 :
1. Créer à l'aide de la commande « mkdir » un répertoire de nom « rep » dans votre répertoire racine
(répertoire de connexion ou « home directory »).
2. Placez-vous dans « rep » et examiner le contenu de ce dernier, en utilisant successivement les commandes
« ls », « ls -l », « ls -a ».
3. Le répertoire « rep » contient-il des fichiers ? Si oui, qui sont-ils ?
4. Tapper les commande suivante.
% cat .
% cd .
% pwd
Conclure:
% rm ..
% cd ..
% pwd
Conclure:
5. A partir du répertoire « rep » :
- Exécuter les commandes « ls -ai » et « ls -ali ». Conclure.
- Exécuter la commande « cd .. » ensuite « ls -id rep », conclure.
- Exécuter ensuite la commande « ls -id ~ » ou « ls -id ~etudiant », conclure.
6. Placez vous dans le répertoire « rep »,
- En utilisant la commande « cat », créez dans ce répertoire un fichier nommé « fich1.txt » contenant la
phrase : « Mon premier fichier sous unix. »
- Créer un répertoire « rep1 ». Ensuite se placer dans le répertoire « rep1 » et exécuter les commandes :
% ls -ali ~/rep
% ls -ali ..
% ls -ail ../..
% ls -ali ~
Comparer les résultats
7. Tappez
% cd /
% pwd
% cd ..
% pwd
Conclure
% cd
% pwd
Conclure
3
 % cd /
% cd ~
% pwd
Conclure
8. Placez−vous dans le répertoire « rep », ensuite exécuter les commandes suivantes :
%touch .fich1
%touch fich2
9. Remonter d’un niveau dans l’arborescence (exécuter la commande «% cd ..») puis effectuer les
commandes suivantes :
% ls -l rep
- Effacer les fichiers qui sont listés par la commande « ls ». Que se passe t-il si on exécute la commande.
% rmdir rep
- Exécuter la commande
% ls -la rep
Conclure
Exercice 2 :
1. Supposons que vous êtes connecté en tant que « etudiant ». A partir du sous-répertoire « rep », lister le
contenu du répertoire de connexion de l’utilisateur « smi » en utilisant un chemin absolu (Nom absolu) et un
chemin relatif (nom relatif).
2. Revenez à votre répertoire racine et créez un sous-répertoire nommé « Rep-unix ».
3. En utilisant cat, créez dans ce répertoire un fichier « fich1.txt » contenant la phrase :
« Mon premier fichier sous unix. »
4. Copiez le fichier « fich1.txt » dans « fich2.txt », ensuite comparer les i-nodes des deux fichiers.
5. Modifiez le nom du fichier « fich2.txt » en « fich3.txt », ensuite afficher les i-nodes des fichiers
« fiche1.txt » et « fiche3.tx ». Qu’observez vous au niveau i-nodes ?.
6. Créez un deuxième répertoire « test » dans votre répertoire racine, et un sous-répertoire « sous-test » dans
le répertoire « test ».
7. A partir du répertoire racine,
- déplacez le fichier « fich3.txt » le répertoire « ~/test/sous-test ».
- copiez le fichier « fich3.txt » dans votre répertoire racine.
- Supprimez le fichier fich3.txt du répertoire « ~/test/sous-test ».
8. A partir du répertoire « sous-test »
- Créez un lien physique nommé « lien_fich1» vers le fichier « fich1.txt »
- Comparer les i-nodes des fichiers « lien_fich1 » et « fich1.txt ».
- En utilisant la commande « cat », visualisez le contenu du fichier « lien_fich1 ». Qu’observez-vous ?
- Modifiez le fichier « fich1.txt » en rajoutant le mot ”fin” à la fin du fichier et visualisez le contenu du
fichier « lien_fich1 ». Qu’observez-vous ?
- Modifier le contenu du fichier « lien_fich1 » en rajoutant le mot « au revoir » à la fin du fichier et
visualiser le contenu de « fich1.txt ». Qu’observez-vous ? Conclure.
- Supprimer le fichier « fich1.txt »
- Visualiser le contenu de répertoire « sous-test »
- Visualiser le contenu du fichier « lien_fich1 ». Qu’observez-vous ?
9. Refaire le même travail avec un lien symbolique et comparer les deux résultats

4
Université Mohammed Premier Année universitaire 2014-2015
Faculté des Sciences Filière SMI
Département de Mathématiques Module : Système d’Exploitation I
et d’Informatique Semestre : S3

TD/TP: Série Numéro 3

Exercice1:
1. Que font les commandes suivantes :
 ls /etc
 ls /etc/*
 ls /etc/p*
 ls -d /etc
2. Donner la commande qui permet de lister les fichiers et sous- répertoires du répertoire « /etc » qui
commencent avec la lettre « p »
- sans lister le contenu des sous-répertoires trouvés.
- sans lister le contenu des sous-répertoires trouvés. L’affichage sera donné avec le masque de
protection pour chaque fichier.
- en plus elle liste de manière récursive, le contenu des sous-répertoires trouvés.
- suivie d’un caractère quelconque, suivi de la lettre « m », suivie de n’importe quelle chaine de
caractères, en plus, elle affiche le contenu de chaque sous-répertoire trouvé.
- suivie d’un caractère quelconque, suivi de la lettre « m », suivie de n’importe quelle chaine de
caractères, suivie de la lettre « a » ou de la lettre « d », sans lister le contenu des sous-répertoires
trouvés.
- suivie d’un caractère quelconque, suivi de la lettre « m » ou « n » ou « p », suivie de n’importe quelle
chaine de caractères. L’affichage sera donné avec plus d’informations sur chaque ficher affiché.
- suivie d’un caractère quelconque, suivi de la lettre « m », « n », « o » ou « p », suivie de n’importe
quelle chaine de caractères. L’affichage sera donné avec plus d’informations sur chaque ficher affiché.
3. Que font les commandes suivantes :
 ls /etc /bin
 ls -d /etc /bin/*
 ls /etc/p* /bin/b*

Exercice2:
Quelle est la commande qui permet de lister tous les fichiers de « /usr/bin » dont le nom:
 Commence par « as » ou par « sa ».
 Commence par « r », « s », « v », ou « z ».
 Ne commence ni avec « d » ni avec « s ».
 Comporte au moins un « f ».
 Comporte au moins deux « f ».
 Comporte au moins 3 caractères.
 Comporte exactement 3 caractères.
 Comporte au plus 3 caractères.

Exercice 3 :
1. Créer dans votre répertoire de connexion, un sous répertoire nommé « D2_tp3 ». Si ce répertoire
existe effacer son contenu.
5
2. A l’aide de l’éditeur de texte « gedit », écrire un programme en langage « C » qui affiche 10 fois la
chaine : "Je suis la tache 1". Sauvegarder ce programme, dans le répertoire « D2_tp3 », sous le nom
« tache1.c ».
3. Compiler et exécuter ce programme. Pour le fichier exécutable, on lui donne le nom « tache1 ».
4. Quels sont les droits d'accès pour ces deux fichiers.
5. En utilisant le symbole « = », modifier les droits d’accès du fichier « tache1.c » de telle sorte que la
lecture, l’écriture et l’exécution soient autorisées pour le propriétaire du fichier, les autres utilisateurs
n’auront aucun droit.
6. Enlever, au propriétaire le droit d’exécution et rajouter au groupe et aux autres utilisateurs la
possibilité de lire le fichier « tache1.c ».
7. Enlever, au propriétaire du fichier « tache1.c », le droit de lecture et lui rajouter le droit d’exécution,
ensuite recompiler le fichier, que se passe-t-il ?.
8. A l’aide de la forme octal, modifier les droits d’accès du fichier exécutable « tache1 » pour avoir les
permissions suivantes : « rw-r--r--r ».
Que se passe t-il si on exécute le programme ?
9. Enlever, au propriétaire du fichier « tache1.c », le droit d’écriture ensuite modifier le contenu du fichier
en remplaçant la chaine "je suis la tache1" par la chaine "tache1 \n". Que se passe-t-il ?
10. tapez la commande « ls -ld /etc ». En se basant sur le résultat obtenu, expliquer ce qui se passe
lorsqu’on tape les commandes suivantes
 cd /etc
 mkdir rep
 rm passwd
 ls -l passwd
 cd
 cp /etc/passwd .

Exercice 4 :
1. Créer un répertoire nommé « D21 » dans le répertoire « D2_tp3 ».
2. Déplacer le fichier « tache1 » dans le répertoire « D21 »
3. Créer un autre sous-répertoire nommé « table » du répertoire « D2_tp3 ».
4. Copier le fichier « tache1.c » dans le répertoire « D21 » et lui donner le nom « tache3.c »
5. A partir du répertoire « D2_tp3 » lancer la commande « find » qui cherche tous les noms des fichiers
qui commencent avec « ta ».
6. Enlever, pour le propriétaire, le droit de lecture sur le répertoire « D21 » et relancer la commande
« find ». Que se passe t-il ?
7. Relancer la commande « find » en redirigeant :
- les résultats dans le fichier « res.txt » et les erreurs vers le fichier « err.txt »
- les résultats et les erreurs vers fichiers « resultats.txt »
Exercice5 :
1. Ecrire une commande qui donne:
- le nombre de fichiers du répertoire courant
- le nombre de répertoires du répertoire courant
- le nombre de fichiers ordinaires du répertoire courant
2. Refaire la question 1 pour un répertoire donné
3. Ecrire une commande qui permet d’afficher :
- le nombre d’utilisateurs utilisant le « bash » comme shell par défaut
- les utilisateurs qui utilisent le « bash » comme shell par défaut.
- les utilisateurs qui utilisent le « bash » comme shell par défaut ainsi que leur nombre.
- les utilisateurs qui commence avec « e » ou « s » et qui utilise le « bash » comme shell par défaut.
6
Université Mohammed Premier Année universitaire 2014-2015
Faculté des Sciences Filière SMI
Département de Mathématiques Module : Système d’Exploitation I
et d’Informatique Semestre : S3

TD/TP: Série Numéro 4

Exercice1 :
En utilisant la commande find « lister » tous les fichiers qui ne sont ni des fichiers ordinaires ni des
répertoires. Pour les tests, vous créez un répertoire nommé « rep », ensuite à l’aide de la commande « cat »
ou « touch », créez deux fichiers nommés « fiche1 » et « fiche2 », enfin vous créez deux liens symboliques
nommés « lien_fiche1» vers le fichier « fiche1 » et « lien_fiche2» vers le fichier « fiche2 »
Exercice2:
A l’aide de la commande grep, lister tous les fichiers du répertoire /etc/X11 dont le nom
- Contient la lettre x.
- Commence par la lettre x.
- Contient la lettre x ou X.
- Commence avec la lettre X ou x.
- Commence par la lettre X ou x et qui contient un ou plusieurs chiffres.
- Commence par la lettre X ou x et qui finit par un chiffre.

Exercice3:
- Lister tous les fichiers cachés du répertoire de connexion sauf les répertoires.
- Lister tous les fichiers ordinaires cachés du répertoire de connexion.

Exercice4 :
1. Ecrire une commande qui donne la liste des fichiers du répertoire « /etc » qui commencent avec la lettre
« p » et qui sont triés par type.
2. Ecrire une commande qui donne la liste des fichiers du répertoire « /etc » qui commencent avec la lettre
« p » triés suivant le nombre de liens (ordre croissant et ordre décroissant).
3. Créer le fichier « resultat.txt » qui a le contenu suivant :
Nom Résultat
----------------------------------------------
Omar 18
Ali 8
Fatima 15
Mohammed 18
Houcine 16
Zahra 5
Hassane 15

a. Afficher le contenu du fichier « resultat.txt » sauf les deux lignes titres (les deux premières lignes).
b. Trier le fichier par ordre alphabétique (les deux lignes titres ne figurent pas sur la sortie).
c. Trier le ficher par ordre croissants suivant le champ « Résultat » (les deux lignes titres ne figurent
pas sur la sortie).
d. Trier le ficher par ordre décroissants suivant le champ « Résultat » (Les deux lignes titres figurent
sur la sortie).

7
 4. Supposons maintenant que le contenu du fichier « resultat.txt » est comme suit :
Nom Résultats
----------------------------------------------
Omar 18:10 :12
Ali 8 :19 :0
Fatima 15 :16 :12
Mohammed 18:10:20
Houcine 16:0:10
Zahra 5:13:10
Hassane 15 :16 :12
a. Trier le fichier par ordre croissant suivant le premier résultat
b. Trier le fichier par ordre croissants suivant le premier résultat, puis suivant le troisième résultat.
c. Afficher avec classement

Exercice5 :
1. Donner la commande qui permet d’afficher la liste de tous les utilisateurs.
2. Ecrire un script qui affiche la liste de tous les utilisateurs avec leur numéro de ligne de la façon suivante :
par exemple si l’utilisateur « etudiant » se trouve sur la ligne 4, alors il sera affiché comme suit :
etudiant:4

Exercice 6
1. Ecrire un script qui affiche ses paramètres dans l’ordre inverse.
2. Ecrire un script qui permet de saisir une série de nombres. La saisie s’arrête quand l’utilisateur tape la
valeur 0. Ensuite le script affiche les nombres saisis dans l’ordre inverse.

Exercice 7
A l’aide des structure conditionnelle « if » et « case-esac » :
1. Ecrire un script qui affiche un message indiquant les types des fichiers passés en argument au script.
2. Ecrire un script qui affiche un message indiquant les types des fichiers du répertoire courant.

8
Université Mohammed Premier Année universitaire 2014-2015
Faculté des Sciences Filière SMI
Département de Mathématiques Module : Système d’Exploitation I
et d’Informatique Semestre : S3

TD: Série Numéro 5

A corriger pendant la séance du cours du Lundi 22 Décembre 2014

Exercice 1 :
On reprend les données de l’exercice 4 (série TD-TP N°4), question 4 : Supposons que le contenu du fichier
« resultat.txt » est comme suit :
Nom Résultats
----------------------------------------------
Omar 18:10 :12
Ali 8 :19 :0
Fatima 15 :16 :12
Mohammed 18:10:20
Houcine 16:0:10
Zahra 5:13:10
Hassane 15 :16 :12

Ecrire un script shell qui permet de rajouter dans le fichier « resultat.txt » une nouvelle colonne qui contient
la somme des trois résultats.

Exercice 2 :
Ecrire un script shell qui permet de calculer le PGCD de deux entiers positifs passés en argument au script
(paramètres positionnels) en utilisant l’algorithme d’Euclide défini de la façon suivante :
Soit 0≤b≤a
Si b=0
pgcd(a,b) = a
Sinon
pgcd(a,b)=pgcd(b,r) où r est la division euclidienne entre a et b : a = bq + r avec 0≤r<b

Le script contient :
- Une fonction qui test que les arguments sont des entiers positifs
- Une fonction qui calcule le PGCD de manière itérative
- Une fonction qui calcule le PGCD de manière récursive.

9
 Correction
TD/TP: Série Numéro 3
Exercice1:
1. Que font les commandes suivantes :
 ls /etc
Rep : affiche la liste des fichiers et sous-répertoires du répertoire « /etc » sauf les fichiers et
répertoires cachés.

 ls /etc/*
Rep : affiche la liste des fichiers et sous-répertoires ainsi que le contenu de chaque sous-répertoire du
répertoire « /etc » sauf les fichiers et répertoires cachés.

 ls /etc/p*
Rep : Affiche la liste des fichiers et sous-répertoires du répertoire « /etc », qui commencent avec la
lettre « p », en plus, elle affiche le contenu de chaque sous-répertoire trouvé.

 ls -d /etc
Rep : cette commande vérifie si le fichier « /etc » existe, si oui elle affiche son nom.

4. Donner la commande qui permet de lister les fichiers et sous- répertoires du répertoire « /etc » qui
commencent avec la lettre « p », sans lister le contenu des sous-répertoires trouvés.
Rep :
%ls -d /etc/p*

5. Donner la commande qui permet de lister les fichiers et sous- répertoires du répertoire « /etc » qui
commencent avec la lettre « p », sans lister le contenu des sous-répertoires trouvés. L’affichage sera donné
avec la masque de protection pour chaque fichier.
Rep :
%ls -ld /etc/p*

6. Donner la commande qui permet de lister les fichiers et sous- répertoires du répertoire « /etc » qui
commencent avec la lettre « p », en plus lister, de manière récursive, le contenu des sous-répertoires.
Rep :
%ls -R /etc/p*

10
7. Donner la commande qui permet de lister les fichiers et sous-répertoires du répertoire « /etc » qui
commencent avec la lettre « p » suivie d’un caractère quelconque, suivi de la lettre « m » suivie de
n’importe quelle chaine de caractères, en plus, elle affiche le contenu de chaque sous-répertoire trouvé.
Rep :
%ls /etc/p?m*

8. Donner la commande qui permet de lister les fichiers et sous- répertoires du répertoire « /etc » qui
commencent avec la lettre « p » suivie d’un caractère quelconque, suivi de la lettre « m » suivie de
n’importe quelle chaine de caractères suivie de la lettre « a » ou la lettre « d », sans lister le contenu des
sous-répertoires trouvés.
Rep :
%ls -d /etc/p?m*[a,d] ou % ls /etc/p?m*[ad]

9. Donner la commande qui permet de lister les fichiers et sous-répertoires du répertoire « /etc » qui
commencent avec la lettre « p » suivie d’un caractère quelconque, suivi de la lettre « m », « n » ou « p »
suivie de n’importe quelle chaine de caractères, du répertoire « /etc ». L’affichage sera donné avec plus
d’informations sur chaque ficher affiché.
Rep :
%ls -ld /etc/p?[m,n,p]*

10. Donner la commande qui permet de lister les fichiers et sous-répertoires du répertoire « /etc » qui
commencent avec la lettre « p » suivie d’un caractère quelconque, suivi de la lettre « m », « n », « o » ou
« p » suivie de n’importe quelle chaine de caractères, du répertoire « /etc ». L’affichage sera donné avec
plus d’informations sur chaque ficher affiché.
Rep :
%ls -ld /etc/p?[m-p]*

11. Que font les commandes suivantes :

 ls /etc /bin
Rep : affiche la liste des fichiers et sous-répertoires du répertoire « /bin » suivi de la liste des fichiers
et sous-répertoires du répertoire « /etc ».

 ls -d /etc /bin/*
Rep : affiche la liste des fichiers et sous-répertoires du répertoire « /bin», ainsi que le contenu de
chaque sous-répertoire trouvé, suivi du répertoire « /etc ».

 ls /etc/p* /bin/b*

11
 Rep : affiche la liste des fichiers et sous-répertoires qui commencent avec la lettre « b » du répertoire
« /bin » suivie de la liste des fichiers et sous-répertoires qui commencent avec la lettre « p » du
répertoire « /etc » ainsi que le contenu de chaque sous-répertoire trouvé.

Exercice2:
Quelle est la commande qui permet de lister tous les fichiers de « /usr/bin » dont le nom:
 Commence par « as » ou par « sa ».
Rep :
%ls -d /usr/bin/as* /usr/bin/sa*

ou
%ls -d /usr/bin/as* ; ls -d /usr/bin/sa*

 Commence par « r », « s », « v », ou « z ».
Rep :
%ls -d [rsvz]*

 Ne commence ni avec « d » ni avec « s ».

Rep :
%ls -d /usr/bin/[!ds]* ou ls /usr/bin/[^ds]*

 Comporte au moins un « f ».
Rep :
%ls -d /usr/bin/*f*

 Comporte au moins deux « f ».

Rep :
%ls -d *f*f*

 Comporte au moins 3 caractères.

Rep :
%ls -d /usr/bin/???*

12
  Comporte exactement 3 caractères.
Rep :
%ls -d /usr/bin/???

 Comporte au plus 3 caractères.

Rep :
%ls -d /usr/bin/? /usr/bin/?? /usr/bin/???
Ou
%ls -d /usr/bin/? ; ls -d /usr/bin/?? ; ls -d /usr/bin/???

Exercice 3 :
11. Créer dans votre répertoire racine, un sous répertoire nommé « D2_tp3 ». Si ce répertoire existe
effacer son contenu.
Rep :
- Sil n’existe pas, on exécute la commande « mkdir D2_tp3 » pour le créer
- S’il existe, à partir du répertoire « D2_tp3 », on exécute la commande : « rm -r * »

12. A l’aide de l’éditeur de texte « gedit », écrire un programme en langage « c » qui affiche 1000 fois la
chaine : "Je suis la tache 1". Sauvegarder ce programme, dans le répertoire « D2_tp3 », sous le nom
« tache1.c ».
Rep :
#include <stdio.h>
main() {
int i= 1 ;
int N=1000
while (i<=N) {
printf("Je suis la tache 1") ;
i=i+1 ;
}
}
13. Compiler et exécuter ce programme. Pour le fichier exécutable, on lui donne le nom « tache1 ».
Rep :
% gcc -o tache1 tache1.c
13
 Dans ce cas le nom du fichier exécutable est « tache1 ».

14. Quels sont les droits d'accès pour ces deux fichiers.
Rep : On exécute la commande :
% ls -l »
ou
% ls -l tache1.c tache1 »
- Le premier caractère désigne le type du fichier
- Les 9 caractères qui suivent désignent les droits d’accès.
Pour le fichier source « tache1.c » on a les droits suivants: rw-r--r--
Le propriétaire a le droit de lecture et d’écriture (les trois premiers caractères rw-)
Les membres du groupe ont le droit de lecture (les trois caractères qui suivent r--)
Les autres utilisateurs ont le droit de lecture (les trois caractères qui suivent r--).
Pour le fichier exécutable « tache1 » on a les droits suivants: rwxr-xr-x
Le propriétaire a le droit de lecture, d’écriture et d’exécution (les trois premiers caractères rwx)
Les membres du groupe ont le droit de lecture et d’exécution (les trois caractères qui suivent r-x)
Les autres utilisateurs ont le droit de lecture et d’exécution (les trois caractères qui suivent r-x).

15. En utilisant la symbole « = », modifier les droits d’accès du fichier « tache1.c » de telle sorte que la
lecture, l’écriture et l’exécution soient autorisées pour le propriétaire du fichier, les autres utilisateurs
n’auront.
Rep :
% chmod u=rwx,g=,o= tache1.c

16. Enlever, au propriétaire du fichier « tache1.c », le droit d’exécution et rajouter au groupe et aux autres
utilisateurs la possibilité de lire le fichier « tache1.c ».
Rep :
% chmod u-x tache1.c ; chmod g+r tache1.c ; chmod o+r tache1.c
ou
% chmod u-x,g+r,o+r tache1.c
ou
% chmod u-x,go+r tache1.c

17. Enlever, au propriétaire du fichier « tache1.c », le droit de lecture et lui rajouter le droit d’exécution,
ensuite recompiler le fichier, que se passe-t-il ?.

14
 Rep :
% chmod u-r,u+x tache1.c
La compilation ne pourra pas avoir lieu, en effet, on ne peut pas ouvrir le fichier « tache1.c » car le
propriétaire n’est pas autorisé en lecture.
 message d’erreur

18. Copier le fichier « tache1.c » « tache2.c »

Rep :
% cp tache1.c tache2.c
Message d’erreur : on ne peut pas ouvrir le fichier « tache1.c » en effet ce fichier n’est autorisé en
lecture.

19. A l’aide de la forme octal, modifier les droits d’accès du fichier exécutable « tache1 » pour avoir les
permissions suivantes : « rw-r--r-- ».
Rep :
Pour avoir la forme octal, on remplace, pour chaque utilisateur, les droits « r », « w » et « x » par 1 et
« - » par 0. Pour chaque utilisateur on obtient un nombre écrit en base 2 ensuite on le réécrit en base
10.
rw- r-- r--
110 100 100
6 4 4

La commande à exécuter pour avoir les permissions:

% chmod 644

Que se passe t-il si on exécute le programme ??

Rep : On ne peut exécuter le programme (fichier « tache1 ») car il n’est pas autorisé en exécution
 Le message suivant est affiche : Bash : ./tache1 : Permission non accordée

20. Enlever, au propriétaire du fichier « tache1.c », le droit d’écriture ensuite modifier le contenu du fichier
en remplaçant la chaine "je suis la tache1" par la chaine "tache1 \n". Que se passe-t-il ??
Rep : après modification, on ne peut pas enregistrer le fichier car il n’est pas autorisé en écriture.

21. Tapez la commande « ls -ld /etc ». En se basant sur le résultat obtenu, expliquer ce qui se passe
lorsqu’on tape les commandes suivantes
 cd /etc
Rep: on peut exécuter la commande « cd /etc », car les autres utilisateurs (other) ont le droit
d’exécution (le droit « x ») sur ce répertoire.

 mkdir rep
Rep: on ne peut pas créer le répertoire « rep » dans le répertoire « /etc » car ce dernier n’est pas
autorisé en écriture pour les autres utilisateurs (les utilisateurs « others » n’ont pas le droit « w »).

 rm passwd
Rep: on ne peut pas supprimer le fichier « passwd » car les autres utilisateurs (others) n’ont pas le
droit d’écriture (n’ont pas le droit « w ») dans le répertoire « /etc ».
15
  ls -l passwd
Rep: affiche les droits d’accès du fichier « passwd », le nombre de liens, propriétaire, ….
-rw-r--r-- 1 root root 1747 2014-10-20 11 :07 b /etc/passwd
 cd
Rep : on revient sur le répertoire de connexion.
 cp /etc/passwd .
Rep : on peut copier le fichier « /etc/passwd » dans le répertoire de connexion car les autres
utilisateurs ont le droit de lecture (le droit « r ») sur le fichier « passwd ».

Exercice 4 :
1. Créer un répertoire nommé « D21 » dans le répertoire « D2_tp3 ».
Rep :
- A partir du répertoire « D2_tp3 », on exécute la commande
% mkdir D21
- A partir du répertoire de connexion, on exécute la commande
% mkdir D2_tp3/D21

2. Déplacer le fichier « tache1 » dans le répertoire « D21 »

Rep :
- A partir du répertoire « D2_tp3 », on exécute la commande
%mv tache1 D21
- A partir du répertoire de connexion, on exécute la commande :
%mv D2_tp3/tache1 D2_tp3/D21

3. Créer un autre sous-répertoire nommé « table » du répertoire « D2_tp3 ».

Rep :
- A partir du répertoire « D2_tp3 », on exécute la commande :
% mkdir table
- A partir du répertoire de connexion, on exécute la commande :
% mkdir D2_tp3/table

4. Copier le fichier « tache1.c » dans le répertoire « D21 » et lui donner le nom « tache3.c »
Rep :
- A partir du répertoire « D2_tp3 », on exécute la commande :
% cp tache1.c table/tache3.c »
- A partir du répertoire de connexion, on exécute la commande
% cp D2_tp3/tache1.c D2_tp3/table/tache3.c »

5. A partir du répertoire « D2_tp3 » lancer la commande « find » qui cherche tous les noms des fichiers
qui commencent avec « ta ».
Rep :
% find . -name "ta*" -type f -print
% find . -name "ta*" -print
La différence entre les deux:
- La première n’affiche pas « ./table », en effet l’option « -type f », n’affiche que les fichiers.
- Par contre, la deuxième affiche les répertoires (dans ce cas la commande affiche « ./tab »).

16
 6. Enlever, pour le propriétaire, le droit de lecture du répertoire « D21 » et relancer la commande
« find ».
Rep :
%chmod u-r D21
% find . -name "ta*" -type f –print
En plus des fichiers trouvés et affichés, un message d’erreur est affiché:
find : « ./D21 » :permission non accordée.
En effet, le propriétaire n’a pas le droit d’exploration du répertoire « D21 » car il n’est pas autorisé en
lecture.

7. Relancer la commande « find » en redirigeant :

- les résultats dans le fichier « res.txt » et les erreurs vers le fichier « err.txt »
Rep :
% find . -name "ta*" -type f > res.txt 2>err.txt

- les résultats et les erreurs vers fichiers « resultats.txt »

Rep :
% find . -name "ta*" -type f &>resultants.txt

Exercice5 :
4. Ecrire une commande qui donne le nombre de fichiers du répertoire courant
Rep :
% ls -al | wc -l

5. Ecrire une commande qui donne le nombre de répertoires du répertoire courant

Rep:
% ls -al | grep ^d | wc -l

6. Ecrire une commande qui donne le nombre de fichiers ordinaires du répertoire courant
Rep :
%ls -al | grep ^- | wc -l

7. refaire 1 et 2 pour un répertoire donné

Rep:
%ls -al rep | wc -l;.

8. Ecrire une commande qui permet d'afficher le nombre d’utilisateurs utilisant le « bash » comme shell
par défaut
Rep:
% grep bash /etc/passwd | wc -l

9. Ecrire une commande qui permet d'afficher les utilisateurs qui utilisent le « bash » comme shell par
défaut.
Rep :
%grep bash /etc/passwd | cut -f 1 -d":"

17
10. Ecrire une commande qui permet d'afficher les utilisateurs qui utilisent le « bash » comme shell
par défaut ainsi que leur nombre.
Rep :
%grep bash /etc/passwd | cut -f1 -d: ; grep bash /etc/passwd | wc –l

11. Ecrire une commande qui permet d'afficher les utilisateurs qui commence avec « e » ou « s » et
qui utilise le « bash » comme shell par défaut.
Rep :
% grep ^[es] /etc/passwd | grep "bash$"
ou
% grep ^[es] /etc/passwd | grep "bash"
ou
%grep bash /etc/passwd | grep ^[es]

18
 Correction
TD/TP: Série Numéro 4
Exercice1 :
En utilisant la commande find « lister » tous les fichiers qui ne sont ni des fichiers ordinaires ni des
répertoires. Pour les tests, vous créez un répertoire nommé « rep », ensuite à l’aide de la commande « cat »
ou « touch », créez deux fichiers nommés « fiche1 » et « fiche2 », enfin vous créez deux liens symboliques
nommés « lien_fiche1» vers le fichier « fiche1 » et « lien_fiche2» vers le fichier « fiche2 »
Rep : find . ! \( -type f -o type d \) -ls

Questions complémentaires : que font les commandes suivantes ?

% find . \( -type f -o type d \) -ls
Cette commande affiche les fichiers ordinaires et les répertoires y compris les fichiers cachés.
% find . \( -type f -a type d \) -ls
Cette commande n’affiche rien : car un fichier ne peut pas être un fichier ordinaire et en mêm
temps un répertoire
% find . ! \( -type f -a type d \) -ls
Cette commande affiche tous les fichiers : en effet c’est la négation d’un fichier qui est en
même temps ordinaire et répertoire.

Exercice2:
A l’aide de la commande grep, lister tous les fichiers du répertoire /etc/X11 dont le nom
- Contient le caractère x.
Rep : ls /etc/X11 | grep x

- Commence par le caractère x.

Rep : ls /etc/X11 | grep ^x

- Contient la lettre x ou X.
Rep : ls /etc/X11/ | grep "[x|X]" ou ls /etc/X11/ | grep "[x|X]"
ou
ls /etc/X11/ | grep "[x,X]"
ou
ls /etc/X11/ | grep "[xX]"

- Commence avec la lettre X ou x.

Rep : ls /etc/X11/ | grep "^[x|X]"

- Commence par la lettre X ou x et qui contient un ou plusieurs chiffres.

Rep1 :
ls /etc/X11/ | grep "^[x|X].*[0-9]"
Rep2 :
ls /etc/X11/ | grep "^[x|X]" | grep "[0-9]"

- Commence par la lettre X ou x et qui finit par un chiffre.

19
 Rep 1 : ls /etc/X11/ | grep "^[x|X].*[0-9]$ "

Rep 2 : ls /etc/X11/ | grep "^[x|X] " | grep " [0-9]$ "

Remarque : On peut mettre les simples quotes ou les doubles quotes mais attention leurs sens diffèrent (voir
le cours)

Exercice3:
- Lister tous les fichiers cachés du répertoire de connexion sauf les répertoires.
Remarque 1 :
La commande « ls -aF » liste tous les fichiers y compris les fichiers cachés en rajoutant le caractère
« / » à la fin des répertoires (voir le cours)
Rep 1: ls -aF | grep "^\." | grep " [^/]$ "
 "^\." : désigne les noms des fichiers qui commencent avec « . »
N.B. on utilise « \ » pour verrouiller l’interprétation du métacaractère « . », dans ce cas « . » sera
considéré comme un caractère et non comme un métacaractère.
 " [^/]$": désigne les noms des fichiers qui terminent avec “/”.

Remarque 2 : La commande peut être appliquée pour un répertoire quelconque, dans ce cas il suffit de spécifier le
chemin du répertoire. Par exemple, refaire la même question pour le répertoire « rep » qui est un sous répertoire du
répertoire courant.
% ls -aF rep | grep "^\." | grep " [^/]$"

Rep 2: On peut regrouper les deux « grep »

% ls -aF | grep "^\..*[^/]$"

Rep3 : On affiche seulement les fichiers qui commence avec « . », ensuite on fait « grep » pour sélectionner les
fichiers qui ne sont pas des répertoires (les noms qui ne se terminent pas avec « / »).
% ls -adF .*| grep "[^/]$ "

Remarque 3: on rajoute l’option « -d » pour ne pas afficher les contenus des sou répertoires.

- Lister tous les fichiers ordinaires cachés du répertoire de connexion.

Rep 1 :
 Tous d’abord on liste tous les fichiers du répertoire avec la commande « ls -al »
 Ensuite, on sélectionne les fichiers ordinaires, ce sont les lignes qui commencent avec le caractère
«-» (commande grep "^-").
 L’affichage de la commande « ls -l » donne les informations sur les fichiers organisées en champ
séparés par des espaces. Pour éviter les confusions, on remplace les espaces par « : » (commande
tr -s " " ":"), on utilise l’option « -s » pour réduire les espaces successives en un seul espace.
 Après, on sélectionne le dernier champ, c’est le champ qui contient les noms des fichiers. On doit
compter pour connaître le numéro du champ (ceci dépend de l’affichage). Dans l’environnement
avec lequel je travaille la commande est « cut -f9,9 -d: » (c’est le 9 ème champ).
 En fin, on sélectionne les noms des fichiers qui commencent avec « . » en utilisant la commande
(grep "^\.")

La commande est : ls -al | grep "^-" | tr -s " " ":" | cut -f9,9 -d: | grep "^\."

20
 Rep 2 :
 Au lieu de sélectionner les noms des fichiers en utilisant les champs, on peut faire la sélection en
comptant les colonnes (les caractères). Dans l’environnement avec lequel je travaille, les noms
des fichiers commencent à partir de la colonne 53 (à partir du caractère 53 y compris les espaces)

La commande est : ls -al | grep "^-" | cut -c53- | grep "^\."

Exercice4 :
1. Ecrire une commande qui donne la liste des fichiers du répertoire « /etc » qui commencent avec la lettre
« p » et qui sont triés par type.
Rep : ls -ld /etc/p* | sort

2. Ecrire une commande qui donne la liste des fichiers du répertoire « /etc » qui commencent avec la lettre
« p » triés suivant le nombre de liens (ordre croissant et ordre décroissant).
Rep :
- Ordre croissant : ls -ld /etc/p* | sort -n k2,2 ou ls -ld /etc/p* | sort -k2n,2n
- Ordre décroissant : ls -ld /etc/p* | sort -n -r -k2,2 ou ls -ld /etc/p* | sort -k2nr,2nr

3. Créer le fichier « resultat.txt » qui a le contenu suivant :

Nom Résultat
----------------------------------------------
Omar 18
Ali 8
Fatima 15
Mohammed 18
Houcine 16
Zahra 5
Hassane 15

e. Afficher le contenu du fichier résultats sauf les deux lignes titres (les deux premières
lignes).
Rep : tail -n +3

f. Trier le fichier par ordre alphabétique (les deux lignes titres ne figurent pas sur la sortie).
Rep : tail -n +3 resultat.txt | sort

g. Trier le ficher par ordre croissants suivant le champ « Résultat » (les deux lignes titres ne
figurent pas sur la sortie).
Rep :
tail -n +3 resultat.txt | sort -n -k2
ou
tail -n +3 resultat.txt | sort -n -k2,2
ou
tail -n +3 resultat.txt | sort -k2n ou tail -n +3 resultat.txt | sort -k2n,2n
Remarque : pour la commande « sort » on doit rajouter l’option « -n », sinon le trie se fait
par ordre ASCII, dans ce cas on a 18 < 5 < 8.

21
 h. Trier le ficher par ordre décroissants suivant le champ « Résultat » (Les deux lignes titres
ne figurent pas sur la sortie).
Rep :
tail -n +3 resultat.txt | sort -n -r -k2,2
ou
tail -n +3 resultat.txt | sort -k2nr,2nr

4. Supposons maintenant que le contenu du fichier « resultat.txt » est comme suit :

Nom Résultats
----------------------------------------------
Omar 18:10 :12
Ali 8 :19 :0
Fatima 15 :16 :12
Mohammed 18:10:20
Houcine 16:0:10
Zahra 5:13:10
Hassane 15 :16 :12

d. Trier le fichier par ordre croissant suivant le premier résultat

Rep 1 :
On doit unifier les séparateurs des champs, en transformant tous les séparateurs de champs en « : ».
- Si on suppose que les noms sont séparés des résultats par des tabulations alors on
transforme les tabulations en « : » avec la commande : tr -s "$\t" ":"
Pour faire le tri suivant le deuxième champ, on utilise la commande :
% tail -n +3 resultat.txt | tr -s "$\t" ":" | sort –n -k2,2 -t :

- Si on suppose que les noms sont séparés des résultats par des espaces et par des
tabulations alors on transforme, tous d’abord, les tabulations en espaces ensuite on transforme les
espaces en « : » avec la commande : tr "$\t" " " | tr -s " " ":"

Pour faire le tri suivant le deuxième champ, on utilise la commande :

% tail -n +3 resultat.txt | tr "$\t" " " | tr -s " " ":" | sort -n -k2,2 -t :

Remarque : Dans ce cas Mohammed est affiché avant Omar

e. Trier le fichier par ordre croissants suivant le premier résultat, puis suivant le troisième.
% tail -n +3 resultat.txt | tr "$\t" " " | tr -s " " ":" | sort -n k2,2 –k4,4 -t :
Dans ce cas « Omar » sera classé avant « Mohammed »
f.Afficher avec classement
% tail -n +3 resultat.txt | tr "$\t" " " | tr -s " " ":" | sort -n k2,2 –k4,4 -t : | cat -n
% tail -n +3 resultat.txt | tr "$\t" " " | tr -s " " ":" | sort -n k2,2 –k4,4 -t : | cat -b
L’option « -b » identique à « -n » en ignorant les lignes vides.

Exercice5 :
3. Donner la commande qui permet d’afficher la liste de tous les utilisateurs.
Rep 1: cut -d: -f1 /etc/passwd ou cut -d":" -f1 /etc/passwd

22
4. Ecrire un script qui affiche la liste de tous les utilisateurs avec leur numéro de ligne de la façon suivante :
par exemple si l’utilisateur « etudiant » se trouve sur la ligne 4, alors il sera affiché comme suit :
etudiant:4
Rep:
#!/bin/bash
echo "Liste des utilisateurs dans /etc/passwd"
let i=1
for params in `cut -d: -f1`
do
echo "$params:$i "
let i=i+1
done

N.B. Dans cette solution, si un nom d’utilisateur est composé de deux chaines séparées par des
espaces alors chaque chaine sera considérée comme un utilisateur.
Refaire le script, en utilisant par exemple les commandes « tail » et « head », pour éviter ce problème.

Exercice 6
1. Ecrire un script qui affiche ses paramètres dans l’ordre inverse.
Réponse :
1.
#!/bin/bash
let i=0
for param in "$@" # Voir pourquoi les doubles quotes sont nécessaires ?????
do
tab[i]=$param
i=$((i+1))
done
echo "affichage dans l'ordre inverse "

let n=${#tab[@]} # taille du tableau = nombre de paramètres

# avec la boucle for
for i in ${!tab[@]} # «${!tab[*]}» désigne l’ensemble des indices du tableau.
do
let j=$n-$i-1
echo " ${tab[$j]}"
done

# avec la boucle while

let i=$n
while [ $i –gt 0 ]
do
echo ${tab[$i]}
let i=i-1
done

2. Créer un script qui permet de saisir une série de nombres. La saisie s’arrête quand l’utilisateur tape la valeur 0.
Ensuite le script affiche les nombres saisis dans l’ordre inverse.

23
Rappel : Statut de la commande « expr expression»
 si l'expression est valide le code retour est soit 0 ou 1:
 si l'expression n’est pas valide, le code retour vaut une autre valeur (en général 2).

Réponse :
Solution algorithmique
Tant que vrai
Lire une valeur au clavier
Si la valeur lue est un entier non nul alors on le sauvegarde dans un tableau.
Si la valeur lue est un entier nul alors on quitte la boucle.
Si la valeur lue n’est pas un entier alors un message sera affiché demandant de saisir un entier.
FinTantque
On affiche les éléments du tableau dans le sens inverse.

Script shell
Tout d’abord on teste si la valeur saisie est un entier. Pour cela, on exploite le code retour (le statut) de la
commande « expr " en exécutant par exemple la commande suivante :
expr $a + 0
Si son statut est < 2 alors $a est un entier.
Si son statut est ≥2 alors $ a n’est pas un entier.

Ensuite pour éviter les affichages inutiles (résultats de l’expression " expr " et messages d’erreurs on utilise
des fichiers temporaires dans lesquels on redirige les résultats et les erreurs et on les effaces à la fin du
script.)

#!/bin/bash
let i=0
while true
do
echo "Saisir un entier "
read a
expr $a + 0 &>err # les résultats et les erreurs sont redirigés dans le fichier « err »
#expr $a + 0 2>err >res # les résultats sont redirigés vers « res » et les erreurs vers « err »
etat=$? # On sauvegarde le statut de la dernière commande dans la varible « etat »
if test $etat -lt 2 # $a est un entier
then
if test $a -eq 0 # si l’entier saisi est un 0
then
break # fin de la saisie. On quitte la boucle while
else
tab[i]=$a # on sauvegarde l’entier saisi dans le tableau tab
let i=i+1
fi
else # la valeur saisie n’est pas un entier
echo " il faut saisir un entier "
fi
done
# on efface les fichiers temporaires
rm err

24
 #rm err res
#affichage des entier dans l’ordre inverse de la saisie
echo "Les éléments saisis dans l'ordre inverse"
let n=${#tab[@]}
for i in ${!tab[@]}
do
let j=$n-$i-1
echo "${tab[$j]}"
done

Exercice 7
A l’aide des structure conditionnelle « if » et « case-esac » :
3. Ecrire un script qui affiche un message indiquant les types des fichiers passés en argument au script.
Rep1: Structure « if » avec la commande « test »:

#!/bin/bash
for fiche in "$@" # ou for fiche in "$*" ou for fiche in "$@" ou for fiche
do
if test -d "$ fiche "
then
echo "$fiche est un répertoire"
elif test -f "$ fiche "
then
echo "$ fiche est un fichier ordinaire"
elif test -L "$ fiche "
then
echo "$ fiche est un lien symbolique"
else
echo "$ fiche est d’un autre type ""
fi
done

Rep2: Structure « if » avec « [ ] » pour les test:

#!/bin/bash
for fiche in "$@" # ou for fiche in "$*" ou for fiche in "$@" ou for fiche
do
if [ -d $ fiche ]
then
echo "$ fiche est un répertoire"
elif [ -f $ fiche ]
then
echo "$ fiche est un fichier ordinaire"
elif [ -L $ fiche ]
then
echo "$ fiche est un lien symbolique"
else
echo "$ fiche est d’un autre type ""
fi
done
25
Rep3: Structure « case-esac » :
#!bin/bash
for fiche in "$@" # permet de parcourir les paramètres positionnels (les arguments du script)
do
type_fic=`ls -ld $ fiche | cut -c1` # on récupère dans la variable « type_fic » le type du fichier
case $type_fic in
-) echo " $fiche est un fichier ordinaire" ;;
d) echo " $fiche est un répertoire" ;;
l) echo " $fiche est un lien symbolique" ;;
*) echo " $fiche est d’un autr type" ;;
esac
done

4. Ecrire un script qui affiche un message indiquant les types des fichiers du répertoire courant.
Rep1 : structure « if » et la boucle « for »
Au lieu d’avoir les fichiers à tester comme paramètres positionnels (« for fiche in "$@" » ) on doit faire les
tests pour les fichiers du répertoire courant, pour cela on utilise les back quotes pour substituer le résultat de la
commande « ls » dans une liste qu’on peut parcourir avec la commande « for » de la manière suivante :
for fiche in `ls` # ou for fiche in $(ls)

Les reste ne change pas:

#!/bin/bash
for fiche in `ls` # ou for fiche in $(ls)
do
if test -d "$fiche"
then
echo "$fiche est un répertoire"
elif test -f "$fiche"
then
echo "$fiche est un fichier ordinaire"
elif test -L "$fiche"
then
echo "$fiche est un lien symbolique"
else
echo "$fiche est d’un autre type ""
fi
done
Rep2 : structure « case-esac » et la boucle « for »
#!/bin/bash
for fiche in `ls` # ou for fiche in $(ls)
do
type_fic=`ls -ld $fiche | cut -c1`
case $type_fic in
-) echo " $fiche est un fichier ordinaire" ;;
d) echo " $fiche est un répertoire" ;;
l) echo " $fiche est un lien symbolique" ;;
*) echo " $fiche est d’un autre type" ;;
esac
done
26
Rep3 : structure « if » et la boucle while
#!/bin/bash
ls | while read fiche
do
if test -d "$fiche"
then
echo "$fiche est un répertoire"
elif test -f "$fiche"
then
echo "$fiche est un fichier ordinaire"
elif test -L "$fiche"
then
echo "$fiche est un lien symbolique"
else
echo "$fiche est d’un autre type ""
fi
done

Rep4 : structure « case-esac » et la boucle while

#!/bin/bash
ls | while read fiche
do
type_fic="ls -ld $fiche | cut -c1"
case $type_fic in
-) echo " $fiche est un fichier ordinaire" ;;
d) echo " $fiche est un répertoire" ;;
l) echo " $fiche est un lien symbolique" ;;
*) echo " $fiche est d’un autre type" ;;
esac
done

27
 Correction
TD/TP: Série Numéro 5

Exercice 1 :
On reprend les données de l’exercice 4 (série TD-TP N°4), question 4 : Supposons que le contenu du fichier
« resultat.txt » est comme suit :
Nom Résultats
----------------------------------------------
Omar 18:10 :12
Ali 8 :19 :0
Fatima 15 :16 :12
Mohammed 18:10:20
Houcine 16:0:10
Zahra 5:13:10
Hassane 15 :16 :12

Ecrire un script shell qui permet de rajouter dans le fichier « resultat.txt » une nouvelle colonne qui contient
la somme des trois résultats.

Réponse
On extrait uniquement les champs résultats et on les sauvegarde dans un fichier nommée « res_plus »
et on transforme les « : » avec le symbole « + ». Pour cela :
- Tout d’abord, on uniformise les séparateurs de champs en transformant tous les espaces et
tabulation en « : » en utilisant la commande :
tail -n +3 resultat.txt | tr "$\t" " " | tr -s " " ":" | cut -f2,3,4 -d: | tr ":" "+" > res_plus
- Ensuite on sélectionne uniquement les résultats (les champs 2, 3 et 4) en utilisant la commande :
cut -f2,3,4 -d:
- En fin en transforme les « : » en« + » en on sauvegarde le résultat dans un fichier nommé
« res_plus » en utilisant la commande
tr ":" "+" > res_plus

Finalement la commande est :

tail -n +3 resultat.txt | tr "$\t" " " | tr -s " " ":" | cut -f2,3,4 -d: | tr ":" "+" > res_plus

On sauvegarde le nombre de lignes du fichier « res_plus » dans la variable « nb » en utilisant la

substitution des commandes avec les back quotes.
let nb=`wc -l < res_plus`

En fin on itère sur les lignes du fichier « res_plus » où chaque ligne du fichier est de la forme
« res1+res2+res3 » avec res1, res2 et res3 sont des entiers. Pour évaluer cette expression, il suffit
d’appeler la commande « let ». Pour calculer la somme « s » de la ligne « i » du fichier « res_plus »
on exécute la commande suivante et on substitue (on utilise les back quotes) le résultat de la
commande dans la variable « s » de la manière suivante :
let s=`tail -n +$i < res_plus | head -1 `
28
 Pour sauvegarder le résultat de l’évaluation dans un fichier « res_somme » on utilise la commande :
echo "$s" >> res_somme

Le scripte pour parcourir tous les lignes du fichier « res_somme »

let i=1
while [ $i -le $nb ]
do
let s=`tail -n +$i < res_plus | head -1 `
echo "$s" >> res_somme
let i=i+1
done
Pour accoler les somme suavegardées dans le fichier « res_somme » vans le fichier « resultat.txt »
- Dans le fichier « res » on sauvegarde les données du fichier « resultat » sauf les deux premières
lignes, à l’aide de la commande :
tail -n +3 resultat.txt > res
- On utilse la commande « paste » pour accoler les lignes des fichiers « res » et le fichier
« res_somme » ensuite on sauvegarde les résultats dans le fichier « res_final » à l’aide de la
commande :
paste res res_somme > res_final
- Pour visualiser on utilise la commande « cat »
cat res_final
- On efface les fichiers temporaires :
rm res_plus res res_somme

Le script complet :
#!/bin/bash

tail -n +3 resultat.txt | tr "$\t" " " | tr -s " " ":" | cut -f2,3,4 -d: | tr ":" "+" > res_plus

let i=1
let nb=`wc -l < res_plus`
while [ $i -le $nb ]
do
let s=`tail -n +$i < res_plus | head -1 `
echo "$s" >> res_somme
let i=i+1
done
tail -n +3 resultat.txt > res
paste res res_somme > res_final
cat res_final
rm res_plus res res_somme

Exercice 2 :
Ecrire un script shell qui permet de calculer le PGCD de deux entiers positifs passés en argument au script
(paramètres positionnels) en utilisant l’algorithme d’Euclide défini de la façon suivante :
29
Soit 0≤b≤a
Si b=0
pgcd(a,b) = a
Sinon
pgcd(a,b)=pgcd(b,r) où r est la division euclidienne entre a et b : a = bq + r avec 0≤r<b

Le script contient :
- Une fonction qui test que les arguments sont des entiers positifs
- Une fonction qui calcule le PGCD de manière itérative
- Une fonction qui calcule le PGCD de manière récursive.

Réponse :
#!/bin/bash
test_numerique() # cette fonction test si les deux arguments sont des entiers.
{
for nb in $* « itérer sur l’ensemble d’arguments »
do
x=expr $nb + 0` 2>err # en cas d’erreur, le message d’erreur est redirigé dans le fichier « err »
etat=$? # on sauvegarde le statut de la commande « expr » dans la variable « etat ».
if test $etat -gt 1 # Si l’argument nb n’est pas entier, alors sortir de la fonction avec le statut 2
then
return 2
fi
if test $nb -lt 0 # Si l’argument n best négative, alors sortir de la fonction avec le statut 1
then
return 1
fi
done
return 0
}

# Fonction calculant le pgcd en utilisant des boucles : pgcd itérative

pgcd_iter()
{
local x=$1
local y=$2
while test $y -ne 0 # while [ $y -ne 0 ]
do
# pgcd(x, y)=pgcd(y, x mod y)
local z=$x
x=$y
y=`expr $z % $y`
done
# Affichage du résultat
echo "Le PGCD($1,$2) est : $x"
return 0
}
30
# Fonction calculant le pgcd en utilisant la récursivité : pgcd récursif
pgcd_rec() # pgcd($1,$2)
{
# test d’arrêt
if test $2 -eq 0 # si $2 égal 0 alors pgcd est égal $1 et sort de la fonction avec un statut égal à 1
then
echo "$1"
return 0
fi
# On appliqué la récursivité: pgcd(x, y)=pgcd(y, x mod y)
# pgcd_rec ( $2 , `expr $1 % $2` )

pgcd_rec $2 `expr $1 % $2`

}

# Programme principal
# Tests de la numéricité des arguments
test_numerique $1 $2
etat=$? # on sauvegarde le statut de la fonction « test_numerique » dans la variable « etat »
case $etat in
0) # Arguments valides
nb1=$1
nb2=$2
if test $1 -le $2
then
nb1=$2
nb2=$1
fi
echo "Fonction itérative: " `pgcd_iter $nb1 $nb2`
echo "Fonction récursive: Le PGCD($1,$2) est : " `pgcd_rec $nb1 $nb2`
;;
1) # Argument negative
echo "L'un des deux paramètres $1 ou $2 est un nombre négatif"
;;
2) # Argument non valide
echo "L'un des deux paramètres $1 ou $2 n'est pas un nombre entier"
;;
esac

31