bff60c0d16c68d0dbf0ef215a4124b4439cc05ab to main · algorithmique / cours

Some changes are not shown.

For a faster browsing experience, only 69 of 1000 files are shown. Download one of the files below to see all changes.

.gitignore

0 → 100644

+7 −0

Original line number	Diff line number	Diff line
		*.o
		.xopp
		slides/package-lock.json
		slides/package.json
		slides/.vscode/settings.json
		.vscode/settings.json
		slides/node_modules/.package-lock.json

.gitlab-ci.yml

+8 −5

Original line number	Diff line number	Diff line
		image: omalaspinas/pandoc:latest
		image: omalaspinas/c_pandoc:latest

		variables:
		GIT_SUBMODULE_STRATEGY: recursive
		@@ -9,8 +9,8 @@ before_script:
		## Install ssh-agent if not already installed, it is required by Docker.
		## (change apt-get to yum if you use an RPM-based image)
		##
		- 'which ssh-agent \|\| (pacman -S --noconfirm openssh)'
		- 'which rsync \|\| (pacman -S --noconfirm rsync)'
		- 'which ssh-agent \|\| (apk add --update openssh-client)'
		- 'which rsync \|\| (apk add --update rsync)'


		##
		@@ -38,8 +38,6 @@ before_script:
		- echo "$SSH_KNOWN_HOSTS" > ~/.ssh/known_hosts
		- chmod 644 ~/.ssh/known_hosts



		build_only:
		script:
		- cd slides
		@@ -47,6 +45,11 @@ build_only:
		- make deploy
		- rsync -avz algo_cours ur1bg_malas@ur1bg.ftp.infomaniak.com:web/malaspinas/

		build_examples:
		script:
		- cd source_codes
		- make

		build_artifacts:
		script:
		- cd slides

README.md

0 → 100644

+17 −0

Original line number	Diff line number	Diff line
		# Remerciements et contributions

		Merci aux contributeurs suivants pour leurs efforts (dans un ordre alphabétique):

		* P. Albuquerque
		* J. Bach
		* A. Boyer
		* M. Corboz
		* M. Divià
		* Y. El Hakouni
		* A. Escribano
		* P. Kunzli
		* G. Legouic
		* G. Marino Jarrin
		* H. Radhwan
		* I. Saroukhanian
		* C. Volta

collective_coding/hashmap/.gitignore

0 → 100644

+2 −0

Original line number	Diff line number	Diff line
		*.o
		main

collective_coding/hashmap/Makefile

0 → 100644

+20 −0

Original line number	Diff line number	Diff line
		CC=gcc
		CFLAGS=-g -std=gnu11 -Wall -Wextra -pedantic -fsanitize=address -fsanitize=leak -fsanitize=undefined
		LDFLAGS=-fsanitize=address -fsanitize=leak -fsanitize=undefined
		SOURCES=$(wildcard *.c)
		OBJECTS=$(SOURCES:.c=.o)

		TARGET = main

		all: $(TARGET)

		$(TARGET): $(OBJECTS)
		$(CC) $^ -o $@ $(LDFLAGS)

		hm.c: hm.h

		.PHONY = clean

		clean:
		rm -f $(OBJECTS) $(TARGET)

collective_coding/hashmap/hm.c

0 → 100644

+91 −0

Original line number	Diff line number	Diff line
		#include "hm.h"
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>

		static int hash(char *key, int capacity) {
		int h = 0;
		for (size_t i = 0; i < strlen(key); ++i) {
		h = (h + key[i] * 43) % capacity;
		}
		return h;
		}

		static int rehash(char *key) {
		return 1;
		}

		static int find_index(hm h, char *key) {
		int i = hash(key, h.capacity);
		int init = i;
		while (h.table[i].state != empty &&
		strncmp(h.table[i].key, key, MAX_LEN) != 0) {
		i = (i + rehash(key)) % h.capacity;
		if (i == init) {
		return -1;
		}
		}
		return i;
		}

		void hm_init(hm *h, int capacity) {
		h->table = malloc(capacity * sizeof(cell_t));
		h->capacity = capacity;
		for (int i = 0; i < h->capacity; ++i) {
		h->table[i].state = empty;
		}
		}

		void hm_destroy(hm *h) {
		free(h->table);
		h->table = NULL;
		h->capacity = -1;
		}

		bool hm_set(hm h, char key, char *value) {
		int i = hash(key, h->capacity);
		int init = i;
		while (h->table[i].state == occupied &&
		strncmp(h->table[i].key, key, MAX_LEN) != 0) {
		i = (i + rehash(key)) % h->capacity;
		if (i == init) {
		return false;
		}
		}
		if (strncpy(h->table[i].key, key, MAX_LEN) == NULL) {
		return false;
		};
		if (strncpy(h->table[i].value, value, MAX_LEN) == NULL) {
		return false;
		};
		h->table[i].state = occupied;
		return true;
		}

		char hm_get(hm h, char key) {
		int i = find_index(h, key);
		return (i >= 0 && h.table[i].state == occupied) ? h.table[i].value : NULL;
		}

		char hm_remove(hm h, char *key) {
		int i = find_index(*h, key);
		if (i >= 0 && h->table[i].state == occupied) {
		h->table[i].state = deleted;
		return h->table[i].value;
		} else {
		return NULL;
		}
		}

		void hm_print(hm h) {
		for (int i = 0; i < h.capacity; ++i) {
		if (h.table[i].state == occupied) {
		printf("[%d], key: %s, value: %s\n", i, h.table[i].key,
		h.table[i].value);

		} else {
		printf("[%d], key: none, value: none\n", i);
		}
		}
		}

collective_coding/hashmap/hm.h

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		#ifndef _HM_H_
		#define _HM_H_

		#include <stdbool.h>

		#define MAX_LEN 80

		typedef enum { empty, occupied, deleted } state_t;

		typedef struct _cell_t {
		state_t state;
		char key[MAX_LEN];
		char value[MAX_LEN];
		} cell_t;

		typedef struct _hm {
		int capacity;
		cell_t *table;
		} hm;

		void hm_init(hm *h, int capacity);
		void hm_destroy(hm *h);
		bool hm_set(hm h, char key, char *value);
		char hm_get(hm h, char key);
		char hm_remove(hm h, char *key);
		void hm_print(hm h);

		#endif

collective_coding/hashmap/main.c

0 → 100644

+48 −0

Original line number	Diff line number	Diff line
		#include "hm.h"
		#include <stdio.h>

		int main() {
		hm h;
		hm_init(&h, 5);
		for (int i = 0; i < 7; ++i) {
		char key[MAX_LEN], value[MAX_LEN];
		printf("Enter key please:\n");
		scanf("%s", key);
		printf("Enter value please:\n");
		scanf("%s", value);
		hm_set(&h, key, value);
		hm_print(h);
		}
		printf("DELETE VALUES!\n");
		for (int i = 0; i < 2; ++i) {
		char key[MAX_LEN];
		printf("Enter key please:\n");
		scanf("%s", key);
		printf("Value: ");
		char *value = hm_remove(&h, key);
		if (value == NULL) {
		printf("Key not found.\n");
		} else {
		printf("Value is %s.\n", value);
		}
		hm_print(h);
		}
		printf("SEARCH VALUES!\n");
		for (int i = 0; i < 2; ++i) {
		char key[MAX_LEN];
		printf("Enter key please:\n");
		scanf("%s", key);
		printf("Value: ");
		char *value = hm_get(h, key);
		if (value == NULL) {
		printf("Key not found.\n");
		} else {
		printf("Value is %s.\n", value);
		}
		}
		hm_destroy(&h);
		/* for (int i = 0; i < 6; ++i) { */
		/* scanf("%s", key); */
		/* scanf("%s", value); */
		/* } */
		}

css/tufte-css/tufte.css

0 → 100644

+470 −0

