ajout des tp

Algo/tp/tp16/testtp16.c

@@ -0,0 +1,32 @@
+#include "tp16.h"
+
+void test(void)
+{
+    Tour A, B, C;
+    A.p = pilenouv();
+    strcpy(A.nom, "Tour A");
+    B.p = pilenouv();
+    strcpy(B.nom, "Tour B");
+    C.p = pilenouv();
+    strcpy(C.nom, "Tour C");
+    int n, i;
+    printf("Donner le nombre d'objets : \n");
+    scanf("%d", &n);
+    for(i = n; i >= 1; i--)
+    {
+        A.p = empiler(A.p, i);
+    }
+    afficher(A.p);
+    afficher(B.p);
+    afficher(C.p);
+    hanoi(n, &A, &B, &C);
+    afficher(A.p);
+    afficher(B.p);
+    afficher(C.p);
+}
+
+int main(void)
+{
+	test();
+	return 0;
+}

Algo/tp/tp16/tp16.c

@@ -0,0 +1,82 @@
+#include "tp16.h"
+
+Pile pilenouv(void)
+{
+    Pile p = NULL;
+    return p;
+}
+
+Pile empiler(Pile p, int x)
+{
+    Maillon *q;
+    q = (Maillon *)malloc(sizeof(Maillon));
+    if(q == NULL)
+    {
+        printf("Erreur d'allocation\n");
+        exit(1);
+    }
+    q->v = x;
+    q->suiv = p;
+    return q;
+}
+
+Pile depiler(Pile p)
+{
+    Maillon *q;
+    if(p == NULL)
+    {
+        printf("Opération Interdite !!!\n");
+        exit(1);
+    }
+    q = p;
+    p = p->suiv;
+    free(q);
+    return p;
+}
+
+int sommet(Pile p)
+{
+    if(p == NULL)
+    {
+        printf("Opération Interdite !!!\n");
+        exit(1);
+    }
+    return p->v;
+}
+
+bool vide(Pile p)
+{
+    return p == NULL;
+}
+
+void afficherX(int p)
+{
+    printf("%d ", p);
+}
+
+void afficher(Pile p)
+{
+    printf("\n");
+    while (! vide(p))
+    {
+        afficherX(sommet(p));
+        p = p->suiv;
+    }
+    printf("\n");
+}
+
+void hanoi(int n, Tour *A, Tour *B, Tour *C)
+{
+    int s;
+    if(n == 1)
+    {
+        s = sommet(A->p);
+        A->p = depiler(A->p);
+        C->p = empiler(C->p, s);
+        printf("%d passe de la %s vers la %s\n", s, A->nom, C->nom);
+        return;
+    }
+        hanoi(n - 1, A, C, B);
+        hanoi(1, A, B, C);
+        hanoi(n - 1, B, A, C);
+}

Algo/tp/tp16/tp16.h

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+
+typedef struct pile {
+    int v;
+    struct pile *suiv;
+} Maillon, *Pile;
+
+typedef struct {
+    Pile p;
+    char nom[20];
+} Tour;
+
+Pile pilenouv(void);
+Pile empiler(Pile p, int x);
+Pile depiler(Pile p);
+int sommet(Pile p);
+bool vide(Pile p);
+void afficherX(int p);
+void afficher(Pile p);
+void test(void);
+void hanoi(int n, Tour *A, Tour *B, Tour *C);

Algo/tp/tp9/testtp9.c

