From 7ad2b0ee7c702f635b3dda5a857a1c0104427557 Mon Sep 17 00:00:00 2001 From: John Charron Date: Wed, 1 Dec 2010 02:00:54 +0100 Subject: [PATCH] =?UTF-8?q?Dossier=20de=20programme=20renomm=C3=A9=20et=20?= =?UTF-8?q?plus=20complet=20(C=20et=20LISP)=20(jc)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- exo4-programmes/couples | Bin 0 -> 12119 bytes exo4-programmes/couples-2.lisp | 106 ++++++ exo4-programmes/couples-3.lisp | 108 ++++++ exo4-programmes/couples-entiers-2.lisp | 189 +++++++++++ exo4-programmes/couples-entiers.lisp | 151 +++++++++ exo4-programmes/couples-old.c | 264 +++++++++++++++ exo4-programmes/couples.c | 445 +++++++++++++++++++++++++ exo4-programmes/couples.lisp | 134 ++++++++ exo4-programmes/couples_entiers.c | 150 +++++++++ 9 files changed, 1547 insertions(+) create mode 100755 exo4-programmes/couples create mode 100644 exo4-programmes/couples-2.lisp create mode 100644 exo4-programmes/couples-3.lisp create mode 100644 exo4-programmes/couples-entiers-2.lisp create mode 100644 exo4-programmes/couples-entiers.lisp create mode 100644 exo4-programmes/couples-old.c create mode 100644 exo4-programmes/couples.c create mode 100644 exo4-programmes/couples.lisp create mode 100644 exo4-programmes/couples_entiers.c diff --git a/exo4-programmes/couples b/exo4-programmes/couples new file mode 100755 index 0000000000000000000000000000000000000000..2a6c3d958e6a15309070f7dfd8dee9120884eb4a GIT binary patch literal 12119 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 Fe*o_@Y}Eh& literal 0 HcmV?d00001 diff --git a/exo4-programmes/couples-2.lisp b/exo4-programmes/couples-2.lisp new file mode 100644 index 0000000..af78fd6 --- /dev/null +++ b/exo4-programmes/couples-2.lisp @@ -0,0 +1,106 @@ +(defun gauss-formula (n) + (/ (* n (+ n 1)) 2)) + +(defun get-n (code) + (isqrt (* code 2))) + +(defun get-axis (code) + (gauss-formula (isqrt (* code 2)))) + +(defun get-axis-from-n (n) + (gauss-formula n)) + +(defun axis-code-compare (code) + (format t "~d ~d~%" code (get-axis code))) + +(defun axis-code-compare-n (startcode n) + (let ((i 0)) + (loop + (when (> i n) (return)) + (axis-code-compare (+ startcode i)) + (incf i)))) + +(defun ord-pr-to-code (x y) + (let ((sumxy (+ x y))) + (if (evenp sumxy) + (+ (gauss-formula sumxy) x) + (+ (gauss-formula sumxy) y)))) + +(defun code-to-ord-pr (code) + (let ((n (get-n code)) + (axis (get-axis code)) + (diff 0)) + (progn + (when (> (get-axis code) code) + (progn + (setf n (- n 1)) + (setf axis (get-axis-from-n n)))) + (setf diff (- code axis)) + (if (evenp n) + (cons diff (cons (- n diff) ())) + (cons (- n diff) (cons diff ())))))) + +(defun ord-mult-to-code (L) + (if (= (list-length L) 1) + (car L) + (ord-mult-to-code (append (butlast (butlast L)) + (cons (ord-pr-to-code (car (last (butlast L))) (car (last L))) ()))))) + +(defun code-to-ord-mult (L-or-code size) + (if (atom L-or-code) + (code-to-ord-mult (code-to-ord-pr L-or-code) (- size 1)) + (if (not (= size 1)) + (code-to-ord-mult (append (butlast L-or-code) (code-to-ord-pr (car (last L-or-code)))) + (- size 1)) + L-or-code))) + +#| Les codes générés par cette fonction ne correspondent pas au code généré par le +diagramme du rapport ni des fonctions ord-mult-to-code et code-to-ord-mult. +Toutefois, la fonction ci-dessous a été créées ici car son écriture et beaucoup plus idiomatique +en LISP (d'où le nom 'ord-mult-to-code-lisp'). En effet, si on avait à coder les nombres naturels en LISP, on ajouterait +(resp. supprimerait) des éléments de la liste en partant du début de la liste afin de créer +une paire ou un n-uplet (resp. pour trouver le code correspondant à une paire ou un n-uplet +|# +(defun ord-mult-to-code-lisp (L) + (if (= (list-length L) 1) + (car L) + (ord-mult-to-code-lisp (cons (ord-pr-to-code (first L) (second L)) (cddr L))))) + +#| voir le commentaire précédent concernant la fonction ord-mult-to-code-lisp |# +(defun code-to-ord-mult-lisp (L-or-code size) + (if (atom L-or-code) + (code-to-ord-mult-lisp (code-to-ord-pr L-or-code) (- size 1)) + (if (not (= size 1)) + (code-to-ord-mult-lisp (append (code-to-ord-pr (car L-or-code)) (cdr L-or-code)) (- size 1)) + L-or-code))) + +#| +(defun code-to-ord-pr (code) + (;let* ((code*2 (* code 2)) + (n (isqrt code*2)) + (axis (gauss-formula n)) + (diff 0)) + (cond + ((> axis code) + (loop while (> axis code) + ((setf n (- n 1)) + (setf axis (gauss-formula n)))) + (< axis code) + ((loop while (< axis code) + ((setf n (- n 1)) + (setf axis (gauss-formula n)))) + (when (> axis code) + ((setf n (- n 1)) + (setf axis (gauss-formula n)))))) + (t 5)))) + |# + + +(defun loop-test (n) + (let ((n 0)) + (loop + (when (> n 10) (return)) + (format t "~d ~d ~d~%" n (isqrt n) (gauss-formula n)) + ;(print n) (write (* n n)) (write n) + (incf n)))) + diff --git a/exo4-programmes/couples-3.lisp b/exo4-programmes/couples-3.lisp new file mode 100644 index 0000000..272f4f3 --- /dev/null +++ b/exo4-programmes/couples-3.lisp @@ -0,0 +1,108 @@ +(defun gauss-formula (n) + (/ (* n (+ n 1)) 2)) + +(defun get-n (code) + (isqrt (* code 2))) + +(defun get-axis (code) + (gauss-formula (isqrt (* code 2)))) + +(defun get-axis-from-n (n) + (gauss-formula n)) + +(defun axis-code-compare (code) + (format t "~d ~d~%" code (get-axis code))) + +(defun axis-code-compare-n (startcode n) + (let ((i 0)) + (loop + (when (> i n) (return)) + (axis-code-compare (+ startcode i)) + (incf i)))) + +(defun ord-pr-to-code-nat (x y) + (let ((sumxy (+ x y))) + (if (evenp sumxy) + (+ (gauss-formula sumxy) x) + (+ (gauss-formula sumxy) y)))) + +(defun code-to-ord-pr-nat (code) + (let ((n (get-n code)) + (axis (get-axis code)) + (diff 0)) + (progn + (when (> (get-axis code) code) + (progn + (setf n (- n 1)) + (setf axis (get-axis-from-n n)))) + (setf diff (- code axis)) + (if (evenp n) + (cons diff (cons (- n diff) ())) + (cons (- n diff) (cons diff ())))))) + +(defun nat-to-int (nat) + (if (< nat 0) + (- (* 2 (abs nat)) 1) + (* 2 (abs nat)))) + +(defun int-to-nat (int) + (if (evenp int) + (/ int 2) + (ceiling (- (- (/ int 2)) 1)))) + + +(defun ord-pr-to-code-int (x y) + (setf x (nat-to-int x)) + (setf y (nat-to-int y)) + (ord-pr-to-code-nat x y)) + +(defun code-to-ord-pr-int (code) + (let ((L (code-to-ord-pr-nat code))) + (progn + (setf L (cons (int-to-nat (first L)) (cdr L))) + (setf L (cons (car L) (cons (int-to-nat (second L)) ()))) + L))) + +(defun ord-mult-to-code-nat (L) + (if (= (list-length L) 1) + (car L) + (ord-mult-to-code-nat (append (butlast (butlast L)) + (cons (ord-pr-to-code-nat (car (last (butlast L))) (car (last L))) ()))))) + +(defun code-to-ord-mult-nat (L-or-code size) + (if (atom L-or-code) + (code-to-ord-mult-nat (code-to-ord-pr L-or-code) (- size 1)) + (if (not (= size 1)) + (code-to-ord-mult-nat (append (butlast L-or-code) (code-to-ord-pr (car (last L-or-code)))) + (- size 1)) + L-or-code))) + +#| Les codes générés par cette fonction ne correspondent pas au code généré par le +diagramme du rapport ni des fonctions ord-mult-to-code et code-to-ord-mult. +Toutefois, la fonction ci-dessous a été créées ici car son écriture et beaucoup plus idiomatique +en LISP (d'où le nom 'ord-mult-to-code-lisp'). En effet, si on avait à coder les nombres naturels en LISP, on ajouterait +(resp. supprimerait) des éléments de la liste en partant du début de la liste afin de créer +une paire ou un n-uplet (resp. pour trouver le code correspondant à une paire ou un n-uplet. +On aurait pu faire pareil pour les fonctions concernant tous les entiers +|# +(defun ord-mult-to-code-nat-lisp (L) + (if (= (list-length L) 1) + (car L) + (ord-mult-to-code-lisp (cons (ord-pr-to-code (first L) (second L)) (cddr L))))) + +#| voir le commentaire précédent concernant la fonction ord-mult-to-code-lisp |# +(defun code-to-ord-mult-nat-lisp (L-or-code size) + (if (atom L-or-code) + (code-to-ord-mult-lisp (code-to-ord-pr L-or-code) (- size 1)) + (if (not (= size 1)) + (code-to-ord-mult-lisp (append (code-to-ord-pr (car L-or-code)) (cdr L-or-code)) (- size 1)) + L-or-code))) + +(defun loop-test (n) + (let ((n 0)) + (loop + (when (> n 10) (return)) + (format t "~d ~d ~d~%" n (isqrt n) (gauss-formula n)) + ;(print n) (write (* n n)) (write n) + (incf n)))) + diff --git a/exo4-programmes/couples-entiers-2.lisp b/exo4-programmes/couples-entiers-2.lisp new file mode 100644 index 0000000..4c85f97 --- /dev/null +++ b/exo4-programmes/couples-entiers-2.lisp @@ -0,0 +1,189 @@ +#| +Auteur : John CHARRON +email : charron.john@gmail.com +|# + +;; définition des variables globales (toujours entre astérisques) +(defvar *current* (list 0 0 0)) ;; liste courante (clé x y) +(setf *current* (list 0 0 0)) +(defvar *db* nil) ;; base de données qui stocke tous les "(clé x y)" +(setf *db* nil) +(push *current* *db*) + +(defvar *max-x* 0) ;; valeur maximale de x jusque atteinte +(setf *max-x* 0) +(defvar *max-y* 0) ;; valeur maximale de y jusque atteinte +(setf *max-y* 0) +(defvar *min-x* 0) ;; valeur minimale de x atteinte +(setf *min-x* 0) +(defvar *min-y* 0) ;; valeur minimale de y atteinte +(setf *min-y* 0) + +#| pour remettre toutes les variables globales à leur valeurs par défaut +afin de tester, de refaire un 'zig-zag', etc. +|# +(defun reset () + (progn + (defvar *current* (list 0 0 0)) ;; liste courante (clé x y) + (setf *current* (list 0 0 0)) + (defvar *db* nil) ;; base de données qui stocke tous les "(clé x y)" + (setf *db* nil) + (push *current* *db*) + (defvar *max-x* 0) ;; valeur maximal de x jusque "là" + (setf *max-x* 0) + (defvar *max-y* 0) ;; valeur maximal de y jusque "là" + (setf *max-y* 0) + (defvar *min-x* 0) ;; valeur minimale de x atteinte + (setf *min-x* 0) + (defvar *min-y* 0) ;; valeur minimale de y atteinte + (setf *min-y* 0) + *current*)) + +#| Les fonctions "right" "down", "down", "up" imitent le movement des +coordonnées sur un graphe mais au les coordonnées "y" positifs sont en DESSOUS du graphe +|# + +(defun right (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (+ 1 (second L)) (last L)))) *db*) + *current*)) + +(defun left (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (- (second L) 1) (last L)))) *db*) + *current*)) + +(defun up (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (second L) (cons (+ (third L) 1) ())))) *db*) + *current*)) + +(defun down (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (second L) (cons (- (third L) 1) ())))) *db*) + *current*)) + +(defun loop-right (L) + (loop + (when (= (second L) (+ (- *min-x*) 1)) (*current*)) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (+ 1 (second L)) (last L)))) *db*) + (update-all L)))) + +(defun loop-left (L) + (loop + (when (= (second L) (- *max-x*)) (return)) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (- (second L) 1) (last L)))) *db*) + (update-all L) + *current*))) + +(defun loop-up (L) + (loop + (when (= (third L) (+ (- *min-y*) 1)) (return)) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (second L) (cons (+ (third L) 1) ())))) *db*) + (update-all L) + *current*))) + +(defun loop-down (L) + (loop + (when (= (third L) (- *max-y*)) (return)) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (second L) (cons (- (third L) 1) ())))) *db*) + (update-all L) + *current*))) + + + + +(defun update-max-x (L) + (if (> (second L) *max-x*) + (setf *max-x* (second L)) + nil)) + +(defun update-max-y (L) + (if (> (third L) *max-y*) + (setf *max-y* (third L)) + nil)) + +(defun update-min-x (L) + (if (< (second L) *min-x*) + (setf *min-x* (second L)) + nil)) + +(defun update-min-y (L) + (if (> (third L) *max-y*) + (setf *min-y* (third L)) + nil)) + +(defun print-all () + (print "*current*") + (print *current*) + (print "*max-x*: ~S") + (print *max-x*)) + +(defun update-all (L) + (cond + ((> (second L) *max-x*) + (setf *max-x* (second L))) + ((> (third L) *max-y*) + (setf *max-y* (third L))) + ((< (second L) *min-x*) + (setf *min-x* (second L))) + ((< (third L) *min-y*) + (setf *min-y* (third L))) + (t ()))) + +;; "move" s'occupe de choisir "right", "down-left" etc. selon les valeurs dans *current* +(defun move (L) + (cond + ((and (= (* (isqrt (first L)) (+ (isqrt (first L)) 1)) (first L)) (evenp (isqrt (first L)))) + (print "in RIGHT") + (loop-right L)) + ((and (integerp (sqrt (first L))) (oddp (first L))) + (print "in UP") + (loop-up L)) + ((and (= (* (isqrt (first L)) (+ (isqrt (first L)) 1)) (first L)) (oddp (isqrt (first L)))) + (print "in LEFT") + (loop-left L)) + ((and (integerp (sqrt (first L))) (evenp (first L))) + (print "in DOWN") + (loop-down L)) + (t *current*) + )) + + +#| +On fait un "move" et puis un "update-max-x-y" +Attention : il faut bien faire un setf L, sinon, le paramètre L de "update-max-x-y utilise la valeur +de L inchangé ! +|# +(defun move-and-update (L) + (progn + (setf L (move L)) + *db*)) + +;; "zig-zag" fait n "move-and-update" en un seul coup et affiche le contenu de *db* (toutes les couples) +(defun zig-zag (L n) + (if (zerop n) + (move-and-update *current*) + (progn + (move-and-update *current*) + (zig-zag L (- n 1))))) diff --git a/exo4-programmes/couples-entiers.lisp b/exo4-programmes/couples-entiers.lisp new file mode 100644 index 0000000..68b680d --- /dev/null +++ b/exo4-programmes/couples-entiers.lisp @@ -0,0 +1,151 @@ +#| +Auteur : John CHARRON +email : charron.john@gmail.com +|# + +;; définition des variables globales (toujours entre astérisques) +(defvar *current* (list 0 0 0)) ;; liste courante (clé x y) +(setf *current* (list 0 0 0)) +(defvar *db* nil) ;; base de données qui stocke tous les "(clé x y)" +(setf *db* nil) +(push *current* *db*) + +(defvar *max-x* 0) ;; valeur maximale de x jusque atteinte +(setf *max-x* 0) +(defvar *max-y* 0) ;; valeur maximale de y jusque atteinte +(setf *max-y* 0) +(defvar *min-x* 0) ;; valeur minimale de x atteinte +(setf *min-x* 0) +(defvar *min-y* 0) ;; valeur minimale de y atteinte +(setf *min-y* 0) + +#| pour remettre toutes les variables globales à leur valeurs par défaut +afin de tester, de refaire un 'zig-zag', etc. +|# +(defun reset () + (progn + (defvar *current* (list 0 0 0)) ;; liste courante (clé x y) + (setf *current* (list 0 0 0)) + (defvar *db* nil) ;; base de données qui stocke tous les "(clé x y)" + (setf *db* nil) + (push *current* *db*) + (defvar *max-x* 0) ;; valeur maximal de x jusque "là" + (setf *max-x* 0) + (defvar *max-y* 0) ;; valeur maximal de y jusque "là" + (setf *max-y* 0) + (defvar *min-x* 0) ;; valeur minimale de x atteinte + (setf *min-x* 0) + (defvar *min-y* 0) ;; valeur minimale de y atteinte + (setf *min-y* 0) + *current*)) + +#| Les fonctions "right" "down", "down", "up" imitent le movement des +coordonnées sur un graphe mais au les coordonnées "y" positifs sont en DESSOUS du graphe +|# + +(defun right (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (+ 1 (second L)) (last L)))) *db*) + *current*)) + +(defun left (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (- (second L) 1) (last L)))) *db*) + *current*)) + +(defun up (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (second L) (cons (+ (third L) 1) ())))) *db*) + *current*)) + +(defun down (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (second L) (cons (- (third L) 1) ())))) *db*) + *current*)) + +(defun update-max-x (L) + (if (> (second L) *max-x*) + (setf *max-x* (second L)) + nil)) + +(defun update-max-y (L) + (if (> (third L) *max-y*) + (setf *max-y* (third L)) + nil)) + +(defun update-min-x (L) + (if (< (second L) *min-x*) + (setf *min-x* (second L)) + nil)) + +(defun update-min-y (L) + (if (> (third L) *max-y*) + (setf *min-y* (third L)) + nil)) + +(defun print-all () + (print "*current*") + (print *current*) + (print "*max-x*: ~S") + (print *max-x*)) + +(defun update-all (L) + (cond + ((> (second L) *max-x*) + (setf *max-x* (second L))) + ((> (third L) *max-y*) + (setf *max-y* (third L))) + ((< (second L) *min-x*) + (setf *min-x* (second L))) + ((< (third L) *min-y*) + (setf *min-y* (third L))) + (t ()))) + +;; "move" s'occupe de choisir "right", "down-left" etc. selon les valeurs dans *current* +(defun move (L) + (cond + ((and (zerop (second L)) (zerop (third L))) ; if x== 0 && y==0 then go right TO BEGIN + (print "in RIGHT") + (right L)) + ((and (= *min-y* (- *max-y*)) (< (second L) (+ (- *min-x*) 1))) + (print "in RIGHT") + (right L)) + ((and (= *max-x* (+ (- *min-x*) 1)) (< (third L) (+ (- *min-y*) 1))) + (print "in UP") + (up L)) + ((and (= *max-y* (+ (- *min-y*) 1)) (> (second L) (- *max-x*))) + (print "in LEFT") + (left L)) + ((and (= *min-x* (- *max-x*)) (> (third L) (- *max-y*))) + (print "in DOWN") + (down L)) + (t *current*) + )) + + +#| +On fait un "move" et puis un "update-max-x-y" +Attention : il faut bien faire un setf L, sinon, le paramètre L de "update-max-x-y utilise la valeur +de L inchangé ! +|# +(defun move-and-update (L) + (progn + (setf L (move L)) + (update-all L) + *db*)) + +;; "zig-zag" fait n "move-and-update" en un seul coup et affiche le contenu de *db* (toutes les couples) +(defun zig-zag (L n) + (if (zerop n) + (move-and-update *current*) + (progn + (move-and-update *current*) + (zig-zag L (- n 1))))) diff --git a/exo4-programmes/couples-old.c b/exo4-programmes/couples-old.c new file mode 100644 index 0000000..b06ebf5 --- /dev/null +++ b/exo4-programmes/couples-old.c @@ -0,0 +1,264 @@ +#include +#include +#include + +int pair(int x){ + return (!(x % 2)); +} + +/* +int code_couples_very_slow(int _x, int _y){ + int x, y; + x = y = 0; + int code = 0; + char direction = 'r'; // 'l' pour "left-down", 'r' pour "right-up" + printf("In the 'couples' function\n"); + sleep(1); + while(((x != _x) || (y != _y))){ + if((y == 0) && (pair(x))){ + printf("IF1:\n"); + sleep(1); + x++; + code++; + direction = 'l'; + printf("IF N° 1, x = %d, y = %d, code = %d\n", x, y, code); + sleep(1); + } + else if((x == 0) && (!pair(y))){ + printf("IF2:\n"); + sleep(1); + y++; + code++; + direction = 'r'; + printf("IF N° 2, x = %d, y = %d, code = %d\n", x, y, code); + sleep(1); + } + else if((y == 0) && (direction == 'l')){ + printf("IF3:\n"); + sleep(1); + while((x != 0) && ((x != _x) || (y != _y))){ + printf("WHILE3:\n"); + sleep(1); + x--; + y++; + code++; + printf("IF N° 3, x = %d, y = %d, code = %d\n", x, y, code); + sleep(1); + } + } + else if((x == 0) && (direction == 'r')){ + printf("IF4:\n"); + sleep(1); + while((y != 0) && ((x != _x) || (y != _y))){ + printf("WHILE4:\n"); + sleep(1); + x++; + y--; + code++; + printf("IF N° 4, x = %d, y = %d, code = %d\n", x, y, code); + sleep(1); + } + } + } + return code; +} + +int code_couples_slow(int _x, int _y){ + int x, y; + x = y = 0; + int code = 0; + char direction = 'r'; // 'l' pour "left-down", 'r' pour "right-up" + while(((x != _x) || (y != _y))){ + if((y == 0) && (pair(x))){ + x++; + code++; + direction = 'l'; + } + else if((x == 0) && (!pair(y))){ + y++; + code++; + direction = 'r'; + } + else if((y == 0) && (direction == 'l')){ + while((x != 0) && ((x != _x) || (y != _y))){ + x--; + y++; + code++; + } + } + else if((x == 0) && (direction == 'r')){ + while((y != 0) && ((x != _x) || (y != _y))){ + x++; + y--; + code++; + } + } + } + return code; +} +*/ + +int orderedPairToCode(int x, int y){ + int sumxy, code; + sumxy = x + y; + code = ((sumxy)*(sumxy + 1))/2; + + if(pair(sumxy)){ + code = code + x; + } + else{ + code = code + y; + } + return code; +} + + +int* codeToOrderedPair(int code){ + int *couple = malloc(2*sizeof(int)); + int n = sqrt(code * 2); + int axis = (n * (n + 1))/2; + int diff = 0; + if(axis > code){ + while(axis > code){ + n = n - 1; + axis = (n * (n + 1))/2; + } + } + else if(axis < code){ + while(axis < code){ + n = n + 1; + axis = (n * (n + 1))/2; + } + if(axis > code){ + n = n - 1; + axis = (n * (n + 1))/2; + } + } + + if(axis == code){ // je pense que je peux me dispenser de cet "if", ça revient au même car diff serait = 0 + if(pair(n)){ + couple[0] = 0; + couple[1] = n; + } + else{ + couple[0] = n; + couple[1] = 0; + } + } + if(axis != code){ // idem + diff = code - axis; + if(pair(n)){ + couple[0] = diff; + couple[1] = n - diff; + } + else{ + couple[0] = n - diff; + couple[1] = diff; + } + } + return couple; +} + +int* codeToOrderedPair2(int code){ + int *couple = malloc(2*sizeof(int)); + int n = sqrt(code * 2); + int axis = (n * (n + 1))/2; + int diff = 0; + if(axis > code){ + n = n - 1; + axis = (n * (n + 1))/2; + } + diff = code - axis; + if(pair(n)){ + couple[0] = diff; + couple[1] = n - diff; + } + else{ + couple[0] = n - diff; + couple[1] = diff; + } + return couple; +} + + +int orderedMultipleToCode(int *arr, int size){ + int code; + if(size > 1){ + code = orderedPairToCode(arr[size - 2], arr[size - 1]); + arr[size - 2] = code; + arr = realloc(arr, (size - 1)); + if(size > 2){ + code = orderedMultipleToCode(&arr[0], (size - 1)); + } + } + return code; +} + +int* codeToOrderedMultiple(int code, int size){ + int *multiple = malloc(size*sizeof(int)); + int *pair; + int i = 0; + for(i = 0; i < (size - 1); i++){ + pair = codeToOrderedPair(code); + code = pair[1]; + multiple[i] = pair[0]; + multiple[i + 1] = pair[1]; + } + return multiple; +} + + +int main(int argc, char **argv, char **envp){ + + int x = 0; + int y = 0; + int code = 0; + int *p; + int size = 0; + + do{ + /* + printf ("\nx = "); + scanf("%d",&x); + printf ("y = "); + scanf("%d",&y); + code = orderedPairToCode(x, y); + printf("Le code du couple (%d, %d) est %d\n", x, y, code); + + printf ("\ncode = "); + scanf("%d",&code); + p = codeToOrderedPair(code); + printf("The ordered pair identified by code %d is (%d, %d)", code, p[0], p[1]); + +*/ + printf("\nEnter a size of a multidimensional array representing a 'ordered multiple': "); + scanf("%d",&size); + p = malloc(size * sizeof(int)); + int i; + for(i = 0; i < size; i++){ + printf("Enter value number %d: ", i); + scanf("%d", &p[i]); + } + + code = orderedMultipleToCode(p, size); + printf("\n... The code is %d", code); + + + + printf ("\ncode = "); + scanf("%d",&code); + printf ("\nnumber of ordered elements = "); + scanf("%d",&size); + p = codeToOrderedMultiple(code, size); + printf("The ordered multiple identified by code %d contains the following elements: ", code); + printf("("); + for(i = 0; i < (size - 1); i++){ + printf("%d, ", p[i]); + } + printf("%d)", p[size-1]); + + + } + while(code != -1); +} + diff --git a/exo4-programmes/couples.c b/exo4-programmes/couples.c new file mode 100644 index 0000000..ffa1708 --- /dev/null +++ b/exo4-programmes/couples.c @@ -0,0 +1,445 @@ +#include +#include +#include + +int even(int x){ + return (!(x % 2)); +} + +int max(int a, int b){ + if(a > b) + return a; + return b; +} + +long int orderedPairToCodeNat(int x, int y){ + long code; + int sumxy; + sumxy = x + y; + code = ((sumxy)*(sumxy + 1))/2; + + if(even(sumxy)){ + code = code + x; + } + else{ + code = code + y; + } + return code; +} + +int* codeToOrderedPairNat(long int code){ + int *couple = malloc(2*sizeof(int)); + int n = sqrt(code * 2); + long int axis = (n * (n + 1))/2; + int diff = 0; + if(axis > code){ + n = n - 1; + axis = (n * (n + 1))/2; + } + diff = code - axis; + if(even(n)){ + couple[0] = diff; + couple[1] = n - diff; + } + else{ + couple[0] = n - diff; + couple[1] = diff; + } + return couple; +} + +long int orderedPairToCodeInt(int x, int y){ + long int code = 0; + + if (x < 0){ + x = (2 * (abs (x))) - 1; + } + else{ + x = 2 * x; + } + + if (y < 0){ + y = (2 * (abs(y))) - 1; + } + else{ + y = 2 * y; + } + + code = orderedPairToCodeNat(x, y); + return code; +} + +int* codeToOrderedPairInt(long int code){ + int *pair = codeToOrderedPairNat(code); + + if (even(pair[0])){ + pair[0] = pair[0] / 2; + } + else{ + pair[0] = (pair[0] / 2)*(-1) - 1; + } + + if (even (pair[1])){ + pair[1] = pair[1] / 2; + } + else{ + pair[1] = (pair[1] / 2)*(-1) - 1; + } + + return pair; +} + +long int orderedPairToCodeIntAlgo2(int x, int y){ + long int code = 0; + int _x, _y, diff; + _x = _y = diff = 0; + int temp; + int absmax; + absmax = max(abs(x), abs(y)); + + if(absmax == abs(x)){ // _x == x + _x = _y = x; + temp = abs(x) * 2; + if(x < 0){ // x negative + code = temp * (temp + 1); + if(y < 0){ // x negative, y negative + diff = abs(_y) - abs(y); + } + else{ // x negative, y positive + diff = abs(_y) + abs(y); + } + } + else{ // x positive + code = (temp - 1) * temp; + if(y > 0){ // x positive, y positive + diff = abs(_y) - abs(y); + } + else{ // x positive, y negative + diff = abs(_y) + abs(y); + } + } + code = code - diff; + } + else{ // _y = y + _x = _y = y; + temp = abs(y) * 2; + if(y < 0){ // y negative + code = temp * (temp + 1); + if(x < 0){ // y negative, x negative + diff = abs(_x) - abs(x); + } + else{ // y negative, x positive + diff = abs(_x) + abs (x); + } + } + else{ // y positive + code = (temp - 1) * temp; + if(x > 0){ // y positive, x positive + diff = abs(_x) - abs(x); + } + else{ // y positive, x negative + diff = abs(_x) + abs(x); + } + } + code = code + diff; + } + return code; +} + +int* codeToOrderedPairIntAlgo2(long int code){ + int* pair = malloc(2*sizeof(int)); + int isqrtcode = (int) sqrt(code); + long int pivotcode = isqrtcode * (isqrtcode + 1); + int x, y; + x = y = 0; + + if(even(isqrtcode)){ + x = y = -(isqrtcode / 2); + if(code > pivotcode){ + x = x + (code - pivotcode); + } + else{ + y = y + (pivotcode - code); + } + } + else{ + x = y = (isqrtcode / 2) + 1; + if(code > pivotcode){ + x = x - (code - pivotcode); + } + else{ + y = y - (pivotcode - code); + } + } + pair[0] = x; + pair[1] = y; + return pair; +} + +long int orderedMultipleToCodeNat(int *arr, int size){ + long int code; + if(size > 1){ + code = orderedPairToCodeNat(arr[size - 2], arr[size - 1]); + arr[size - 2] = code; + arr = realloc(arr, (size - 1)); + if(size > 2){ + code = orderedMultipleToCodeNat(&arr[0], (size - 1)); + } + } + return code; +} + +int* codeToOrderedMultipleNat(long int code, int size){ + int *multiple = malloc(size*sizeof(int)); + int *pair; + int i = 0; + for(i = 0; i < (size - 1); i++){ + pair = codeToOrderedPairNat(code); + code = pair[1]; + multiple[i] = pair[0]; + multiple[i + 1] = pair[1]; + } + return multiple; +} + + +long int orderedMultipleToCodeInt(int *arr, int size){ + long int code; + if(size > 1){ + code = orderedPairToCodeInt(arr[size - 2], arr[size - 1]); + arr[size - 2] = code; + arr = realloc(arr, (size - 1)); + if(size > 2){ + code = orderedMultipleToCodeInt(&arr[0], (size - 1)); + } + } + return code; +} + +int* codeToOrderedMultipleInt(long int code, int size){ + int *multiple = malloc(size*sizeof(int)); + int *pair; + int i = 0; + for(i = 0; i < (size - 1); i++){ + pair = codeToOrderedPairInt(code); + code = pair[1]; + multiple[i] = pair[0]; + multiple[i + 1] = pair[1]; + } + return multiple; +} + + +long int orderedMultipleToCodeIntAlgo2(int *arr, int size){ + long int code = 0; + if(size > 1){ + code = orderedPairToCodeIntAlgo2(arr[size - 2], arr[size - 1]); + arr[size - 2] = code; + arr = realloc(arr, (size - 1)); + if(size > 2){ + code = orderedMultipleToCodeIntAlgo2(&arr[0], (size - 1)); + } + } + return code; +} + +int* codeToOrderedMultipleIntAlgo2(long int code, int size){ + int *multiple = malloc(size*sizeof(int)); + int *pair; + int i = 0; + for(i = 0; i < (size - 1); i++){ + pair = codeToOrderedPairIntAlgo2(code); + code = pair[1]; + multiple[i] = pair[0]; + multiple[i + 1] = pair[1]; + } + return multiple; +} + + + + +void testMultiNat(){ + + int x = 0; + int y = 0; + long int code = 0; + int *p; + int size = 0; + + do{ + printf("\n(NATURAL NUMBERS) testPairInt();Enter a size of a multidimensional array representing a 'ordered multiple': "); + scanf("%d",&size); + p = malloc(size * sizeof(int)); + int i; + for(i = 0; i < size; i++){ + printf("Enter value number %d: ", i); + scanf("%d", &p[i]); + } + + code = orderedMultipleToCodeNat(p, size); + printf("\n... The code is %ld", code); + printf ("\ncode = "); + scanf("%ld",&code); + printf ("\nnumber of ordered elements = "); + scanf("%d",&size); + p = codeToOrderedMultipleNat(code, size); + printf("The ordered multiple identified by code %ld contains the following elements: ", code); + printf("("); + + for(i = 0; i < (size - 1); i++){ + printf("%d, ", p[i]); + } + printf("%d)", p[size-1]); + } + while(1); +} + +void testPairInt(){ + + int x = 0; + int y = 0; + long int code = 0; + int *p; + + do{ + p = malloc(2 * sizeof(int)); + int i; + for(i = 0; i < 2; i++){ + printf("(ORDERED PAIRS INT) Enter value number %d: ", i); + scanf("%d", &p[i]); + } + + code = orderedPairToCodeInt(p[0], p[1]); + printf("\n... The code is %ld", code); + printf ("\ncode = "); + scanf("%ld",&code); + p = codeToOrderedPairInt(code); + printf("The ordered pair identified by code %ld contains the following elements: ", code); + printf("("); + + for(i = 0; i < 1; i++){ + printf("%d, ", p[i]); + } + printf("%d)\n", p[1]); + } + while(1); +} + +void testMultiInt(){ + + int x = 0; + int y = 0; + long int code = 0; + int *p; + int size = 0; + + do{ + printf("\n(INTEGERS) Enter a size of a multidimensional array representing a 'ordered multiple': "); + scanf("%d",&size); + p = malloc(size * sizeof(int)); + int i; + for(i = 0; i < size; i++){ + printf("Enter value number %d: ", i); + scanf("%d", &p[i]); + } + + code = orderedMultipleToCodeInt(p, size); + printf("\n... The code is %ld", code); + printf ("\ncode = "); + scanf("%ld",&code); + printf ("\nnumber of ordered elements = "); + scanf("%d",&size); + p = codeToOrderedMultipleInt(code, size); + printf("The ordered multiple identified by code %ld contains the following elements: ", code); + printf("("); + + for(i = 0; i < (size - 1); i++){ + printf("%d, ", p[i]); + } + printf("%d)", p[size-1]); + } + while(1); +} + +void testPairIntAlgo2(){ + + int x = 0; + int y = 0; + long int code = 0; + int *p; + + do{ + p = malloc(2 * sizeof(int)); + int i; + + for(i = 0; i < 2; i++){ + printf("(ORDERED PAIRS INT) Enter value number %d: ", i); + scanf("%d", &p[i]); + } + + code = orderedPairToCodeIntAlgo2(p[0], p[1]); + printf("\n... The code is %ld", code); + + printf ("\ncode = "); + scanf("%ld",&code); + p = codeToOrderedPairIntAlgo2(code); + printf("The ordered pair identified by code %ld contains the following elements: ", code); + printf("("); + + for(i = 0; i < 1; i++){ + printf("%d, ", p[i]); + } + printf("%d)\n", p[1]); + } + while(1); +} + + +void testMultiIntAlgo2(){ + + int x = 0; + int y = 0; + long int code = 0; + int *p; + int size = 0; + + do{ + printf("\n(INTEGERS) Enter a size of a multidimensional array representing a 'ordered multiple': "); + scanf("%d",&size); + p = malloc(size * sizeof(int)); + int i; + for(i = 0; i < size; i++){ + printf("Enter value number %d: ", i); + scanf("%d", &p[i]); + } + + code = orderedMultipleToCodeIntAlgo2(p, size); + printf("\n... The code is %ld", code); + printf ("\ncode = "); + scanf("%ld",&code); + printf ("\nnumber of ordered elements = "); + scanf("%d",&size); + p = codeToOrderedMultipleIntAlgo2(code, size); + printf("The ordered multiple identified by code %ld contains the following elements: ", code); + printf("("); + + for(i = 0; i < (size - 1); i++){ + printf("%d, ", p[i]); + } + printf("%d)", p[size-1]); + } + while(1); +} + + + + +int main(int argc, char **argv, char **envp){ + // testMultiNat(); + // testPairInt(); + // testMultiInt(); + // testPairIntAlgo2(); + testMultiIntAlgo2(); +} + diff --git a/exo4-programmes/couples.lisp b/exo4-programmes/couples.lisp new file mode 100644 index 0000000..8bedf33 --- /dev/null +++ b/exo4-programmes/couples.lisp @@ -0,0 +1,134 @@ +#| +Auteur : John CHARRON +email : charron.john@gmail.com + +Ce petit program a plein de défauts, je le sais, n'en parlons pas pour l'instant. +L'idée ici était de m'amuser, de faire des progrès en LISP, de faire une implémentation +d'une question de complexité : le programme sera amélioré par la suite (meilleurs moyens +de récupérer des données (plus efficace), etc.), il ne s'agit qu'un début. +L'idée ici est de générer des couples avec une clé : + - *current* est la liste courante (clé x y) + - *db* est la base de données, les valeurs générées sont stockées dans *db* + (inefficace, je sais, car il faudrait pour l'instant faire un parcours séquentiel pour + retrouver la donnée... j'améliorera cela par la suite, laisser pour l'instant) + - les fonctions "right" "down-left", "down", "up-right" imitent le movement des + coordonnées sur un graphe mais au les coordonnées "y" positifs sont en DESSOUS du graphe + - "move" s'occupe de choisir "right", "down-left" etc. selon les valeurs dans *current* + - Pour que "move" marche, il faut mettre à jour à chaque "move" *max-x* et *max-y* (ici à l'aide + de la fonction "update-max-x-y" + - "zig-zag" fait n "move-and-update" en un seul coup et affiche le contenu de *db* (toutes les couples) +|# + + + +;; définition des variables globales (toujours entre astérisques) +(defvar *current* (list 0 0 0)) ;; liste courante "(code x y)" +(setf *current* (list 0 0 0)) +(defvar *db* nil) ;; base de données qui stocke tous les "(code x y)" +(setf *db* nil) +(push *current* *db*) + +(defvar *max-x* 0) ;; valeur maximal courante de x +(setf *max-x* 0) +(defvar *max-y* 0) ;; valeur maximal courante de y +(setf *max-y* 0) + +#| pour remettre toutes les variables globales à leur valeurs par défaut +afin de tester, de refaire un 'zig-zag', etc. +|# +(defun reset () + (progn + (defvar *current* (list 0 0 0)) ;; liste courante (clé x y) + (setf *current* (list 0 0 0)) + (defvar *db* nil) ;; base de données qui stocke tous les "(clé x y)" + (setf *db* nil) + (push *current* *db*) + (defvar *max-x* 0) ;; valeur maximal de x jusque "là" + (setf *max-x* 0) + (defvar *max-y* 0) ;; valeur maximal de y jusque "là" + (setf *max-y* 0) + *current*)) + +#| Les fonctions "right" "down-left", "down", "up-right" imitent le movement des +coordonnées sur un graphe mais au les coordonnées "y" positifs sont en DESSOUS du graphe +|# +(defun right (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (+ 1 (second L)) (last L)))) *db*) + *current*)) + +(defun down (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (second L) (cons (+ 1 (third L)) ())))) *db*) + *current*)) + +(defun up-right (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (+ 1 (second L)) (cons (- (third L) 1) ())))) *db*) + *current*)) + +(defun down-left (L) + (progn + (push + (setf *current* + (cons (+ 1 (first L)) (cons (- (second L) 1) (cons (+ 1 (third L)) ())))) *db*) + *current*)) + +(defun update-max-x (L) + (if (> (second L) *max-x*) + (setf *max-x* (second L)) + nil)) + +(defun update-max-y (L) + (if (> (third L) *max-y*) + (setf *max-y* (third L)) + nil)) + +(defun update-max-x-y (L) + (cond + ((> (second L) *max-x*) + (setf *max-x* (second L))) + ((> (third L) *max-y*) + (setf *max-y* (third L))) + (t ()))) + +;; "move" s'occupe de choisir "right", "down-left" etc. selon les valeurs dans *current* +(defun move (L) + (cond + ((and (zerop (third L)) (= *max-x* *max-y*)) ;; RIGHT takes precedence over LEFT becuase it occurs first + (print "in RIGHT") ;; + (right L)) + ((and (zerop (second L)) (= *max-x* *max-y*)) ;; DOWN + (print "in DOWN") + (down L)) + ((> *max-x* *max-y*) ;; DOWN-LEFT + (print "in DOWN-LEFT") + (down-left L)) + ((< *max-x* *max-y*) ;; UP-RIGHT + (print "in UP-RIGHT") + (up-right L)))) + +#| +On fait un "move" et puis un "update-max-x-y" +Attention : il faut bien faire un setf L, sinon, le paramètre L de "update-max-x-y utilise la valeur +de L inchangé ! +|# +(defun move-and-update (L) + (progn + (setf L (move L)) + (update-max-x-y L) + *db*)) + +;; "zig-zag" fait n "move-and-update" en un seul coup et affiche le contenu de *db* (toutes les couples) +(defun zig-zag (L n) + (if (zerop n) + (move-and-update *current*) + (progn + (move-and-update *current*) + (zig-zag L (- n 1))))) diff --git a/exo4-programmes/couples_entiers.c b/exo4-programmes/couples_entiers.c new file mode 100644 index 0000000..2b60dc9 --- /dev/null +++ b/exo4-programmes/couples_entiers.c @@ -0,0 +1,150 @@ +#include +#include +#include + +int pair(int x){ + return (!(x % 2)); +} + +int orderedPairToCode(int x, int y){ + int sumxy, code; + sumxy = x + y; + code = ((sumxy)*(sumxy + 1))/2; + + if(pair(sumxy)){ + code = code + x; + } + else{ + code = code + y; + } + return code; +} + + +int* codeToOrderedPair(int code){ + int *couple = malloc(2*sizeof(int)); + int n = sqrt(code * 2); + int axis = (n * (n + 1))/2; + int diff = 0; + if(axis > code){ + while(axis > code){ + n = n - 1; + axis = (n * (n + 1))/2; + } + } + else if(axis < code){ + while(axis < code){ + n = n + 1; + axis = (n * (n + 1))/2; + } + if(axis > code){ + n = n - 1; + axis = (n * (n + 1))/2; + } + } + + if(axis == code){ // je pense que je peux me dispenser de cet "if", ça revient au même car diff serait = 0 + if(pair(n)){ + couple[0] = 0; + couple[1] = n; + } + else{ + couple[0] = n; + couple[1] = 0; + } + } + if(axis != code){ // idem + diff = code - axis; + if(pair(n)){ + couple[0] = diff; + couple[1] = n - diff; + } + else{ + couple[0] = n - diff; + couple[1] = diff; + } + } + return couple; +} + +int orderedMultipleToCode(int *arr, int size){ + int code; + if(size > 1){ + code = orderedPairToCode(arr[size - 2], arr[size - 1]); + arr[size - 2] = code; + arr = realloc(arr, (size - 1)); + if(size > 2){ + code = orderedMultipleToCode(&arr[0], (size - 1)); + } + } + return code; +} + +int* codeToOrderedMultiple(int code, int size){ + int *multiple = malloc(size*sizeof(int)); + int *pair; + int i = 0; + for(i = 0; i < (size - 1); i++){ + pair = codeToOrderedPair(code); + code = pair[1]; + multiple[i] = pair[0]; + multiple[i + 1] = pair[1]; + } + return multiple; +} + + +int main(int argc, char **argv, char **envp){ + + int x = 0; + int y = 0; + int code = 0; + int *p; + int size = 0; + + do{ + /* + printf ("\nx = "); + scanf("%d",&x); + printf ("y = "); + scanf("%d",&y); + code = orderedPairToCode(x, y); + printf("Le code du couple (%d, %d) est %d\n", x, y, code); + + printf ("\ncode = "); + scanf("%d",&code); + p = codeToOrderedPair(code); + printf("The ordered pair identified by code %d is (%d, %d)", code, p[0], p[1]); + +*/ + printf("\nEnter a size of a multidimensional array representing a 'ordered multiple': "); + scanf("%d",&size); + p = malloc(size * sizeof(int)); + int i; + for(i = 0; i < size; i++){ + printf("Enter value number %d: ", i); + scanf("%d", &p[i]); + } + + code = orderedMultipleToCode(p, size); + printf("\n... The code is %d", code); + + + + printf ("\ncode = "); + scanf("%d",&code); + printf ("\nnumber of ordered elements = "); + scanf("%d",&size); + p = codeToOrderedMultiple(code, size); + printf("The ordered multiple identified by code %d contains the following elements: ", code); + printf("("); + for(i = 0; i < (size - 1); i++){ + printf("%d, ", p[i]); + } + printf("%d)", p[size-1]); + + + } + while(code != -1); +} +