Original line number	Diff line number	Diff line
		@charset "UTF-8";

		/* Import ET Book styles
		adapted from https://github.com/edwardtufte/et-book/blob/gh-pages/et-book.css */

		@font-face {
		font-family: "et-book";
		src: url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.eot");
		src: url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.woff") format("woff"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.ttf") format("truetype"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.svg#etbookromanosf") format("svg");
		font-weight: normal;
		font-style: normal;
		font-display: swap;
		}

		@font-face {
		font-family: "et-book";
		src: url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.eot");
		src: url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.woff") format("woff"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.ttf") format("truetype"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.svg#etbookromanosf") format("svg");
		font-weight: normal;
		font-style: italic;
		font-display: swap;
		}

		@font-face {
		font-family: "et-book";
		src: url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.eot");
		src: url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.woff") format("woff"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.ttf") format("truetype"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.svg#etbookromanosf") format("svg");
		font-weight: bold;
		font-style: normal;
		font-display: swap;
		}

		@font-face {
		font-family: "et-book-roman-old-style";
		src: url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.eot");
		src: url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.woff") format("woff"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.ttf") format("truetype"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.svg#etbookromanosf") format("svg");
		font-weight: normal;
		font-style: normal;
		font-display: swap;
		}

		/* Tufte CSS styles */
		html {
		font-size: 15px;
		}

		body {
		width: 87.5%;
		margin-left: auto;
		margin-right: auto;
		padding-left: 12.5%;
		font-family: et-book, Palatino, "Palatino Linotype", "Palatino LT STD", "Book Antiqua", Georgia, serif;
		background-color: #fffff8;
		color: #111;
		max-width: 1400px;
		counter-reset: sidenote-counter;
		}

		h1 {
		font-weight: 400;
		margin-top: 4rem;
		margin-bottom: 1.5rem;
		font-size: 3.2rem;
		line-height: 1;
		}

		h2 {
		font-style: italic;
		font-weight: 400;
		margin-top: 2.1rem;
		margin-bottom: 1.4rem;
		font-size: 2.2rem;
		line-height: 1;
		}

		h3 {
		font-style: italic;
		font-weight: 400;
		font-size: 1.7rem;
		margin-top: 2rem;
		margin-bottom: 1.4rem;
		line-height: 1;
		}

		hr {
		display: block;
		height: 1px;
		width: 55%;
		border: 0;
		border-top: 1px solid #ccc;
		margin: 1em 0;
		padding: 0;
		}

		p.subtitle {
		font-style: italic;
		margin-top: 1rem;
		margin-bottom: 1rem;
		font-size: 1.8rem;
		display: block;
		line-height: 1;
		}

		.numeral {
		font-family: et-book-roman-old-style;
		}

		.danger {
		color: red;
		}

		article {
		padding: 5rem 0rem;
		}

		section {
		padding-top: 1rem;
		padding-bottom: 1rem;
		}

		p,
		dl,
		ol,
		ul {
		font-size: 1.4rem;
		line-height: 2rem;
		}

		p {
		margin-top: 1.4rem;
		margin-bottom: 1.4rem;
		padding-right: 0;
		vertical-align: baseline;
		}

		/* Chapter Epigraphs */
		div.epigraph {
		margin: 5em 0;
		}

		div.epigraph > blockquote {
		margin-top: 3em;
		margin-bottom: 3em;
		}

		div.epigraph > blockquote,
		div.epigraph > blockquote > p {
		font-style: italic;
		}

		div.epigraph > blockquote > footer {
		font-style: normal;
		}

		div.epigraph > blockquote > footer > cite {
		font-style: italic;
		}
		/* end chapter epigraphs styles */

		blockquote {
		font-size: 1.4rem;
		}

		blockquote p {
		width: 55%;
		margin-right: 40px;
		}

		blockquote footer {
		width: 55%;
		font-size: 1.1rem;
		text-align: right;
		}

		section > p,
		section > footer,
		section > table {
		width: 55%;
		}

		/* 50 + 5 == 55, to be the same width as paragraph */
		section > dl,
		section > ol,
		section > ul {
		width: 50%;
		-webkit-padding-start: 5%;
		}

		dt:not(:first-child),
		li:not(:first-child) {
		margin-top: 0.25rem;
		}

		figure {
		padding: 0;
		border: 0;
		font-size: 100%;
		font: inherit;
		vertical-align: baseline;
		max-width: 55%;
		-webkit-margin-start: 0;
		-webkit-margin-end: 0;
		margin: 0 0 3em 0;
		}

		figcaption {
		float: right;
		clear: right;
		margin-top: 0;
		margin-bottom: 0;
		font-size: 1.1rem;
		line-height: 1.6;
		vertical-align: baseline;
		position: relative;
		max-width: 40%;
		}

		figure.fullwidth figcaption {
		margin-right: 24%;
		}

		/* Links: replicate underline that clears descenders */
		a:link,
		a:visited {
		color: inherit;
		}

		.no-tufte-underline:link {
		background: unset;
		text-shadow: unset;
		}

		a:link, .tufte-underline, .hover-tufte-underline:hover {
		text-decoration: none;
		background: -webkit-linear-gradient(#fffff8, #fffff8), -webkit-linear-gradient(#fffff8, #fffff8), -webkit-linear-gradient(currentColor, currentColor);
		background: linear-gradient(#fffff8, #fffff8), linear-gradient(#fffff8, #fffff8), linear-gradient(currentColor, currentColor);
		-webkit-background-size: 0.05em 1px, 0.05em 1px, 1px 1px;
		-moz-background-size: 0.05em 1px, 0.05em 1px, 1px 1px;
		background-size: 0.05em 1px, 0.05em 1px, 1px 1px;
		background-repeat: no-repeat, no-repeat, repeat-x;
		text-shadow: 0.03em 0 #fffff8, -0.03em 0 #fffff8, 0 0.03em #fffff8, 0 -0.03em #fffff8, 0.06em 0 #fffff8, -0.06em 0 #fffff8, 0.09em 0 #fffff8, -0.09em 0 #fffff8, 0.12em 0 #fffff8, -0.12em 0 #fffff8, 0.15em 0 #fffff8, -0.15em 0 #fffff8;
		background-position: 0% 93%, 100% 93%, 0% 93%;
		}

		@media screen and (-webkit-min-device-pixel-ratio: 0) {
		a:link, .tufte-underline, .hover-tufte-underline:hover {
		background-position-y: 87%, 87%, 87%;
		}
		}

		a:link::selection,
		a:link::-moz-selection {
		text-shadow: 0.03em 0 #b4d5fe, -0.03em 0 #b4d5fe, 0 0.03em #b4d5fe, 0 -0.03em #b4d5fe, 0.06em 0 #b4d5fe, -0.06em 0 #b4d5fe, 0.09em 0 #b4d5fe, -0.09em 0 #b4d5fe, 0.12em 0 #b4d5fe, -0.12em 0 #b4d5fe, 0.15em 0 #b4d5fe, -0.15em 0 #b4d5fe;
		background: #b4d5fe;
		}

		/* Sidenotes, margin notes, figures, captions */
		img {
		max-width: 100%;
		}

		.sidenote,
		.marginnote {
		float: right;
		clear: right;
		margin-right: -60%;
		width: 50%;
		margin-top: 0.3rem;
		margin-bottom: 0;
		font-size: 1.1rem;
		line-height: 1.3;
		vertical-align: baseline;
		position: relative;
		}

		.sidenote-number {
		counter-increment: sidenote-counter;
		}

		.sidenote-number:after,
		.sidenote:before {
		font-family: et-book-roman-old-style;
		position: relative;
		vertical-align: baseline;
		}

		.sidenote-number:after {
		content: counter(sidenote-counter);
		font-size: 1rem;
		top: -0.5rem;
		left: 0.1rem;
		}

		.sidenote:before {
		content: counter(sidenote-counter) " ";
		font-size: 1rem;
		top: -0.5rem;
		}

		blockquote .sidenote,
		blockquote .marginnote {
		margin-right: -82%;
		min-width: 59%;
		text-align: left;
		}

		div.fullwidth,
		table.fullwidth {
		width: 100%;
		}

		div.table-wrapper {
		overflow-x: auto;
		font-family: "Trebuchet MS", "Gill Sans", "Gill Sans MT", sans-serif;
		}

		.sans {
		font-family: "Gill Sans", "Gill Sans MT", Calibri, sans-serif;
		letter-spacing: .03em;
		}

		code, pre > code {
		font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;
		font-size: 1.0rem;
		line-height: 1.42;
		-webkit-text-size-adjust: 100%; /* Prevent adjustments of font size after orientation changes in iOS. See https://github.com/edwardtufte/tufte-css/issues/81#issuecomment-261953409 */
		}

		.sans > code {
		font-size: 1.2rem;
		}

		h1 > code,
		h2 > code,
		h3 > code {
		font-size: 0.80em;
		}

		.marginnote > code,
		.sidenote > code {
		font-size: 1rem;
		}

		pre > code {
		font-size: 0.9rem;
		width: 52.5%;
		margin-left: 2.5%;
		overflow-x: auto;
		display: block;
		}

		pre.fullwidth > code {
		width: 90%;
		}

		.fullwidth {
		max-width: 90%;
		clear:both;
		}

		span.newthought {
		font-variant: small-caps;
		font-size: 1.2em;
		}

		input.margin-toggle {
		display: none;
		}

		label.sidenote-number {
		display: inline;
		}

		label.margin-toggle:not(.sidenote-number) {
		display: none;
		}

		.iframe-wrapper {
		position: relative;
		padding-bottom: 56.25%; /* 16:9 */
		padding-top: 25px;
		height: 0;
		}

		.iframe-wrapper iframe {
		position: absolute;
		top: 0;
		left: 0;
		width: 100%;
		height: 100%;
		}

		@media (max-width: 760px) {
		body {
		width: 84%;
		padding-left: 8%;
		padding-right: 8%;
		}

		hr,
		section > p,
		section > footer,
		section > table {
		width: 100%;
		}

		pre > code {
		width: 97%;
		}

		section > dl,
		section > ol,
		section > ul {
		width: 90%;
		}

		figure {
		max-width: 90%;
		}

		figcaption,
		figure.fullwidth figcaption {
		margin-right: 0%;
		max-width: none;
		}

		blockquote {
		margin-left: 1.5em;
		margin-right: 0em;
		}

		blockquote p,
		blockquote footer {
		width: 100%;
		}

		label.margin-toggle:not(.sidenote-number) {
		display: inline;
		}

		.sidenote,
		.marginnote {
		display: none;
		}

		.margin-toggle:checked + .sidenote,
		.margin-toggle:checked + .marginnote {
		display: block;
		float: left;
		left: 1rem;
		clear: both;
		width: 95%;
		margin: 1rem 2.5%;
		vertical-align: baseline;
		position: relative;
		}

		label {
		cursor: pointer;
		}

		div.table-wrapper,
		table {
		width: 85%;
		}

		img {
		width: 100%;
		}
		}

examples/hashmap/.gitignore

0 → 100644

+2 −0

Original line number	Diff line number	Diff line
		main
		*.o

examples/hashmap/Makefile

0 → 100644

+20 −0

Original line number	Diff line number	Diff line
		CC=gcc
		CFLAGS=-g -std=gnu11 -Wall -Wextra -pedantic -fsanitize=address -fsanitize=leak -fsanitize=undefined
		LDFLAGS=-fsanitize=address -fsanitize=leak -fsanitize=undefined
		SOURCES=$(wildcard *.c)
		OBJECTS=$(SOURCES:.c=.o)

		TARGET = main

		all: $(TARGET)

		$(TARGET): $(OBJECTS)
		$(CC) $^ -o $@ $(LDFLAGS)

		hashmap.c: hashmap.h

		.PHONY = clean

		clean:
		rm -f $(OBJECTS) $(TARGET)

examples/hashmap/hm.c

0 → 100644

+123 −0

Original line number	Diff line number	Diff line
		#include "hm.h"
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>

		static bool is_not_allocated(hm h) {
		return (h.table == NULL \|\| h.capacity < 1 \|\| h.size < 0);
		}

		static size_t hash(hm h, char key[MAX_LEN]) {
		int index = 0;
		for (size_t i = 0; i < strlen(key); ++i) {
		index = (index + key[i] * 43) % h.capacity;
		}
		return index;
		}

		static int rehash(char *key) {
		return 1;
		}

		static bool search_condition(hm h, char key[MAX_LEN], int index) {
		return strncmp(h.table[index].key, key, MAX_LEN) == 0 &&
		h.table[index].state == occupied;
		}

		static bool set_condition(hm h, char key[MAX_LEN], int index) {
		return search_condition(h, key, index) \|\| h.table[index].state != occupied;
		}

		static int find_index(
		hm h, char key[MAX_LEN], bool (*condition)(hm, char[], int)) {
		int try = 0;
		int index = hash(h, key);
		while (try < h.capacity) {
		if (condition(h, key, index)) {
		return index;
		}
		index = (index + rehash(key)) % h.capacity;
		try += 1;
		}
		return -1;
		}

		static bool is_empty(hm h) {
		return h.size == 0;
		}

		void hm_init(hm *h, int capacity) {
		h->capacity = capacity;
		h->size = 0;
		h->table = malloc(h->capacity * sizeof(*h->table));
		for (int i = 0; i < h->capacity; ++i) {
		h->table[i].state = empty;
		}
		}

		void hm_destroy(hm *h) {
		h->capacity = -1;
		h->size = -1;
		free(h->table);
		h->table = NULL;
		}

		bool hm_set(hm h, char key, char *value) {
		if (is_not_allocated(*h)) {
		return false;
		}

		int index = find_index(*h, key, set_condition);
		if (index < 0) {
		return false;
		}
		/* printf("%d\n", index); */
		strncpy(h->table[index].value, value, MAX_LEN);
		strncpy(h->table[index].key, key, MAX_LEN);
		h->table[index].state = occupied;
		h->size += 1;
		return true;
		}

		bool hm_get(hm h, char key, char value) {
		int index = find_index(h, key, search_condition);
		if (index >= 0) {
		strncpy(value, h.table[index].value, MAX_LEN);
		return true;
		}
		return false;
		}
		bool hm_remove(hm h, char key, char *value) {
		int index = find_index(*h, key, search_condition);
		if (index >= 0) {
		h->table[index].state = deleted;
		strncpy(value, h->table[index].value, MAX_LEN);
		h->size -= 1;
		return true;
		}
		return false;
		}

		bool hm_search(hm h, char *key) {
		int index = find_index(h, key, search_condition);
		return (index >= 0);
		}

		void hm_print(hm h) {
		if (is_not_allocated(h)) {
		printf("Well this hashmap is not allocated n00b.\n");
		}
		if (is_empty(h)) {
		printf("The hashmap is empty.\n");
		}
		for (int i = 0; i < h.capacity; ++i) {
		if (h.table[i].state == occupied) {
		printf("index: %d, key: %s, value: %s\n", i, h.table[i].key,
		h.table[i].value);

		} else {
		printf("index: %d, key: {none}, value: {none}\n", i);
		}
		}
		}

examples/hashmap/hm.h

0 → 100644

+30 −0

Original line number	Diff line number	Diff line
		#ifndef _HM_H_
		#define _HM_H_

		#include <stdbool.h>

		#define MAX_LEN 80

		typedef enum { empty, occupied, deleted } state_t;

		typedef struct _cell_t {
		char key[MAX_LEN];
		char value[MAX_LEN];
		state_t state;
		} cell_t;

		typedef struct _hm {
		cell_t *table;
		int capacity;
		int size;
		} hm;

		void hm_init(hm *h, int capacity);
		void hm_destroy(hm *h);
		bool hm_set(hm h, char key, char *value);
		bool hm_get(hm h, char key, char value);
		bool hm_remove(hm h, char key, char *value);
		bool hm_search(hm h, char *key);
		void hm_print(hm h);

		#endif

examples/hashmap/main.c

0 → 100644

+21 −0

Original line number	Diff line number	Diff line
		#include "hm.h"
		#include <stdio.h>

		int main() {
		char key[80], value[80];
		hm h;
		hm_init(&h, 5);
		for (int i = 0; i < 6; ++i) {
		scanf("%s", key);
		scanf("%s", value);
		hm_set(&h, key, value);
		hm_print(h);
		if (hm_search(h, "orestis")) {
		printf("orestis found.\n");
		}
		if (hm_remove(&h, "orestis", value)) {
		printf("orestis removed: %s.\n", value);
		}
		}
		hm_destroy(&h);
		}

examples/tri_selection/tri.c

+15 −3

Original line number	Diff line number	Diff line
		@@ -15,6 +15,12 @@ void find_min(double tab[], int i0, int ind, double min) {
		}
		}

		void swap(double a, double b) {
		double tmp = *a;
		a = b;
		*b = tmp;
		}

		int main() {
		srand(time(NULL));
		double tab[SIZE];
		@@ -26,13 +32,19 @@ int main() {
		double min = tab[i];
		int ind_min = i;
		find_min(tab, i, &ind_min, &min);
		double tmp = tab[i];
		tab[i] = min;
		tab[ind_min] = tmp;
		swap(&tab[i], &tab[ind_min]);
		}

		for (int i = 0; i < SIZE; ++i) {
		printf("%f ", tab[i]);
		}
		printf("\n");

		for (int i = 0; i < SIZE - 1; ++i) {
		if (tab[i] > tab[i + 1]) {
		return EXIT_FAILURE;
		}
		}

		return EXIT_SUCCESS;
		}

lessons/.gitignore

0 → 100644

+5 −0

Original line number	Diff line number	Diff line
		*.log
		*.aux
		*.pdf
		*.dvi
		*.eps

lessons/contenu_cours_1.md

0 → 100644

+207 −0

Original line number	Diff line number	Diff line
		# Algorithmes et structures de données 2020-21

		Contenu du cours 1 du 16.09.2020

		*****


		## Présentation personnelle

		[Paul Albuquerque](mailto:paul.albuquerque@hesge.ch), resp. de filière
		bureau B410
		022 546 2554
		paul.albuquerque@hesge.ch

		## Organisation du module (2 cours, 50 % chacun)

		- Algorithmes et structures de données
		- 1er semestre
		- Bases de la programmation en C jusqu'à Noël
		- Algorithmique jusque fin janvier
		- 2ème semestre
		- Algorithmique

		> Au moins 2 évaluations par semestre

		- Programmation séquentielle en langage C
		- 1er & 2ème semestre :travaux pratiques en langage C
		- Chaque semestre des travaux pratiques sont répartis dans deux gros projets d'env. 7 semaines

		## Qu'est-ce qu'un algorithme ?

		Informellement, c'est une recette ou une marche à suivre.

		Plus formellement:

		\| Définition \|
		\|:-----------------------------------------------------------------\|
		\| Un algorithme est une suite finie et non ambiguë d'opérations\|
		\| ou d'instructions permettant de résoudre un problème. \|


		Le mot algorithme vient du nom latinisé du mathématicien perse
		[Al-Khawarizmi](http://fr.wikipedia.org/wiki/Al-Khawarizmi)

		Les algorithmes des grecs : Euclide, Erastosthène

		Le père de l'algorithmique : Muhammad Ibn Mūsā al-Khuwārizmī

		Résolution d'un problème

		- Décomposition en sous-problèmes
		- Résolution des sous-problèmes
		- Assemblage des résultats

		## Notions de base d'algorithmique séquentielle

		- Définition d'une variable (nom, type, valeur, adresse)
		- Séquences d'instructions
		- Boucles et tests (`for`, `while`, `do...while`, `if...else`)

		## Algorithme de vérification qu'un nombre est 1<sup>er</sup>

		- Comment demander le nombre
		- Forme de l'algorithme (boucle et tests)
		- Condition d'arrêt de la boucle

		## Qu'est qu'un programme C ?

		- Importations de librairies (paquetages) :
		```C
		#include <stdlio.h>
		#include <stdlib.h>
		```

		- Entête du programme : `int main()`
		- Déclaration de variables : `int x = 5;`
		- Bloc d'instructions :
		```C
		{
		int x = 5;
		printf("x=%d\n",x);

		}
		```

		## Les types de base : les entiers (`int, unsigned int`)

		- Numérotation binaire en particulier sur 32 bits
		- Nombres négatifs =\> complément à 2

		numération sur 3 bits :

		\|binaire \| entier&GreaterEqual;0\| binaire \| entier<0\|
		\|:-------\|:---------------------\|:--------\|:--------\|
		\|000 \| 0 \| 111 \| -1 \|
		\|001 \| 1 \| 110 \| -2 \|
		\|010 \| 2 \| 101 \| -3 \|
		\|011 \| 3 \| 100 \| -4 \|

		- Nombres négatifs =\> complément à 1 par simple inversion des bits

		problème : 0 possède alors deux représentations !

		- Opérations particulières
		- Division entière : 5 / 2 = 2 , 10 / 3 = 3 , 18 / 5 = 3
		- Reste de la division entière (modulo) : 5 % 2 = 1 , 10 % 3 = 1 , 18 % 5 = 3
		- Constantes de la librairie `<limits.h>`: `INT_MAX, INT_MIN`

		## Les types de base : les réels (`float, double`)

		- `Float`: écriture, opérations, exemples complets d'exponentiation
		`pow(A,B)` où `A, B` sont des `double` =\> le résultat est un `double` !
		Attention ! Le calcul effectué par pow utilise un logarithmes et une exponentielle.

		> Sur 32 bits : 1 bit de signe, 8 bits pour l'exposant et 23 bits pour la mantisse.

		- Exemple : coder 19,625 en binaire

		> > 19 : 10011 = 2<sup>4</sup> + 2<sup>1</sup> + 2<sup>0</sup>;
		0,625 : 0,101 = 2<sup>-1</sup> + 2<sup>-3</sup>

		> > 19,625 : 10011,101 = 0,10011101 \* 2<sup>5</sup>

		> > Le signe du nombre est stocké sur dans le 1<sup>er</sup> bit (0 positif / 1 négatif).

		> > L'exposant est stocké sur 8 positions =\> 256 valeurs =\> -128..127.

		> > Donc 5 = 00000101

		> > La mantisse de 23 bits stockée est 00111010000000000000000
		(le 1<sup>er</sup> 1 est omis car obligatoire)

		> > 19,625 stocké en binaire : 0 00000101 00111010000000000000000

		- Questions : quelles sont les valeurs les plus petite, grande, petite positive (\>0)?

		## Les booléens `bool`

		- Librairie: `<stdbool.h>`
		Valeurs possibles: `true, false`
		Conversion possible en entier

		> Exemples:
		```C
		bool x = true; // booléen vrai
		bool x = false; // booléen faux
		bool x = 17; // 17 converti en booléen vrai
		bool x = -5; // -5 converti en booléen vrai
		bool x = 0; // 0 converti en booléen faux
		int y = false; // booléen faux converti en 0
		int y = true; // booléen vrai converti en 1
		```

		- Vérification =\> table de vérité
		- not (A and B) = (not A) or (not B) : `!(A && B) == (!A)\|\| (!B)`
		- not (A or B) = (not A) and (not B) : `! --\|\| B) == (!A) && (!B)`
		- Opérateurs logiques : `*==, !=, &&, \|\|, !, <, >, <=, >=`
		- Comparaisons bit à bit : `&` (et), `\|` (ou), `^` (xor), `!` (not)
		- Comparaisons bit à bit avec assignation : `&=, \|=, ^=`


		## Structures de boucle

		- Syntaxe
		```C
		for (initialisation;condition;increment) {
		instructions;
		}

		while (condition) {
		instructions;
		}

		do {
		instructions;
		} while (condition);
		```
		- Instructions : `break, continue`

		## Les caractères (type prédéfini) `char`

		- On considère les caractères sont des valeurs encodées sur 1 octet (code ASCII étendu).
		Il y a donc 256 valeurs possibles. La conversion entre entier et caractère est effective.
		Par exemple, le caractère 'A' correspond à 65 et 'a' à 96.
		```C
		char ch = 'a'; // Caractère 'a'
		printf("La variable ch est %c\n",ch); // affiche 'a'
		char x = 96;
		printf("La variable x est %c\n",x); // affiche aussi 'a'
		int v = 'a';
		printf("La variable v est %d\n",v); // affiche 96
		```
		## Structures de test

		- Syntaxe
		```C
		if (condition) {
		instructions;
		} else if (condition) {
		instructions;
		} else {
		instructions;
		}
		```
		## Exemple de boucles (`for, while, do ... while`)

		- La factorielle

lessons/contenu_cours_2.md

0 → 100644

+91 −0

Original line number	Diff line number	Diff line
		# Algorithmes et structures de données 2020-21

		Contenu du cours 2 du du 23.09.2020

		*****

		## Plus petit commun multiple (PPCM) de deux nombres

		- Algorithme de PPCM: exemple avec 12 et 15

		\| Tester si\| `>, <` ou `=`\| \|
		\|-----------\|:------------:\|:---------\|
		\| \| `12 < 15` \| \|
		\| \| `24 > 15` \| \|
		\| \| `24 < 30` \| \|
		\| \| `36 > 30` \| \|
		\| \| `36 < 45` \| \|
		\| \| `48 > 45` \| \|
		\| \| `48 < 60` \| \|
		\| \| `60 = 60` \| Fin !\|


		## Plus grand diviseur commun (PGCD) de deux nombres

		- Algorithme naïf du PGCD
		- Pseudo-code du calcul du `PGCD` de `N` et `M`

		```
		si M rem N = 0 alors
		PGCD := N
		sinon
		pour I de sqrt(N) à 1 faire
		si N rem I = 0 et M rem I = 0 alors
		PGCD := I
		exit
		fin si
		fin pour
		fin si
		```

		- Algorithme d'Euclide : exemple avec N = 35 et M = 60

		\| Dividende \| = \| Diviseur \* Quotient \| + \| Reste \|
		\|:----------:\|:----:\|:---------------------:\|:---:\|:-------:\|
		\| 35 \| = \| 60 \* 0 \| + \| 35 \|
		\| 60 \| = \| 35 \* 1 \| + \| 25 \|
		\| 35 \| = \| 25 \* 1 \| + \| 10 \|
		\| 25 \| = \| 10 \* 2 \| + \| 5 \|
		\| 10 \| = \| 5 \* 2 \| + \| 0 \|

		> > => PGCD = 5


		## Exercice : Montrer que `PGCD(M,N)PPCM(M,N) = MN`

		- Utiliser la décomposition en facteurs 1<sup>er<sup/>

		## Type composé : tableaux statiques à une dimension

		- Collection ordonnée d'objets de même type dont le nombre est connu à la compilation
		- La taille d'un tableau statique ne peut pas changer en cours d'exécution
		- Allocation contiguë en mémoire et sur la pile

		```C
		int entiers[] = {1,2,3,4,5};
		int tab[3];
		```
		- Accès aux éléments d’un tableau via l’opérateur `[index]` où `index` est l’indice de l’élément à accéder, `index` va de 0 à la taille du tableau moins un
		```C
		int premier = entiers[0];
		int dernier = entiers[4];
		```
		> Attention! L'accès à un indice hors de l'intervalle zéro à la taille du tableau moins un ne produit pas d'erreur à la compilation, mais possible à l'exécution.

		- Tableau de nombres flottants
		```C
		const int SIZE = 13;
		float tab[SIZE];
		```

		- Initialisation d'un tableau de floats avec `i*i`, puis avec des nombres aléatoires
		```C
		for (int i=0;i<SIZE;i++) {
		tab[i] = (float)rand()/(float)(RAND_MAX) ;
		}
		```
		- Recherche d'un indice de la valeur minimale d'un tableau de floats et permutation avec l'élément en 1<sup>ère</sup> position
		- Répétition de l'opération précédente sur des tranches du tableau
		- Tri par sélection avec illustration sur un exemple
		- Algorithme de vérification que deux mots sont des anagrammes en utilisant un tri

lessons/contenu_cours_3.md

0 → 100644

+108 −0

Original line number	Diff line number	Diff line
		# Algorithmes et structures de données 2020-21

		Contenu du cours 3 du 30.09.2020

		*****

		## Tableaux à deux dimensions

		- Image noir et blanc avec des booléens : initialisation
		```C
		int n = 8, m = 8;
		bool image_nb[n][m];
		for (int i=0;i<n;i++) {
		for (int j=0;j<m;j++) {
		image_nb[i][j] = true;
		}
		}
		```
		- Image en niveaux de gris : initialisation
		```C
		int n = 8, m = 8;
		int image_gris[n][m];
		for (int i=0;i<n;i++) {
		for (int j=0;j<m;j++) {
		image_gris[i][j] = rand()%256;
		}
		}
		```
		>
		* Négatif d'une image à 256 niveaux de gris
		- Appliquer à chaque pixel l'opération `pixel = 255 - pixel`
		```C
		for (int i=0;i<n;i++) {
		for (int j=0;j<m;j++) {
		image_gris[i][j] = 255 - image_gris[i][j];
		}
		}

		```

		## Type énuméré

		- On définit un type énuméré `semaine, coin, mois, couleur, direction` en énumérant toutes ses valeurs possibles.
		Explicitement

		```C
		enum semaine {lu,ma,me,je,ve,sa,di};
		enum coin {cinq_cts=5,dix_cts=10,vingt_cts=20,euro=100};
		enum mois {
		jan=1,feb,mar,apr,mai,jun,jul,aug,sep,oct,nov,dec
		};
		enum couleur {RED,GREEN,BLUE};
		enum direction {EST=2,OUEST=3,NORD=0,SUD=1};
		```

		> Les valeurs d’un type énuméré peuvent être considérées comme des entiers.
		Sans précision particulière, le premier élément correspond à 0 et les suivants à 1, 2, etc.
		Sinon on peut explicitement spécifier des valeurs.
		Rien n’empêche d'attribuer plusieurs fois le même nombre.

		## Opérateur de contrôle `switch`

		- Comparaison entre une valeur et un ensemble de choix pour sélectionner une action à effectuer. Toutes les possibilités doivent être prises en compte.

		```C
		void main() {
		type data = id1;
		int val;
		switch(data) {
		case ID1: val = data+1; break;
		case ID2: val = data*2; break;
		case ID3: val = data/3.0; break;
		};
		println!(\"val =%d\\n\",val);
		}
		```

		## Exemple de la « couverture de la reine »

		```C
		enum piece {SAFE,VULN,QUEEN};
		int size = 8;
		piece board[size][size];
		// initialisation de l'échiquier
		for (int i=0;i<size;i++) {
		for (int j=0;j<size;j++) {
		board[i][j] = SAFE;
		}
		}
		int pos_reine[] = {3,4};
		// couverture sans les diagonales !!!
		for (int k=0;k<size;k++) {
		board[k][pos_reine[1]] = VULN;
		board[pos_reine[0]][k] = VULN;
		}
		board[pos_reine[0]][pos_reine[1]] = QUEEN;
		```

		## Matrices

		1. Tableau 2D de nombres

		2. Opérations arithmétiques
		1. Addition : `C = A+B`
		2. Soustraction : `C = A-B`
		3. Multiplication : `C = A*B` (produit lignes/colonnes)
		4. Puissance entière : `C = A`<sup>n</sup>

lessons/contenu_cours_4.md

0 → 100644

+126 −0

Original line number	Diff line number	Diff line
		# Algorithmes et structures de données 2020-21

		Contenu du cours 4 du 7.10.2020

		*****

		## Crible d’Eratosthène

		- Retour sur les tableaux à 1 dimension

		## Type article (enregistrement, record) : `struct`

		- Un article permet de regrouper des types de nature différente (appelés champs) comme composant d'un type composé.

		- Exemples de `struct`:
		```C
		struct fraction {
		int num;
		int den;
		};

		enum mois {
		jan=1,feb,mar,apr,mai,jun,jul,aug,sep,oct,nov,dec
		};
		struct date {
		int day;
		mois month;
		int year;
		}

		enum sexe {FEM, MASC, AUTRE};
		struct employe {
		char nom[80];
		sexe genre;
		int age;
		float salaire;
		}
		```

		## Fonction cube d'un nombre

		```C
		int cube(int x) {
		return xxx;
		}
		```

		## Fonction de parité

		```C
		bool est_pair(int n) {
		return n%2 == 0;
		}
		```

		## Plus Petit Commun Multiple (PPCM)

		- Fonction PPCM: `int ppcm(int n,int m);`

		## Plus Grand Commun Diviseur (PGCD)

		- Fonction PGCD: `nt pgcd(int n,int m);`

		## Paramètres de fonction

		- Dans le langage C, les paramètres des fonctions sont toujours passés par copie.
		Ainsi, la valeur d'une variable passée en paramètre à une fonction n'est pas modifiée,
		puisque c'est une copie de cette variable qui est passée effectivement à la fonction.
		Toutes les manipulations effectuées par la fonction le sont donc sur cette copie.
		Celle-ci est détruite à la fin de l'exécution de la fonction, laissant la variable originelle inchangée.

		- Pour que des modifications puissent subsister après l'exécution, on peut procéder de deux manières :
		1. en retournant une valeur par la fonction ;
		2. en passant en paramètre un pointeur : celui-ci donne accès à une
		zone mémoire hors de la portée (scope) de la fonction, zone qui
		peut donc être modifiée durablement.

		- Fonction d'incrément

		```C
		void sans_effet(int x) {
		x++;
		}
		void increment(int* x) {
		(*x)++;
		}

		void main() {
		int a = 2;
		sans_effet(a);
		printf("a=%d",a); // imprime 2, valeur de a inchangée
		increment(&a);
		printf(\"a=%d\",a); // imprime 3
		}
		```

		## Zones d'allocation mémoire

		- Un programme utilise deux types de zone mémoire lors de son exécution pour stocker les variables : la pile et le tas.
		- A l'exécution d'un programme, les allocations de variables :
		1. sur la pile, sont faites par le système d'exploitation
		- dans ce cas, on parle de variables statiques
		2. sur le tas, sont de la responsabilité de la programmeuse via un appel à la fonction `malloc()`
		- dans ce cas, on parle de variables dynamiques
		- La désallocation d'une variable statique survient lors de la sortie de sa portée (scope) et est donc automatique.
		- Une variable dynamique doit être explicitement désallouée par la programmeuse avec un appel à la fonction `free()`.
		- Il y a parfois une petite confusion entre la zone mémoire où réside un pointeur et celle où se situe l'espace pointé par le pointeur.
		- Par exemple, l’instruction
		`char* ptr_ch = malloc(3*sizeof(char));`
		alloue un espace sur le tas pour 3 caractères, alors que la variable `ptr_ch` est allouée sur la pile.



		## Pseudo-code du tri par sélection

		```
		procedure tri_selection(tableau t[0..n-1])
		begin
		for i = 0 to n-2 do
		ind_min := index_min(t[i..n-1])
		if t[ind_min] ≠ t[i] then
		echanger(t[i],t[ind_min])
		end if
		end for
		end tri_selection
		```

lessons/contenu_cours_5.md

0 → 100644

+126 −0

Original line number	Diff line number	Diff line
		# Algorithmique et structures de données 2020-21

		Contenu du cours 5 du 14.10.2020

		******

		## Le tri par insertion

		- Algorithme appliqué au tableau: 4 7 6 1 2
		- 1ère étape : 4 7 6 1 2
		- trouver la position `pos` de 7 dans le sous-tableau trié à 1 élément : 4
		- décaler de 1 les éléments de la position `pos=1` à la fin du sous-tableau
		- insérer l'élément 7 en position `pos=1`

		- 2ème étape : 4 7 6 1 2
		- trouver la position `pos` de 6 dans le sous-tableau trié à 2 éléments : 4 7
		- décaler de 1 les éléments de la position `pos=1` à la fin du sous-tableau
		- insérer l'élément 6 en position `pos=1`

		- 3ème étape : 4 6 7 1 2
		- trouver la position `pos` de 1 dans le sous-tableau trié à 3 éléments : 4 6 7
		- décaler de 1 les éléments de la position `pos=0` à la fin du sous-tableau
		- insérer l'élément 1 en position `pos=0`

		- 4ème étape : 1 4 6 7 2
		- trouver la position `pos` de 2 dans le sous-tableau trié à 4 éléments : 1 4 6 7
		- décaler de 1 les éléments de la position `pos=1` à la fin du sous-tableau
		- insérer l'élément 2 en position `pos=1`

		- On obtient le tableau trié: 1 2 4 6 7

		## Tri à bulles

		- Algorithme appliqué au tableau 4 7 6 2 1
		- Principe : on parcours le tableau depuis et on permute les éléments successifs s'ils sont dans le désordre
		4 7 6 2 1
		4 7 6 2 1
		4 6 7 2 1
		4 6 2 7 1
		4 6 2 1 7
		A la fin de cette traversée, le plus grand élément se trouve en dernière position.

		- On applique à nouveau ce principe, mais sur le tableau allant de la 1ère à l'avant-dernière case du tableau
		4 6 2 1 7
		4 6 2 1 7
		4 2 6 1 7
		4 2 1 6 7

		- Et ainsi de suite ...

		- En 4 étapes nécessitant 4, puis 3, puis 2, et finalement 1, opérations de comparaison-échange, on obtient un tableau trié.
		Donc en 4+3+2+1 = 5·4/2 = 10 opérations, on a un tableau trié.

		- Plus généralement, un tableau à N éléments se trie en N(N-1)/2 opérations avec le tri à bulles.

		## Type composé : `struct`

		- Exemple des chaînes de caractères

		- On peut définir un type pour les chaînes de caractères en stockant la longueur effective de la chaîne, c'est-à-dire la première occurrence du caractère `\0`
		```C
		struct _chaine {
		char* str;
		int len;
		} chaine;
		```
		- Quelques implémentations de fonctions
		```C
		chaine chaine_build(char* phrase) {
		chaine ch;
		ch.len = length(phrase);
		ch.str = malloc((ch.len+1)*sizeof(char));
		for (int i=0;i<ch.len;i++) {
		ch.str[i] = phrase[i];
		}
		return ch;
		}

		chaine deep_copy(chaine ch) {
		return chaine_build(ch.str);
		}

		// Dangereux, car plusieurs pointeurs
		// sur le même tableau de caractères !!!
		chaine shallow_copy(chaine ch) {
		chaine cpy;
		cpy.len = ch.len;
		cpy.str = ch.str;
		return cpy;
		}

		// Si plusieurs pointeurs sur même tableau de caractères,
		// alors autres pointeurs dessus ne seront pas mis à NULL
		void chaine_free(chaine* ch) {
		if (NULL != ch>str)
		free(ch>str);
		ch>str = NULL;
		}
		ch>len = -1;
		}
		```
		- Illustration

		![Deep vs. shallow copy](./figures/fig_string_deep_shallow_copy.png)


		## Récursivité

		- Exemple de la factorielle : n ! = n·(n-1)·(n-2)·... ·3·2·1 = n·(n-1) !
		Donc fact(n) = n·fact(n-1) (récursivité)
		et fact(1) = 1 (condition d'arrêt)
		```C
		int fact(int n) {
		if (n > 1) {
		return n*fact(n1);
		} else {
		return 1;
		}
		}
		void main() {
		int f = fact(4);
		}
		```

		![Illustration](./figures/fig_recursivite_factorielle.png)

lessons/contenu_cours_6.md

0 → 100644

+97 −0

Original line number	Diff line number	Diff line
		# Algorithmique et structures de données 2020-21

		Contenu du cours 6 du 28.10.2020

		*****

		## Récursivité

		- Exemple de la factorielle : n ! = n·(n-1)·(n-2)·... ·3·2·1 = n·(n-1) !
		Donc fact(n) = n·fact(n-1) (récursivité)
		et fact(1) = 1 (condition d'arrêt)
		```C
		int fact(int n) {
		if (n > 1) {
		return n*fact(n1);
		} else {
		return 1;
		}
		}
		void main() {
		int f = fact(4);
		}
		```

		![Illustration](./figures/fig_recursivite_factorielle.png)

		- Exemple du PGCD
		Algorithme d'Euclide pour le PGCD de 42 et 27

		> 42 = 27·1 + 15
		> 27 = 15·1 + 12
		> 15 = 12·1 + 3
		> 12 = 3·4 + 0
		PGCD(42,27)=PGCD(27,15)=PGCD(15,12)=PGCD(12,3)=3
		```C
		int pgcd(int n,int m) {
		if (n%m > 0) {
		return pgcd(m,n%m);
		} else {
		return m;
		}
		}
		```

		![Illustration de la récursivité pour l'algorithme d'Euclide](./figures/fig_recursivite_pgcd_euclide.png)

		- Exemple de l'écriture binaire
		```C
		void binaire(int n) {
		printf("%d",n%2);
		if (n/2 != 0) {
		binaire(n/2);
		} else {
		printf("\n");
		}
		// printf("%d",n%2);
		}

		Binaire(13); // affiche 1 0 1 1 puis un retour à la ligne`
		```
		> > > $\hspace*{36mm} 2^0 2^1 2^2 2^3$

		![Illustration de la récursivité pour l'écriture binaire](./figures/fig_recursivite_binaire.png)

		- Que se passe-t-il si on décommente le deuxième `printf` ?

		## Exemples et exercices de récursivité

		- Algorithme du PPCM de deux nombres `n` et `m`
		- `ppcm(mult_n,mult_m) = ppcm(mult_n + n, mult_m)`
		si `mult_n < mult_m` (récursivité)
		- `ppcm(mult_n,mult_m) = ppcm(mult_n, mult_m + m)`
		si `mult_n > mult_m` (récursivité)
		- `ppcm(mult_n,mult_m) = mult_n`
		si `mult_n = mult_m` (condition d’arrêt)

		- Puissance indienne
		\begin{align*}
		a^b & = a^{b/2}\cdot a^{b/2} & \textrm{ si $b$ est pair (récursivité)} \\
		a^b & = a^{b-1}\cdot a & \textrm{ si $b$ est impair (récursivité)} \\
		a^0 & = 1 & \textrm{ (condition d’arrêt)}
		\end{align*}

		- Suite de Fibonacci
		\begin{align*}
		a_n & = a_{n-1} + a_{n-2} & \textrm{ (récursivité)} \\
		a_1 & = 1, a_0 = 0 & \textrm{ (condition d’arrêt)}
		\end{align*}

		## Problème des 8-reines

		- Le but du problème des 8 reines est de placer 8 reines d'un jeu d'échecs sur un échiquier de $8 \times 8$ cases sans que les reines ne puissent se menacer mutuellement, conformément aux règles du jeu d'échecs.
		- Ainsi, deux reines ne devraient jamais partager la même rangée, colonne, ou diagonale.
		- Le problème se généralise au placement de N reines sur un échiquier de $N \times N$ cases. Pour $N=8$, il y a 92 solutions
		- Il s'agit d'un exemple classique de problème de backtracking qui se programme avec la récursivité.

		![Problème des 8-reines. Source : wikipedia, https://fr.wikipedia.org/wiki/Problème_des_huit_dames](./figures/fig_recursivite_8_reines.png)
		No newline at end of file

lessons/contenu_cours_applications_piles.md

0 → 100644

+74 −0

Original line number	Diff line number	Diff line
		# Algorithmes et structures de données

		# Deux applications des piles

		*****

		## La transformation infixe $\Leftarrow$ postfixe

		Exemples:

		\| Expression infixe \| \| Expression postfixe \|
		\|-----------------------\|------------------\|---------------------\|
		\| A + B * C \| transformé en \| A B C * + \|
		\| A + (B / C – D ^ E ) \| transformé en \| A B C / D E ^ – + \|


		A chaque opérateur, on associe une priorité, par exemple:

		\| Opérateur \| Priorité \|
		\|-----------\|----------\|
		\| ^ \| 3 \|
		\| *, / \| 2 \|
		\| +, - \| 1 \|


		L'algorithme utilise une pile dans laquelle on stocke les opérateurs et les parenthèses ouvertes
		rencontrées dans l'expression.

		Les étapes sont les suivantes :

		1. Examiner le prochain caractère dans l'expression donnée.
		2. Si c'est un opérande, le mettre directement dans l'expression du résultat.
		3. Si c'est une parenthèse ouverte, la mettre dans la pile avec la priorité zéro.
		4. Si c'est un opérateur, comparer sa priorité avec celle de l'élément au sommet de la pile:
		* Si la priorité de l'opérateur est plus grande que l'opérateur du sommet de la pile, empiler ce nouvel opérateur.
		* Sinon prendre l'opérateur du sommet de la pile, le mettre dans l'expression du résultat et répéter la comparaison avec le nouveau sommet de la pile, jusqu'à ce qu'un opérateur de priorité inférieure à celle de l'opérateur de l'expression apparaisse au sommet de la pile ou jusqu'à ce que la pile soit vide.
		5. Si c'est une parenthèse fermée, enlever de la pile les opérateurs et les placer dans l'expression du résultat jusqu'à ce qu'une parenthèse ouverte apparaisse au sommet de la pile, se défaire de cette parenthèse.
		6. Si l'expression donnée est vide, enlever de la pile les opérateurs restants et les placer dans l'expression du résultat.

		La table ci-dessous montre la réalisation d'une transformation infixe - postfixe sur une expression algébrique (supposée syntaxiquement correcte):

		![Exemple de transformation infixe-postfixe](./figures/fig_transf_infixe_postfixe.png)

		Remarque: On utilise aussi d'autres structures de données pour traiter ce problème. Entre autres les arbres.

		## L'évaluation d'une expression en notation postfixée

		La manière la plus simple de procéder est d'utiliser une pile contenant à chaque instant les valeurs des opérandes déjà calculés.

		Dans une expression donnée sous forme postfixée, chaque opérateur porte sur les opérandes qui le précédent immédiatement, ceux ci doivent toujours se trouver en tête de pile au moment de l'opération. Le résultat d'une opération est un nouvel opérande qui est remis au sommet de la pile pour la suite de l'évaluation.

		Les règles d'évaluation sont les suivantes:

		* la valeur d'un opérande est toujours empilée.
		* Un opérateur s'applique toujours aux 2 opérandes en tête de pile.
		* Le résultat de l'opération est remis en tête de pile.

		Exemple:

		Soit l'expression postfixe à évaluer: A B C + * D -

		\| Caractères lus \| Pile des opérandes (nombres) \|
		\|----------------\|------------------------------\|
		\| A \| A \|
		\| B \| A, B \|
		\| C \| A, B, C \|
		\| + \| A, B+C \|
		\| * \| A*(B+C) \|
		\| D \| A*(B+C), D \|
		\| A \| *(B+C)-D \|

		La pile contient finalement la valeur de l'expression.

		Ce traitement exige naturellement que l'expression à évaluer soit syntaxiquement correcte.
		No newline at end of file

lessons/contenu_cours_struct_pile.md

0 → 100644

+35 −0

Original line number	Diff line number	Diff line
		# Algorithmes et structures de données

		# Structure de pile

		*****

		## 1. Définition
		Une pile est une structure de données dans laquelle la dernière information entrée, est la première à ressortir (en anglais : LIFO, Last In First Out)

		On envisage deux types d'implémentation de piles:

		1. l'une à capacité limitée (piles dénommées statiques);
		2. l'autre à capacité « infinie » (piles dénommées dynamiques dont la capacité limite dépend en réalité de la mémoire disponible).

		## 2. Spécification de la structure
		Le type des éléments qu'on empile, n'étant pas précisé, on parle de spécification générique.

		Les opérations possibles sur une pile en définissent l'interface :

		* Opérations de manipulation
		* Empiler un nouvel élément sur la pile
		* Dépiler l'élément au sommet de la pile (i.e. le dernier élément introduit)

		* Fonctions de consultation
		* Lire l'élément au sommet de la pile
		* Tester si la pile est vide
		* Tester si la pile a atteint la capacité maximale, seulement dans le cas d'une pile statique
		* L'interface de la pile est l'ensemble des fonctionnalités offertes à l'utilisateur pour interagir avec une pile

		## 3. Quelques applications des piles
		* Gérer les mécanismes internes de mise en œuvre de la récursivité
		* Traiter les structures imbriquées
		* Implémenter les machines abstraites
		* Passer les paramètres aux procédures
		* Sauver l'état d'un processus
		No newline at end of file

lessons/contenu_cours_struct_queue.md

0 → 100644

+113 −0

Original line number	Diff line number	Diff line
		# Algorithmes et structures de données

		# Structure de file d'attente

		*****

		## 1. Définition

		Une file d'attente ou queue est une structure de données dans laquelle la première information entrée est la première à ressortir (en anglais : FIFO, First In First Out)

		On considère ici une implémentation de queue dynamique et donc à capacité « infinie » (dépend en réalité de la mémoire disponible).

		## 2. Spécification de la structure

		Si le type des éléments qu'on insère, n'est pas précisé, on parle de spécification générique.

		Les opérations possibles sur une file d'attente (ou queue) en définissent l'interface :

		* Opérations de manipulation
		* Créer une liste vide
		* Détruire une liste
		* Insérer un nouvel élément en queue de la file d'attente
		* Extraire un élément en tête de la file d'attente (i.e. le premier élément introduit)
		*
		* Fonctions de consultation
		* Lire l'élément en tête de la file d'attente
		* Lire l'élément en queue de la file d'attente
		* Tester si la file d'attente est vide

		L'interface de la file d'attente est l'ensemble des fonctionnalités offertes à l'utilisateur pour interagir
		avec celle-ci.

		## 3. Structure de file d'attente

		On considère une liste chaînée d'articles avec deux pointeurs de tête et de queue. Chaque article comportera un champ pour stocker les valeurs dans cette liste et un champ contenant une variable de type accès pour assurer le chaînage. On considère à titre d'exemple le cas de valeurs entières.

		Schématiquement:

		![Illustration d'une file d'attente](./figures/fig_queue_representation.png)

		L'accès à la file d'attente se fera par les pointeurs de tête et de queue.

		Une telle file d'attente basée sur une liste chaînée sera déclarée par exemple sous la forme suivante:

		```C
		struct _element { // Elément de liste
		int data;
		struct _element* next;
		} element;

		struct _queue { // File d'attente:
		element* tete; // tête de file d'attente
		element* debut; // queue de file d'attente
		}
		```

		## 4. Implémentation des fonctionnalité d'une file d'attente

		### a) Consultations

		On considère la fonction queue_est_vide qui teste si la file d'attente est vide et les fonctions `queue_tete` et `queue_debut` qui retournent l'élément en tête, respectivement en queue, de la file d'attente.

		```C
		bool queue_est_vide(queue fa) {
		return (NULL == fa.tete && NULL == fa.debut);
		}

		int queue_tete(queue fa) {
		assert(!queue_est_vide(fa));
		return fa.tete>data;
		}

		int queue_debut(queue fa) {
		assert(!queue_est_vide(fa));
		return fa.debut>data;
		}
		```

		### b) Manipulations

		#### Insertion en queue de file d'attente

		Voici l'entête de la fonction: `void queue_inserer(queue* fa,int val);`

		Il faut considérer plusieurs cas:

		* La file d'attente est vide

		![Insertion dans une file d'attente vide](./figures/fig_empty_queue_insert.png)

		* L'insertion se fait en queue d'une file d'attente non vide

		![Insertion dans une file d'attente non-vide](./figures/fig_non_empty_queue_insert.png)

		#### Extraction en tête de file d'attente

		Voici l'entête de la procédure: `int queue_extraire(queue* fa);`

		On commence par récupérer, la valeur en tête de file d'attente via l'appel `queue_tete(*fa);`

		Puis on met un pointeur temporaire sur l'élément en tête, avant de déplacer le pointeur de tête sur l'élément suivant.
		Finalement, on désalloue la mémoire

		![Extraction d'une file d'attente](./figures/fig_queue_extract.png)

		Si la file d'attente n'avait qu'un seul élément, alors il faudrait mettre le pointeur `fa->debut` à `NULL`.
		Dans ce cas, à la suite du point (3), le pointeur `fa->tete` se retrouve à `NULL`. On doit donc ajouter l'instruction :

		```C
		if (NULL == fa>tete) {
		fa>debut = NULL;
		}
		```

lessons/contenu_cours_struct_sorted_list.md

0 → 100644

+206 −0

Original line number	Diff line number	Diff line
		# Algorithmes et structures de données

		# Structure de liste triée

		*****

		## 1. Définition

		On considère une liste chaînée d'articles. Chaque article comportera un champ pour stocker les valeurs
		dans la liste et un champ contenant une variable de type pointeur pour assurer le chaînage.
		Schématiquement:

		![Illustration d'une file d'attente](./figures/fig_queue_representation.png)

		La liste est triée pour autant que l'insertion de chaque nouvelle valeur dans la liste maintienne cette
		propriété.
		L'accès à la liste se fera uniquement par le pointeur lst qui référence le début de la liste.
		Une telle liste chaînée sera déclarée par exemple sous la forme suivante:

		```C
		typedef struct _element { // Elément de liste
		int n;
		struct _element* suivant;
		} element;

		typedef element* liste; // Pointeur sur des éléments de liste
		```

		## 2. Insertion dans une liste triée

		Voici l'entête de la procédure : `liste inserer(liste lst,int val);`

		Il faut considérer plusieurs cas.

		### La liste est vide: `lst == NULL`

		![Insertion dans une liste triée vide](./figures/fig_empty_sorted_list_insert.png)

		### L'insertion se fait en 1ère position: `val <= lst->n`

		Par exemple, pour `val = 1`

		![Insertion en 1ère position d'une liste triée](./figures/fig_1st_position_sorted_list_insert.png)

		### Les positions autres que la 1ère position

		Par exemple, pour `val = 13`

		![Insertion aux autres positions d'une liste triée](./figures/fig_other_position_sorted_list_insert.png)

		```C
		(1) tmp = malloc(sizeof(element));
		tmp->n = 13;
		```

		On déplace un pointeur crt jusqu'à l'élément précédent la position d'insertion de sorte que
		```C
		crt->n < val <= crt->suivant->n
		```

		On utilise une boucle:
		```C
		(2) while (NULL != crt->suivant && val > crt->suivant->n) {
		crt = crt->suivant;
		}
		```

		Puis on raccroche l'élément pointé par tmp à la liste
		```C
		(3) tmp->suivant = crt->suivant;
		(4) crt->suivant = tmp;
		return lst;
		```

		## 3. Extraction d'un élément dans une liste triée

		Voici l'entête de la procédure : `liste extraire(liste lst,int val);`

		Si la liste est vide, on retourne la liste vide.

		Ensuite, on déplace deux pointeurs prec et crt à travers la liste jusqu'à ce que : `prec->n < val <= crt->n`

		On utilise une boucle:
		```C
		while (NULL != crt && val > crt->n) {
		prec = crt;
		crt = crt->suivant;
		}
		```

		Il faut à nouveau considérer plusieurs cas.

		### La valeur à retirer est supérieure à la dernière valeur de la liste.

		Ceci équivaut à: `crt == NULL` ou `prec->suivant == NULL`

		On retourne la liste inchangée.

		Par exemple, pour `val = 30`

		![Extraction d'une valeur supérieure à la dernière valeur d'une liste triée](./figures/fig_greater_value_sorted_list_extract.png)

		### La valeur à retirer n'est pas celle dans l'élément pointé par `crt`.

		Ceci équivaut à: `val < crt->n`

		On retourne la liste inchangée.

		Par exemple, pour `val = 9`

		![Extraction d'une valeur pas dans une liste triée (1)](./figures/fig_no_value_sorted_list_extract_1.png)

		ou pour val = 1

		![Extraction d'une valeur pas dans une liste triée (2)](./figures/fig_no_value_sorted_list_extract_2.png)

		### La valeur à retirer est celle dans l'élément pointé par `crt`.

		Ceci équivaut à: `val == crt->n`

		#### La valeur à retirer est en début de liste.

		Ceci équivaut à: `crt == prec`

		On doit déplacer la tête de liste : lst = crt->suivant;

		Par exemple, pour `val = 3`

		![Extraction d'une valeur en début de liste triée ](./figures/fig_1st_element_sorted_list_extract.png)

		#### La valeur à retirer n'est pas en début de liste.

		On doit raccrocher l'élément pointé par prec à celui suivant `crt`: `prec->suivant = crt->suivant;`

		Par exemple, pour `val = 12`

		![Extraction d'une valeur pas en début de liste triée](./figures/fig_other_element_sorted_list_extract_1.png)

		ou pour `val = 21`

		![Extraction d'une valeur pas dans une liste triée (1)](./figures/fig_other_element_sorted_list_extract_2.png)

		Finalement, on libère la mémoire de l'élément pointé par `crt`: `free(crt);`

		![Extraction d'une valeur pas dans une liste triée (1)](./figures/fig_free_element_sorted_list_extract.png)

		## 4. Recherche dans une liste triée

		La fonction recherche retourne un pointeur sur l'élément qui contient la valeur recherchée ou un pointeur `NULL` si la valeur est absente de la liste triée.

		Voici l'entête de la procédure : `element* recherche(liste lst,int val);`

		On considère d'abord la fonction utilitaire `position` qui retourne un pointeur sur l'élément avant la
		position d'insertion d'une valeur ou un pointeur `NULL` s'il s'agit de la tête de liste.
		```C
		element* position(liste lst,int val) {
		element* pos = lst;
		if (est_vide(lst) \|\| val <= lst->n) {
		pos = NULL;
		} else {
		while (NULL != pos->suivant && val > pos->suivant->n) {
		pos = pos->suivant;
		}
		}
		return pos;
		}
		```

		Par exemple, pour val = 1 ou 3

		![Recherche d'une valeur en début de liste triée](./figures/fig_1st_element_sorted_list_search.png)

		et pour val = 29

		![Recherche d'une valeur en fin de liste triée](./figures/fig_last_element_sorted_list_search.png)

		et finalement pour val = 10 ou 12

		![Recherche d'une valeur en milieu de liste triée](./figures/fig_other_element_sorted_list_search.png)

		Ainsi, la fonction de recherche s'écrit simplement :
		```C
		element* recherche(liste lst,int val) {
		element* pos = position(lst,val);
		if (est_vide(lst)) {
		return NULL;
		}
		if (NULL == pos && val == lst->n) {
		return lst;
		} else if (NULL != pos->suivant && val == pos->suivant->n) {
		return pos->suivant;
		} else {
		return NULL;
		}
		}
		```

		## Exercice

		Ecrire directement la fonction `recherche` sans utiliser la fonction `position`.
		Faire les dessins illustrant les différents cas possibles.

lessons/figures/fig_1st_element_sorted_list_extract.png

0 → 100644

+9.01 KiB

9.01 KiB

lessons/figures/fig_1st_element_sorted_list_search.png

0 → 100644

+43.3 KiB

43.32 KiB

lessons/figures/fig_1st_position_sorted_list_insert.png

0 → 100644

+20.5 KiB

20.47 KiB

lessons/figures/fig_empty_queue_insert.png

0 → 100644

+19.8 KiB

19.76 KiB

lessons/figures/fig_empty_sorted_list_insert.png

0 → 100644

+12.7 KiB

12.69 KiB

lessons/figures/fig_free_element_sorted_list_extract.png

0 → 100644

+109 KiB

109.42 KiB

lessons/figures/fig_greater_value_sorted_list_extract.png

0 → 100644

+6.73 KiB

6.73 KiB

lessons/figures/fig_last_element_sorted_list_search.png

0 → 100644

+31.1 KiB

31.08 KiB

lessons/figures/fig_no_value_sorted_list_extract_1.png

0 → 100644

+6.44 KiB

6.44 KiB

lessons/figures/fig_no_value_sorted_list_extract_2.png

0 → 100644

+6.91 KiB

6.91 KiB

lessons/figures/fig_non_empty_queue_insert.png

0 → 100644

+29.3 KiB

29.32 KiB

lessons/figures/fig_other_element_sorted_list_extract_1.png

0 → 100644

+116 KiB

115.64 KiB

lessons/figures/fig_other_element_sorted_list_extract_2.png

0 → 100644

+113 KiB

113.13 KiB

lessons/figures/fig_other_element_sorted_list_search.png

0 → 100644

+38.3 KiB

38.27 KiB

lessons/figures/fig_other_position_sorted_list_insert.png

0 → 100644

+12 KiB

12.00 KiB

lessons/figures/fig_queue_extract.png

0 → 100644

+23.7 KiB

23.68 KiB

lessons/figures/fig_queue_representation.png

0 → 100644

+7.08 KiB

7.08 KiB

lessons/figures/fig_recursivite_8_reines.png

0 → 100644

+10.9 KiB

10.89 KiB

lessons/figures/fig_recursivite_binaire.png

0 → 100644

+32.7 KiB

32.67 KiB

lessons/figures/fig_recursivite_factorielle.png

0 → 100644

+78.3 KiB

78.35 KiB

lessons/figures/fig_recursivite_pgcd_euclide.png

0 → 100644

+121 KiB

121.40 KiB

lessons/figures/fig_string_deep_shallow_copy.png

0 → 100644

+22.3 KiB

22.32 KiB

lessons/figures/fig_transf_infixe_postfixe.png

0 → 100644

+69.7 KiB

69.69 KiB

lessons/tris/figures/arbre_tab.eps

0 → 100644

+405 −0

Original line number	Diff line number	Diff line
		%!PS-Adobe-3.0 EPSF-3.0
		%%Title: arbre_tab.fig
		%%Creator: fig2dev Version 3.2 Patchlevel 5e
		%%CreationDate: Thu Dec 27 00:07:59 2018
		%%BoundingBox: 0 0 511 506
		%Magnification: 1.0000
		%%EndComments
		%%BeginProlog
		/$F2psDict 200 dict def
		$F2psDict begin
		$F2psDict /mtrx matrix put
		/col-1 {0 setgray} bind def
		/col0 {0.000 0.000 0.000 srgb} bind def
		/col1 {0.000 0.000 1.000 srgb} bind def
		/col2 {0.000 1.000 0.000 srgb} bind def
		/col3 {0.000 1.000 1.000 srgb} bind def
		/col4 {1.000 0.000 0.000 srgb} bind def
		/col5 {1.000 0.000 1.000 srgb} bind def
		/col6 {1.000 1.000 0.000 srgb} bind def
		/col7 {1.000 1.000 1.000 srgb} bind def
		/col8 {0.000 0.000 0.560 srgb} bind def
		/col9 {0.000 0.000 0.690 srgb} bind def
		/col10 {0.000 0.000 0.820 srgb} bind def
		/col11 {0.530 0.810 1.000 srgb} bind def
		/col12 {0.000 0.560 0.000 srgb} bind def
		/col13 {0.000 0.690 0.000 srgb} bind def
		/col14 {0.000 0.820 0.000 srgb} bind def
		/col15 {0.000 0.560 0.560 srgb} bind def
		/col16 {0.000 0.690 0.690 srgb} bind def
		/col17 {0.000 0.820 0.820 srgb} bind def
		/col18 {0.560 0.000 0.000 srgb} bind def
		/col19 {0.690 0.000 0.000 srgb} bind def
		/col20 {0.820 0.000 0.000 srgb} bind def
		/col21 {0.560 0.000 0.560 srgb} bind def
		/col22 {0.690 0.000 0.690 srgb} bind def
		/col23 {0.820 0.000 0.820 srgb} bind def
		/col24 {0.500 0.190 0.000 srgb} bind def
		/col25 {0.630 0.250 0.000 srgb} bind def
		/col26 {0.750 0.380 0.000 srgb} bind def
		/col27 {1.000 0.500 0.500 srgb} bind def
		/col28 {1.000 0.630 0.630 srgb} bind def
		/col29 {1.000 0.750 0.750 srgb} bind def
		/col30 {1.000 0.880 0.880 srgb} bind def
		/col31 {1.000 0.840 0.000 srgb} bind def

		end

		/cp {closepath} bind def
		/ef {eofill} bind def
		/gr {grestore} bind def
		/gs {gsave} bind def
		/sa {save} bind def
		/rs {restore} bind def
		/l {lineto} bind def
		/m {moveto} bind def
		/rm {rmoveto} bind def
		/n {newpath} bind def
		/s {stroke} bind def
		/sh {show} bind def
		/slc {setlinecap} bind def
		/slj {setlinejoin} bind def
		/slw {setlinewidth} bind def
		/srgb {setrgbcolor} bind def
		/rot {rotate} bind def
		/sc {scale} bind def
		/sd {setdash} bind def
		/ff {findfont} bind def
		/sf {setfont} bind def
		/scf {scalefont} bind def
		/sw {stringwidth} bind def
		/tr {translate} bind def
		/tnt {dup dup currentrgbcolor
		4 -2 roll dup 1 exch sub 3 -1 roll mul add
		4 -2 roll dup 1 exch sub 3 -1 roll mul add
		4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb}
		bind def
		/shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul
		4 -2 roll mul srgb} bind def
		/DrawEllipse {
		/endangle exch def
		/startangle exch def
		/yrad exch def
		/xrad exch def
		/y exch def
		/x exch def
		/savematrix mtrx currentmatrix def
		x y tr xrad yrad sc 0 0 1 startangle endangle arc
		closepath
		savematrix setmatrix
		} def

		/$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def
		/$F2psEnd {$F2psEnteredState restore end} def

		/pageheader {
		save
		newpath 0 506 moveto 0 0 lineto 511 0 lineto 511 506 lineto closepath clip newpath
		-12.6 554.5 translate
		1 -1 scale
		$F2psBegin
		10 setmiterlimit
		0 slj 0 slc
		0.06000 0.06000 sc
		} bind def
		/pagefooter {
		$F2psEnd
		restore
		} bind def
		%%EndProlog
		pageheader
		%
		% Fig objects follow
		%
		%
		% here starts figure with depth 50
		% Ellipse
		15.000 slw
		n 1200 3600 300 300 0 360 DrawEllipse gs col0 s gr

		% Ellipse
		n 2400 2400 300 300 0 360 DrawEllipse gs col0 s gr

		% Ellipse
		n 3600 3600 300 300 0 360 DrawEllipse gs col0 s gr

		% Polyline
		0 slj
		0 slc
		n 1200 3285 m
		2175 2580 l gs col0 s gr
		% Polyline
		n 3600 3300 m
		2640 2580 l gs col0 s gr
		% Ellipse
		n 6007 3592 300 300 0 360 DrawEllipse gs col0 s gr

		% Ellipse
		n 7207 2392 300 300 0 360 DrawEllipse gs col0 s gr

		% Ellipse
		n 8407 3592 300 300 0 360 DrawEllipse gs col0 s gr

		% Polyline
		n 6007 3277 m
		6982 2572 l gs col0 s gr
		% Polyline
		n 8407 3292 m
		7447 2572 l gs col0 s gr
		% Ellipse
		n 600 4800 300 300 0 360 DrawEllipse gs col0 s gr

		% Ellipse
		n 1800 4800 300 300 0 360 DrawEllipse gs col0 s gr

		% Ellipse
		n 3000 4800 300 300 0 360 DrawEllipse gs col0 s gr

		% Ellipse
		n 4800 1200 300 300 0 360 DrawEllipse gs col0 s gr

		% Polyline
		n 1046 3837 m
		566 4512 l gs col0 s gr
		% Polyline
		n 1380 3840 m
		1815 4500 l gs col0 s gr
		% Polyline
		n 3450 3855 m
		3015 4515 l gs col0 s gr
		% Polyline
		n 7215 2085 m
		5055 1350 l gs col0 s gr
		% Polyline
		n 2400 2085 m
		4545 1365 l gs col0 s gr
		% Polyline
		n 1725 7275 m 2325 7275 l 2325 7875 l 1725 7875 l
		cp gs col0 s gr
		% Polyline
		n 2325 7275 m 2925 7275 l 2925 7875 l 2325 7875 l
		cp gs col0 s gr
		% Polyline
		n 2925 7275 m 3525 7275 l 3525 7875 l 2925 7875 l
		cp gs col0 s gr
		% Polyline
		n 3525 7275 m 4125 7275 l 4125 7875 l 3525 7875 l
		cp gs col0 s gr
		% Polyline
		n 4125 7275 m 4725 7275 l 4725 7875 l 4125 7875 l
		cp gs col0 s gr
		% Polyline
		n 4725 7275 m 5325 7275 l 5325 7875 l 4725 7875 l
		cp gs col0 s gr
		% Polyline
		n 5325 7275 m 5925 7275 l 5925 7875 l 5325 7875 l
		cp gs col0 s gr
		% Polyline
		n 5925 7275 m 6525 7275 l 6525 7875 l 5925 7875 l
		cp gs col0 s gr
		% Polyline
		n 6525 7275 m 7125 7275 l 7125 7875 l 6525 7875 l
		cp gs col0 s gr
		% Polyline
		n 7125 7275 m 7725 7275 l 7725 7875 l 7125 7875 l
		cp gs col0 s gr
		% Polyline
		n 1725 6975 m 2325 6975 l 2325 7275 l 1725 7275 l
		cp gs col0 s gr
		% Polyline
		n 2325 6975 m 2925 6975 l 2925 7275 l 2325 7275 l
		cp gs col0 s gr
		% Polyline
		n 2925 6975 m 3525 6975 l 3525 7275 l 2925 7275 l
		cp gs col0 s gr
		% Polyline
		n 3525 6975 m 4125 6975 l 4125 7275 l 3525 7275 l
		cp gs col0 s gr
		% Polyline
		n 4125 6975 m 4725 6975 l 4725 7275 l 4125 7275 l
		cp gs col0 s gr
		% Polyline
		n 4725 6975 m 5325 6975 l 5325 7275 l 4725 7275 l
		cp gs col0 s gr
		% Polyline
		n 5325 6975 m 5925 6975 l 5925 7275 l 5325 7275 l
		cp gs col0 s gr
		% Polyline
		n 5925 6975 m 6525 6975 l 6525 7275 l 5925 7275 l
		cp gs col0 s gr
		% Polyline
		n 6525 6975 m 7125 6975 l 7125 7275 l 6525 7275 l
		cp gs col0 s gr
		% Polyline
		n 7125 6975 m 7725 6975 l 7725 7275 l 7125 7275 l
		cp gs col0 s gr
		% Arc
		gs clippath
		2268 6698 m 2428 7015 l 2535 6961 l 2376 6644 l 2376 6644 l 2457 6940 l 2268 6698 l cp
		eoclip
		n 2175.0 6975.0 300.0 180.0000 0.0000 arc
		gs col0 s gr
		gr

		% arrowhead
		n 2268 6698 m 2457 6940 l 2376 6644 l 2349 6725 l 2268 6698 l
		cp gs 0.00 setgray ef gr col0 s
		% Arc
		gs clippath
		2939 6657 m 3019 7003 l 3136 6976 l 3056 6630 l 3056 6630 l 3066 6936 l 2939 6657 l cp
		eoclip
		n 2475.0 6975.0 600.0 180.0000 0.0000 arc
		gs col0 s gr
		gr

		% arrowhead
		n 2939 6657 m 3066 6936 l 3056 6630 l 3011 6702 l 2939 6657 l
		cp gs 0.00 setgray ef gr col0 s
		% Arc
		gs clippath
		4754 6651 m 4818 7000 l 4936 6978 l 4872 6630 l 4872 6630 l 4868 6936 l 4754 6651 l cp
		eoclip
		n 4125.0 6975.0 750.0 180.0000 0.0000 arc
		gs col0 s gr
		gr

		% arrowhead
		n 4754 6651 m 4868 6936 l 4872 6630 l 4824 6699 l 4754 6651 l
		cp gs 0.00 setgray ef gr col0 s
		% Arc
		gs clippath
		5371 6646 m 5417 6997 l 5536 6982 l 5490 6630 l 5490 6630 l 5470 6936 l 5371 6646 l cp
		eoclip
		n 4425.0 6975.0 1050.0 180.0000 0.0000 arc
		gs col0 s gr
		gr

		% arrowhead
		n 5371 6646 m 5470 6936 l 5490 6630 l 5438 6698 l 5371 6646 l
		cp gs 0.00 setgray ef gr col0 s
		% Arc
		gs clippath
		4068 8207 m 4033 7854 l 3913 7866 l 3949 8219 l 3949 8219 l 3979 7915 l 4068 8207 l cp
		eoclip
		n 5325.0 7875.0 1350.0 180.0000 0.0000 arcn
		gs col0 s gr
		gr

		% arrowhead
		n 4068 8207 m 3979 7915 l 3949 8219 l 4002 8153 l 4068 8207 l
		cp gs 0.00 setgray ef gr col0 s
		% Arc
		gs clippath
		4078 8203 m 4032 7852 l 3913 7867 l 3959 8219 l 3959 8219 l 3980 7914 l 4078 8203 l cp
		eoclip
		n 5025.0 7875.0 1050.0 180.0000 0.0000 arcn
		gs col0 s gr
		gr

		% arrowhead
		n 4078 8203 m 3980 7914 l 3959 8219 l 4011 8151 l 4078 8203 l
		cp gs 0.00 setgray ef gr col0 s
		% Arc
		gs clippath
		2895 8198 m 2831 7849 l 2713 7871 l 2777 8219 l 2777 8219 l 2782 7914 l 2895 8198 l cp
		eoclip
		n 3525.0 7875.0 750.0 180.0000 0.0000 arcn
		gs col0 s gr
		gr

		% arrowhead
		n 2895 8198 m 2782 7914 l 2777 8219 l 2825 8150 l 2895 8198 l
		cp gs 0.00 setgray ef gr col0 s
		% Arc
		gs clippath
		2934 8181 m 2827 7842 l 2713 7878 l 2819 8217 l 2819 8217 l 2787 7913 l 2934 8181 l cp
		eoclip
		n 3225.0 7875.0 450.0 180.0000 0.0000 arcn
		gs col0 s gr
		gr

		% arrowhead
		n 2934 8181 m 2787 7913 l 2819 8217 l 2858 8141 l 2934 8181 l
		cp gs 0.00 setgray ef gr col0 s
		% Arc
		gs clippath
		7181 6642 m 7216 6995 l 7336 6983 l 7300 6630 l 7300 6630 l 7271 6935 l 7181 6642 l cp
		eoclip
		n 5925.0 6975.0 1350.0 180.0000 0.0000 arc
		gs col0 s gr
		gr

		% arrowhead
		n 7181 6642 m 7271 6935 l 7300 6630 l 7247 6696 l 7181 6642 l
		cp gs 0.00 setgray ef gr col0 s
		/Times-Roman ff 333.33 scf sf
		4350 1050 m
		gs 1 -1 sc (0) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		1875 2250 m
		gs 1 -1 sc (1) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		6675 2250 m
		gs 1 -1 sc (2) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		675 3525 m
		gs 1 -1 sc (3) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		3075 3525 m
		gs 1 -1 sc (4) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		5475 3525 m
		gs 1 -1 sc (5) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		7875 3525 m
		gs 1 -1 sc (6) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		225 4500 m
		gs 1 -1 sc (7) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		1425 4500 m
		gs 1 -1 sc (8) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		2625 4500 m
		gs 1 -1 sc (9) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		1950 7200 m
		gs 1 -1 sc (0) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		2550 7200 m
		gs 1 -1 sc (1) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		3150 7200 m
		gs 1 -1 sc (2) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		3750 7200 m
		gs 1 -1 sc (3) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		4350 7200 m
		gs 1 -1 sc (4) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		4950 7200 m
		gs 1 -1 sc (5) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		5550 7200 m
		gs 1 -1 sc (6) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		6150 7200 m
		gs 1 -1 sc (7) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		6750 7200 m
		gs 1 -1 sc (8) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		7275 7200 m
		gs 1 -1 sc (9) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		3000 8925 m
		gs 1 -1 sc (est fils de) col0 sh gr
		/Times-Roman ff 333.33 scf sf
		3225 5775 m
		gs 1 -1 sc (est parent de) col0 sh gr
		% here ends figure;
		pagefooter
		showpage
		%%Trailer
		%EOF

lessons/tris/figures/arbre_tab.fig

0 → 100644

+131 −0

Original line number	Diff line number	Diff line
		#FIG 3.2 Produced by xfig version 3.2.5c
		Landscape
		Center
		Inches
		Letter
		100.00
		Single
		-2
		1200 2
		6 225 825 8775 5175
		6 885 2085 3915 3915
		1 3 0 2 0 7 50 -1 -1 0.000 1 0.0000 1200 3600 300 300 1200 3600 1200 3900
		1 3 0 2 0 7 50 -1 -1 0.000 1 0.0000 2400 2400 300 300 2400 2400 2400 2700
		1 3 0 2 0 7 50 -1 -1 0.000 1 0.0000 3600 3600 300 300 3600 3600 3600 3900
		2 1 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 2
		1200 3285 2175 2580
		2 1 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 2
		3600 3300 2640 2580
		-6
		6 5625 2025 8775 3975
		1 3 0 2 0 7 50 -1 -1 0.000 1 0.0000 6007 3592 300 300 6007 3592 6007 3892
		1 3 0 2 0 7 50 -1 -1 0.000 1 0.0000 7207 2392 300 300 7207 2392 7207 2692
		1 3 0 2 0 7 50 -1 -1 0.000 1 0.0000 8407 3592 300 300 8407 3592 8407 3892
		2 1 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 2
		6007 3277 6982 2572
		2 1 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 2
		8407 3292 7447 2572
		-6
		1 3 0 2 0 7 50 -1 -1 0.000 1 0.0000 600 4800 300 300 600 4800 600 5100
		1 3 0 2 0 7 50 -1 -1 0.000 1 0.0000 1800 4800 300 300 1800 4800 1800 5100
		1 3 0 2 0 7 50 -1 -1 0.000 1 0.0000 3000 4800 300 300 3000 4800 3000 5100
		1 3 0 2 0 7 50 -1 -1 0.000 1 0.0000 4800 1200 300 300 4800 1200 4800 1500
		2 1 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 2
		1046 3837 566 4512
		2 1 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 2
		1380 3840 1815 4500
		2 1 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 2
		3450 3855 3015 4515
		2 1 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 2
		7215 2085 5055 1350
		2 1 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 2
		2400 2085 4545 1365
		4 0 0 50 -1 0 20 0.0000 4 225 165 4350 1050 0\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 1875 2250 1\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 6675 2250 2\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 675 3525 3\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 3075 3525 4\001
		4 0 0 50 -1 0 20 0.0000 4 240 165 5475 3525 5\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 7875 3525 6\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 225 4500 7\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 1425 4500 8\001
		4 0 0 50 -1 0 20 0.0000 4 240 165 2625 4500 9\001
		-6
		6 1650 5550 7800 9300
		6 1650 5550 7800 9300
		5 1 0 2 0 7 50 -1 -1 0.000 0 0 1 0 2175.000 6975.000 1875 6975 2175 6675 2475 6975
		2 1 2.00 120.00 240.00
		5 1 0 2 0 7 50 -1 -1 0.000 0 0 1 0 2475.000 6975.000 1875 6975 2475 6375 3075 6975
		2 1 2.00 120.00 240.00
		5 1 0 2 0 7 50 -1 -1 0.000 0 0 1 0 4125.000 6975.000 3375 6975 4125 6225 4875 6975
		2 1 2.00 120.00 240.00
		5 1 0 2 0 7 50 -1 -1 0.000 0 0 1 0 4425.000 6975.000 3375 6975 4425 5925 5475 6975
		2 1 2.00 120.00 240.00
		5 1 0 2 0 7 50 -1 -1 0.000 0 1 0 1 5325.000 7875.000 3975 7875 5325 9225 6675 7875
		2 1 2.00 120.00 240.00
		5 1 0 2 0 7 50 -1 -1 0.000 0 1 0 1 5025.000 7875.000 3975 7875 5025 8925 6075 7875
		2 1 2.00 120.00 240.00
		5 1 0 2 0 7 50 -1 -1 0.000 0 1 0 1 3525.000 7875.000 2775 7875 3525 8625 4275 7875
		2 1 2.00 120.00 240.00
		5 1 0 2 0 7 50 -1 -1 0.000 0 1 0 1 3225.000 7875.000 2775 7875 3225 8325 3675 7875
		2 1 2.00 120.00 240.00
		5 1 0 2 0 7 50 -1 -1 0.000 0 0 1 0 5925.000 6975.000 4575 6975 5925 5625 7275 6975
		2 1 2.00 120.00 240.00
		6 1650 6900 7800 7950
		6 1710 7260 7740 7890
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		1725 7275 2325 7275 2325 7875 1725 7875 1725 7275
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		2325 7275 2925 7275 2925 7875 2325 7875 2325 7275
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		2925 7275 3525 7275 3525 7875 2925 7875 2925 7275
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		3525 7275 4125 7275 4125 7875 3525 7875 3525 7275
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		4125 7275 4725 7275 4725 7875 4125 7875 4125 7275
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		4725 7275 5325 7275 5325 7875 4725 7875 4725 7275
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		5325 7275 5925 7275 5925 7875 5325 7875 5325 7275
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		5925 7275 6525 7275 6525 7875 5925 7875 5925 7275
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		6525 7275 7125 7275 7125 7875 6525 7875 6525 7275
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		7125 7275 7725 7275 7725 7875 7125 7875 7125 7275
		-6
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		1725 6975 2325 6975 2325 7275 1725 7275 1725 6975
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		2325 6975 2925 6975 2925 7275 2325 7275 2325 6975
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		2925 6975 3525 6975 3525 7275 2925 7275 2925 6975
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		3525 6975 4125 6975 4125 7275 3525 7275 3525 6975
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		4125 6975 4725 6975 4725 7275 4125 7275 4125 6975
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		4725 6975 5325 6975 5325 7275 4725 7275 4725 6975
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		5325 6975 5925 6975 5925 7275 5325 7275 5325 6975
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		5925 6975 6525 6975 6525 7275 5925 7275 5925 6975
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		6525 6975 7125 6975 7125 7275 6525 7275 6525 6975
		2 2 0 2 0 7 50 -1 -1 0.000 0 0 7 0 0 5
		7125 6975 7725 6975 7725 7275 7125 7275 7125 6975
		4 0 0 50 -1 0 20 0.0000 4 225 165 1950 7200 0\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 2550 7200 1\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 3150 7200 2\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 3750 7200 3\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 4350 7200 4\001
		4 0 0 50 -1 0 20 0.0000 4 240 165 4950 7200 5\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 5550 7200 6\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 6150 7200 7\001
		4 0 0 50 -1 0 20 0.0000 4 225 165 6750 7200 8\001
		4 0 0 50 -1 0 20 0.0000 4 240 165 7275 7200 9\001
		-6
		-6
		4 0 0 50 -1 0 20 0.0000 4 225 1290 3000 8925 est fils de\001
		4 0 0 50 -1 0 20 0.0000 4 300 1695 3225 5775 est parent de\001
		-6

lessons/tris/figures/depart.eps

0 → 100644

+261 −0

Original line number	Diff line number	Diff line
		%!PS-Adobe-2.0 EPSF-2.0
		%%Title: depart.fig
		%%Creator: fig2dev Version 3.2 Patchlevel 4
		%%CreationDate: Mon May 9 11:20:58 2005
		%%For: lazeyras@eig3 (LAZEYRAS Michel - EIG prof)
		%%BoundingBox: 0 0 452 308
		%%Magnification: 1.0000
		%%EndComments
		/$F2psDict 200 dict def
		$F2psDict begin
		$F2psDict /mtrx matrix put
		/col-1 {0 setgray} bind def
		/col0 {0.000 0.000 0.000 srgb} bind def
		/col1 {0.000 0.000 1.000 srgb} bind def
		/col2 {0.000 1.000 0.000 srgb} bind def
		/col3 {0.000 1.000 1.000 srgb} bind def
		/col4 {1.000 0.000 0.000 srgb} bind def
		/col5 {1.000 0.000 1.000 srgb} bind def
		/col6 {1.000 1.000 0.000 srgb} bind def
		/col7 {1.000 1.000 1.000 srgb} bind def
		/col8 {0.000 0.000 0.560 srgb} bind def
		/col9 {0.000 0.000 0.690 srgb} bind def
		/col10 {0.000 0.000 0.820 srgb} bind def
		/col11 {0.530 0.810 1.000 srgb} bind def
		/col12 {0.000 0.560 0.000 srgb} bind def
		/col13 {0.000 0.690 0.000 srgb} bind def
		/col14 {0.000 0.820 0.000 srgb} bind def
		/col15 {0.000 0.560 0.560 srgb} bind def
		/col16 {0.000 0.690 0.690 srgb} bind def
		/col17 {0.000 0.820 0.820 srgb} bind def
		/col18 {0.560 0.000 0.000 srgb} bind def
		/col19 {0.690 0.000 0.000 srgb} bind def
		/col20 {0.820 0.000 0.000 srgb} bind def
		/col21 {0.560 0.000 0.560 srgb} bind def
		/col22 {0.690 0.000 0.690 srgb} bind def
		/col23 {0.820 0.000 0.820 srgb} bind def
		/col24 {0.500 0.190 0.000 srgb} bind def
		/col25 {0.630 0.250 0.000 srgb} bind def
		/col26 {0.750 0.380 0.000 srgb} bind def
		/col27 {1.000 0.500 0.500 srgb} bind def
		/col28 {1.000 0.630 0.630 srgb} bind def
		/col29 {1.000 0.750 0.750 srgb} bind def
		/col30 {1.000 0.880 0.880 srgb} bind def
		/col31 {1.000 0.840 0.000 srgb} bind def

		end
		save
		newpath 0 308 moveto 0 0 lineto 452 0 lineto 452 308 lineto closepath clip newpath
		-71.3 343.0 translate
		1 -1 scale

		/cp {closepath} bind def
		/ef {eofill} bind def
		/gr {grestore} bind def
		/gs {gsave} bind def
		/sa {save} bind def
		/rs {restore} bind def
		/l {lineto} bind def
		/m {moveto} bind def
		/rm {rmoveto} bind def
		/n {newpath} bind def
		/s {stroke} bind def
		/sh {show} bind def
		/slc {setlinecap} bind def
		/slj {setlinejoin} bind def
		/slw {setlinewidth} bind def
		/srgb {setrgbcolor} bind def
		/rot {rotate} bind def
		/sc {scale} bind def
		/sd {setdash} bind def
		/ff {findfont} bind def
		/sf {setfont} bind def
		/scf {scalefont} bind def
		/sw {stringwidth} bind def
		/tr {translate} bind def
		/tnt {dup dup currentrgbcolor
		4 -2 roll dup 1 exch sub 3 -1 roll mul add
		4 -2 roll dup 1 exch sub 3 -1 roll mul add
		4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb}
		bind def
		/shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul
		4 -2 roll mul srgb} bind def
		/DrawEllipse {
		/endangle exch def
		/startangle exch def
		/yrad exch def
		/xrad exch def
		/y exch def
		/x exch def
		/savematrix mtrx currentmatrix def
		x y tr xrad yrad sc 0 0 1 startangle endangle arc
		closepath
		savematrix setmatrix
		} def

		/$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def
		/$F2psEnd {$F2psEnteredState restore end} def

		$F2psBegin
		10 setmiterlimit
		0 slj 0 slc
		0.06000 0.06000 sc
		%
		% Fig objects follow
		%
		%
		% here starts figure with depth 50
		% Polyline
		7.500 slw
		n 8025 3225 m
		8325 3900 l gs col0 s gr
		% Polyline
		n 2250 4500 m
		1875 5100 l gs col0 s gr
		% Polyline
		n 2625 4425 m
		3000 5100 l gs col0 s gr
		% Polyline
		n 4650 4500 m
		4275 5100 l gs col0 s gr
		/Times-Bold ff 300.00 scf sf
		1500 975 m
		gs 1 -1 sc (1) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		2100 975 m
		gs 1 -1 sc (16) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		3300 975 m
		gs 1 -1 sc (12) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		5700 975 m
		gs 1 -1 sc (10) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		4500 975 m
		gs 1 -1 sc (2) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		5100 975 m
		gs 1 -1 sc (8) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		2700 975 m
		gs 1 -1 sc (5) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		6000 1875 m
		gs 1 -1 sc (1) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		3600 3000 m
		gs 1 -1 sc (16) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		7800 3075 m
		gs 1 -1 sc (5) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		2400 4275 m
		gs 1 -1 sc (12) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		7200 4275 m
		gs 1 -1 sc (2) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		8400 4275 m
		gs 1 -1 sc (8) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		1800 5475 m
		gs 1 -1 sc (10) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		6300 975 m
		gs 1 -1 sc (6) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		3000 5475 m
		gs 1 -1 sc (6) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		6900 975 m
		gs 1 -1 sc (7) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		3900 975 m
		gs 1 -1 sc (4) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		4800 4275 m
		gs 1 -1 sc (4) dup sw pop 2 div neg 0 rm col0 sh gr
		/Times-Bold ff 300.00 scf sf
		4200 5475 m
		gs 1 -1 sc (7) dup sw pop 2 div neg 0 rm col0 sh gr
		% Polyline
		n 7575 3225 m
		7275 3900 l gs col0 s gr
		% Ellipse
		n 8400 4200 309 309 0 360 DrawEllipse gs col0 s gr

		% Ellipse
		n 7800 3000 309 309 0 360 DrawEllipse gs col0 s gr

		% Ellipse
		n 7200 4200 309 309 0 360 DrawEllipse gs col0 s gr

		% Ellipse

Source

Target

Files

Some changes are not shown.