@@ -1,4 +1,4 @@
-#include "tp9.h"
+#include "tp9/tp9.h"
 
 void test(void)
 {

Algo/tp/tp9/tp9.c

@@ -1,4 +1,4 @@
-#include "tp9.h"
+#include "tp9/tp9.h"
 
 Mat lireMat(FILE *fe)
 {

Maths/tp/Bases2/tp3/TP3_exo2.py

@@ -0,0 +1,168 @@
+
+import numpy as np
+np.set_printoptions(suppress=True)	# (pour mieux arrondir à 0 lors des print)
+
+import math
+
+from numpy.polynomial.polynomial import polyval
+
+import matplotlib.pyplot as plt
+
+# On active le "mode interactif" de pyplot. Ainsi, les plt.show() ne sont plus nécessaires.
+plt.ion()						
+
+# --------------------------------------------------------------------------------------
+# Fonction de "fin temporaire" pendant l'avancée du TP. Attend une frappe Entrée, puis quitte le script.
+
+def stop_ici():
+	plt.pause(0.1)	# nécessaire pour que matplotlib ait le temps d'afficher les figures
+	input()
+	exit()
+
+# --------------------------------------------------------------------------------------
+# Tous les passages indiqués "TODO()" sont à remplacer par vos soins
+
+def TODO():
+	print("à vous!")
+	stop_ici()
+
+# --------------------------------------------------------------------------------------
+# Cette petite fonction sert à tracer les flèches avec une syntaxe un peu plus intuitive que le code matplotlib de base.
+# - xdepart, ydepart : coordonnées du point d'attache de la flèche
+# - xfleche, yfleche : longueurs de la flèche en x et en y
+
+def myfleche(xdepart, ydepart, xfleche, yfleche):
+	plt.annotate("", (xdepart+xfleche,ydepart+yfleche) , (xdepart,ydepart),
+		arrowprops={'color':'red','shrink': 0,'width':0.02} )
+
+
+
+#################################################################################################
+###
+### EXERCICE 2 : représenter graphiquement l'approximation affine d'une courbe paramétrée
+###
+#################################################################################################
+
+
+
+#################################################################################
+# 			 Rappel de la séance du TP2
+#################################################################################
+#
+# Une *courbe paramétrée* est un ensemble de points de la forme
+#		Point(t) = (f(t), g(t))
+# lorsque la variable t parcourt un certain intervalle donné.
+#
+# - La variable "t" s'appelle le **paramètre** de la courbe.
+# - Chaque valeur de t définit UN point, dont l'abscisse vaut f(t) et l'ordonnée vaut g(t).
+# - La courbe est obtenue en représentant les points associés à TOUTES les valeurs de t.
+#################################################################################
+
+
+
+print('''Représentez la courbe paramétrée
+	(f(t),g(t))
+associée aux fonctions polynômiales
+	f(t) = 1 -4.t + 2.t^2 + 2.t^3
+	g(t) = 2 +7.t + t^2   - t^3  - t^4
+pour le paramètre t dans l'intervalle [-2,2].''')
+
+# Discrétisation de l'intervalle [-2,2] sur 200 points :
+t = np.linspace(-2,2,200)
+# Calcul de f(t), g(t) aux points correspondants :
+ft = 1 -4*t + 2*t**2 + 2*t**3
+gt = 2 +7*t + t**2   - t**3  - t**4
+# Représentation de la courbe paramétrée :
+plt.figure()
+plt.plot(ft,gt)
+
+# ou 
+# t = np.linspace(-2,2,200) deja defini en haut
+f=[1,-4,2,2]
+g=[2,7,1,-1,-1]
+ftt=polyval(t,f)
+gtt=polyval(t,g)
+plt.figure()
+plt.plot(ftt,gtt)
+
+stop_ici()  # ---------- Supprimez cette ligne une fois que le code précédent fonctionne ------------------
+
+# --------------------------------------------------------------------------------------
+print("-"*80)
+
+
+#################################################################################
+# 			 Approximation affine pour une courbe paramétrée
+#################################################################################
+#
+# L'approximation affine de la courbe paramétrée au point t s'écrit
+#
+#	f(t+h) ~= f(t) + h.f'(t)		[en abscisses]
+#	g(t+h) ~= g(t) + h.g'(t)		[en ordonnées]
+#
+# On va représenter cette approximation affine par une FLÈCHE.
+#
+# - La flèche démarre du point "t" sur le graphe
+#		Point(t) = ( f(t) , g(t) )
+#
+# - La flèche a des longueurs (en abscisses et en ordonnées) de valeurs respectives
+#		fleche = ( h.f'(t) , h.g'(t) )
+#
+# Avec ces notations, l'approximation affine ci-dessus peut se réécrire
+#		Point(t+h) ~= Point(t) + fleche
+#
+# c'est-à-dire que "fleche" représente l'évolution (approximative) de la courbe 
+# lorsque le point d'intérêt passe du paramètre "t" à "t+h".
+#
+# Graphiquement, "fleche" est tangente à la courbe au point "t", et sa longueur
+# représente la quantité d'évolution de la courbe du point "t" au point "t+h".
+#################################################################################
+
+
+print('''(Question papier) Trouvez l'expression des fonctions dérivées f'(t) et g'(t) de la question précédente.''')
+
+stop_ici()  # ---------- Supprimez cette ligne une fois que le code précédent fonctionne ------------------
+
+# --------------------------------------------------------------------------------------
+print("-"*80)
+
+print('''Déduisez-en la valeur des 4 nombres f(1), g(1), f'(1), g'(1), et rentrez-les ci-dessous.''')
+
+f1 = TODO()
+g1 = TODO()
+fprime1 = TODO()
+gprime1 = TODO()
+
+stop_ici()  # ---------- Supprimez cette ligne une fois que le code précédent fonctionne ------------------
+
+# --------------------------------------------------------------------------------------
+print("-"*80)
+
+print('''Le code ci-dessous trace la flèche associée aux 4 valeurs que vous avez calculées à la question précédente.
+
+Déterminez graphiquement si la flèche est bien à l'endroit et dans la direction où elle devrait.
+Si la flèche n'est pas là où elle devrait, c'est que votre calcul de f(1),g(1),f'(1) ou g'(1) était faux. Dans ce cas, corrigez-le et relancez le code. ''')
+
+plt.plot(f1,g1,marker='o',color='blue')        # marque le point de paramètre "t" avec un cercle
+h = 0.5									       # écart "h" de l'approximation affine (fixe la proportionnalité gobale de la flèche)
+myfleche(f1, g1, h*fprime1, h*gprime1)         # trace la flèche
+
+stop_ici()  # ---------- Supprimez cette ligne une fois que le code précédent fonctionne ------------------
+
+# --------------------------------------------------------------------------------------
+print("-"*80)
+
+
+print('''Calculez de même les approximations affines pour la courbe aux points
+	t = -2, -1.5, -1, ...., 1.5, 2
+et représentez-les par autant de flèches.''')
+
+for t in TODO():
+	TODO() # (plusieurs lignes)
+
+print('''Vérification: toutes les flèches rouges sont-elles bien *tangentes* à la courbe ?
+Si oui, passez à la suite.
+Si non, qu'avez-vous oublié ?
+''')
+
+

systeme/tp/tp8/fonctions.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+
+doc() {
+       cat << EOF >&2
+Affiche le nombre de processus de chaque utilisateur possédant au moins
+1 processus dans le système.
+
+usage : \'basename $0\' \[ -h \]
+
+    -h : affiche cette aide.
+EOF
+#affiche (cat) tout ce qui est entre cat et EOF (End Of File == CTRL + D)
+}
+
+usage() {
+    doc
+    exit 1
+}
+
+
+# 1. Compte le nombre de processus de l'utilisateur dont le login est passé en argument.
+# 2. $1 : le login.
+# 3. stdout : le nombre de processus de l'utilisateur.
+processOneUser() {
+    # Les remarques indiquées dans la fonction processAllUsers
+    # s'appliquent également à cette fonction
+    ps h -eo user | grep $1 | wc -l
+}
+
+# 1. Affiche le tableau (non trié) du nombre de processus par utilisateur.
+# 2. Pas d'argument.
+# 3. stdout : le tableau.
+processAllUsers() {
+    # traitement
+    # ----------
+    # début
+    # L<-liste des utilisateurs possédant un processus en mémoire
+    # pour i élément de L faire
+    #       n=nombre de processus de l'utilisateur i dans le système
+    #       afficher "i n"
+    # fin pour
+    # fin
+
+    # Remarques :
+    # 1. pour obtenir la liste des propriétaire des processus, utilisez la
+    #    commande : ps h -eo user
+    # 2. Pour éliminer les doublons d'une liste filtrez la avec la commande :
+    #    sort -u.
+    local L
+    local i
+    local n
+    # ou local L i n=0
+    L=$(ps h -eo user | sort -u)
+    for i in $L; do 
+	    local n=$(processOneUser $i)
+	    echo "$i $n"
+    done
+    
+    
+}
+
+toHTML() {
+	local L R
+	echo "<html>"
+	echo "<body>"
+	echo "<table border=\"1\">"
+	while read L R;do # ou read L
+	       echo "<tr><td>$L</td><td>$R</td></tr>" 
+	       #echo $L | sed -re 's/^⁽[^ ]+) (.*)$/<tr><td>\1<\/td><td>\2<\/td><\/tr>/'
+       done
+       echo "</table>"
+       echo "</body>"
+       echo "</html>"
+}       
+
+# Début du traitement des arguments.
+while [ $# -ne 0 ]; do
+    case $1 in
+        -h|--help)
+            doc
+            exit 0
+            ;;
+        *) usage
+            ;;
+    esac
+    shift
+done
+# Fin du traitement des arguments.
+
+processAllUsers | sort -t" " -k2 -r -n | toHTML > user.html

systeme/tp/tp8/tp_8.md

@@ -1,9 +1,10 @@
-# Système utilisateur – TP n°8
+r# Système utilisateur – TP n°8
 
 Pas de compte rendu dédié aux TP sur les scripts shell. Vos programmes feront foi \!
 
 ## Variables et environnement d'exécution
 
+
  - Vérifiez si la variable  `PATH` contient  le répertoire courant. Sinon ajoutez-le. 
  - Créez et affectez une variable de "jour" (pour aujourd'hui). 
  - Créez, affectez et exportez une variable "mois". 

systeme/tp/tp8/user.html

@@ -0,0 +1,21 @@
+<html>
+<body>
+<table border="1">
+<tr><td>root</td><td>183</td></tr>
+<tr><td>anperederi</td><td>73</td></tr>
+<tr><td>www-data</td><td>5</td></tr>
+<tr><td>rwhod</td><td>2</td></tr>
+<tr><td>_chrony</td><td>2</td></tr>
+<tr><td>avahi</td><td>2</td></tr>
+<tr><td>xrdp</td><td>1</td></tr>
+<tr><td>uml-net</td><td>1</td></tr>
+<tr><td>rtkit</td><td>1</td></tr>
+<tr><td>_rpc</td><td>1</td></tr>
+<tr><td>mysql</td><td>1</td></tr>
+<tr><td>mongodb</td><td>1</td></tr>
+<tr><td>messagebus</td><td>1</td></tr>
+<tr><td>colord</td><td>1</td></tr>
+<tr><td>clamav</td><td>1</td></tr>
+</table>
+</body>
+</html>

systeme/tp/tp9/alpha.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+i=0
+
+while read L; do
+	if [ $
+	echo "$L" | egrep -q "[0-9]{2}"| tr a-z A-Z
+	shift
+	i=$(($i + 1))
+done

systeme/tp/tp9/num.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+L=""
+
+for i; do
+	if echo $i | egrep -q '^[0-9]+$' ; then
+		L="$i $L"
+	fi
+done
+
+echo $L

systeme/tp/tp9/tp_9.md

@@ -0,0 +1,74 @@
+# Petits exercices 
+
+## num
+
+Écrivez le script `num` acceptant une liste d'arguments et qui n'affiche que ceux qui sont numériques et les affiche dans l'ordre inverse.
+
+## alpha
+
+Écrivez le script `alpha` lisant son entrée standard et
+
+ - n'affichant que les lignes paires 
+ - qui en plus contiennent un nombre d'au moins deux chiffres 
+ - en les passant en majuscules (via la commande `tr a-z A-Z`) 
+ - en les faisant précéder de leur numéro (d'origine) 
+
+## Classement de photos
+
+Les vacances sont finies \! et j'ai plein de photos dans mon répertoire *images*. 
+J'aimerais que vous m'écriviez un script qui les classe automatiquement en fonction de leur date de dernière modification dansdes répertoires de noms `AAAA-MM-JJ` (année-mois-jour: exemple : 2010-10-29). 
+Le répertoire devra être créé si nécessaire avant que la photo soit déplacée à l'intérieur.
+
+Algorithme :
+
+* __debut__ 
+* __pour__ tous les **fichiers** F du répertoire passé en argument __faire__ 
+  * DIR ← date sous la forme *AAAA-MM-JJ* du fichier F 
+  * __si__ le répertoire de DIR n'existe pas __alors__ 
+    * créer le répertoire DIR 
+  * __fin si__ 
+  * déplacer F dans DIR 
+* __fin pour__ 
+* __fin__ 
+
+
+- Écrivez le script shell associé.
+
+<note>
+
+Indications :
+
+* la commande  `ls -l --time-style +%Y-%m-%d ` permet de lister les fichiers avec leur date sous la forme `AAAA-MM-DD`.  
+* Pour tester avec des photos fictives, vous pouvez utiliser la commande `touch -m -t 200910130000 img-0001.jpg`. Cette commande crée un fichier vide dont la date de dernière modification est fixée au jour du 13 octobre(10) 2009. 
+
+</note>
+
+## Un petit jeu d'adresse
+
+Ce petit jeu d'adresse consiste à présenter à l'utilisateur, pendant un
+temps limité (1.5 secondes), une fenêtre `xeyes` placée aléatoirement à
+l'écran. Si l'utilisateur réussi à "tuer" la fenêtre en la fermant à
+l'aide de la croix avant le temps imparti il gagne 1 point. Sinon c'est
+le programme qui "tue" la fenêtre avant de présenter la suivante. Une
+partie se joue en 10 coups.
+
+Écrivez le script shell associé à ce jeu.
+
+<note>
+
+Indications :
+
+* Une fenêtre peut généralement être placée à une position donnée de l'écran via l'option -geometry. Par exemple la commande  `xeyes -geometry +500+300` lancera  `xeyes` qui placera sa fenêtre à la position (500,300). Remarque : certains gestionnaires de fenêtres, comme `Gnome 3` ou `i3` par exemple, ne tiennent pas toujours compte du placement demandé ! 
+* La commande `sleep` est l'une des rares commandes standard acceptant en argument un nombre flottant exprimant le temps en seconde. Ainsi sleep 0.2 fera dormir le processus 200 millisecondes. 
+* La commande `shuf -i 0-100 -n 1` permet d'obtenir un entier aléatoire dans l'intervalle [0-100]. 
+
+</note>
+
+- Modifiez votre programme pour qu'il réponde au synopsis suivant :
+
+ `prog [-n num] [-t delai]`
+
+où
+
+ *  `num` est le nombre de coups de la partie (10 par défaut). 
+ *  `delai` est le temps imparti pour tuer la fenêtre.