Commit 93c4604addbfcde48a598f4edad16892eb78d18f

Authored by badetitou
1 parent 96a1332a

tuto algo

Showing 1 changed file with 467 additions and 0 deletions   Show diff stats
_tutos/algorithmie.md 0 → 100644
@@ -0,0 +1,467 @@ @@ -0,0 +1,467 @@
  1 +---
  2 +title: "Introduction Algorithmie"
  3 +tags: c algo
  4 +author: "Benoit 'badetitou' Verhaeghe"
  5 +license: WTFPL
  6 +license_url: http://www.wtfpl.net/
  7 +---
  8 +
  9 +De l'algorithmie au C
  10 +---------------------
  11 +
  12 +Bonjour, Ceci est un petit livre récapitulatif de l'ensemble de ce que l'on à vu en Algorithmie et en C.
  13 +
  14 +**Attention. Ceci n'est qu'un récapitulatif. Vous ne pouvez pas prétendre tout savoir avec seulement ces connaissances.**
  15 +
  16 +[Des exemples ? ](https://drive.google.com/open?id=0Bxnrqy9eZ2mXYWxpRnpQSXM0VHc)
  17 +
  18 +
  19 +
  20 +# Algorithmie
  21 +
  22 +## Action ou Fonction
  23 +
  24 +### Introduction
  25 +
  26 +L'algorithmie est la partie de la conception où nous devons réfléchir à notre programme avant de le transcrire dans un vrai langage de programmation.
  27 +
  28 +Il est évident que pour créer un programme informatique complexe, le plus simple est de le diviser en plusieurs sous programme simple. C'est ce que nous appelons les actions et les fonctions.
  29 +
  30 +### Action
  31 +Les actions sont une des manières de diviser son programme. Elle est composé d'un nom, est d'une suite de paramètres.
  32 +
  33 +```
  34 +Action <nom d'action> (paramètres)
  35 +| D : <Déclaration> {Signification}
  36 +| R : <Déclaration> {Signification}
  37 +| D/R : <Déclaration> {Signification}
  38 +| VL : <Déclaration> {Signification}
  39 +|
  40 +| <Corps>
  41 +FinAction
  42 +
  43 +```
  44 +
  45 +L'ensemble des lettres correspondent à l'utilité des paramètres.
  46 +*
  47 +Données : Information Utilisées
  48 +*
  49 +Résultats : Informations produites
  50 +*
  51 +Données/Résultats : Informations modifiées
  52 +*
  53 +Variables Locales : Informations temporaires au déroulement de l'algorithme
  54 +
  55 +
  56 +### Fonctions
  57 +La fonction fonctionne de la même manière qu'une action. Les principales différences sont l'ajout d'un type de retour. **L'absence de paramètre de type Résultat ou Données/Résultat.**
  58 +
  59 +``````
  60 +Fonction <nom d'action> (paramètres) : Type de retour
  61 +| D : <Déclaration> {Signification}
  62 +| VL : <Déclaration> {Signification}
  63 +|
  64 +| <Corps>
  65 +|
  66 +| Retourner <variable du type indiquer>
  67 +FinAction
  68 +```
  69 +
  70 +# Les types
  71 +
  72 +## Listes des types
  73 +
  74 +
  75 +Voici une liste non exhaustive des types existant en algorithmie
  76 +* Entier
  77 +* Réel
  78 +* Caractère
  79 +* Chaîne de Caractère
  80 +* Booléen (Vrai ou Faux)
  81 +* Vecteur de "Type" de taille "Entier"
  82 +* Matrice de "Type" de dimensions "Entier","Entier"
  83 +* Structures
  84 +
  85 +## Operation de base
  86 +### Entier, Réel, Caractère, Chaîne de caractère
  87 +Ce sont ici les type de base avec lesquels nous allons le plus travailler.
  88 +
  89 +Comme le nom l'indique les variable de type entier permette de stocker un entier dans la mémoire. De même que un réel permet de stocker un réel est une chaîne de caractère un caractère.
  90 +
  91 +#### Affectation
  92 +Prenons A et B deux variable de type Entier. Et C de type Réel.
  93 +
  94 +Pour enregistrer une valeur dans une variable nous utiliserons la notation suivante :
  95 +```A<-9 ```. Je stocke la valeur '9' dans la variable 'A'
  96 +
  97 +Nous pouvons maintenant affecter cette valeur à une autre variable : ```B<-A```
  98 +
  99 +*Et si nous faisions ```C<-B``` ?* Alors C était une variable pour les réel. Elle convertirai 9 en un nombre de type réel.
  100 +
  101 +*Que ce passe-t-il si je stocke un Réel dans un Entier ?*
  102 +
  103 +Le réel sera tronqué, ça veut dire qu'on enlève tout ce qui a après la virgule.
  104 +
  105 +```
  106 +C<-9.7
  107 +B<-C
  108 +Afficher B {Affiche '9'}
  109 +```
  110 +
  111 +Le fonctionnement est le même pour les Chaînes de Caractères
  112 +
  113 +#### Addition..Soustraction..Multiplication..Division..Modulo
  114 +Les variables comportant des nombres (Entier, Réel, Caractère (cf : [Table ASCII](http://www.asciitable.com/))) supporte l'ensemble des opération ci-dessus. Le modulo étant le reste de la division entière.
  115 +
  116 +**ATTENTION : Réel/Entier->Réel ET Entier/Réel->Réel**
  117 +
  118 +```
  119 +Opérateur :
  120 ++ : Addition
  121 +- : Soustraction
  122 +/ : Division
  123 +* : Multiplication
  124 +% : Modulo
  125 +
  126 +Format : A(opérateur)B
  127 +```
  128 +
  129 +### Booléen
  130 +Les booléen (ou boolean dans la langue de shakespeare) sont des variables pouvant contenir soit VRAI soit FAUX. Il est possible de les combiner via les opération suivante :
  131 +1. ET : VRAI ET FAUX -> FAUX
  132 +2. OU : VRAI OU FAUX -> VRAI
  133 +
  134 +Bref elles respectent [l'Algèbre de Boole (logique)](https://www.wikiwand.com/fr/Alg%C3%A8bre_de_Boole_(logique))
  135 +####Exemple d'affectation
  136 +Une affectation simple.
  137 +
  138 +```
  139 +A<-VRAI
  140 +```
  141 +
  142 +Une affectation par évaluation
  143 +
  144 +```
  145 +B<-5
  146 +A<- B<2
  147 +Afficher A {Affiche FAUX}
  148 +A<- B=5
  149 +Afficher A {Affiche VRAI}
  150 +```
  151 +
  152 +
  153 +### Vecteur et matrice
  154 +Les vecteurs (ou tableau) ainsi que les matrices (tableau à plusieurs dimension) sont la manière la plus simple de stocker un grand ensemble d'information.
  155 +
  156 +En algorithmie la première case du table est la case 1. La dernière la case n (=correspondant à sa dimension).
  157 +
  158 +#### Exemples :
  159 +[Comprendre les Boucles](structure_de_controle.md)
  160 +
  161 +*
  162 +Parcours de Tableau
  163 +
  164 +```
  165 +Action affiche_element (v, n) : { Affiche les element 1 à 1 de mon vecteur}
  166 + | D : v Vecteur d'entier de taille n
  167 + | D : n Entier
  168 + | VL: i Entier
  169 + |
  170 + | Pour i de 1 à n Faire
  171 + | | Afficher v[i]
  172 + | FinPour
  173 + |
  174 +FinAction
  175 +
  176 +```
  177 +
  178 +* Remplissage de Tableau
  179 +
  180 +```
  181 +Action affiche_element (v, n) : { Affiche les element 1 à 1 de mon vecteur}
  182 + | R : v Vecteur d'entier de taille n
  183 + | D : n Entier
  184 + | VL: i Entier
  185 + |
  186 + | Pour i de 1 à n Faire
  187 + | | Lire v[i]
  188 + | FinPour
  189 + |
  190 +FinAction
  191 +```
  192 +* Parcours de Matrice
  193 +
  194 +```
  195 +Action affiche_element (n,m, Mat) : { Affiche les element 1 à 1 de mon vecteur}
  196 + | D : Mat Matrice d'entier de dimension n,m
  197 + | D : n Entier
  198 + | D : m Entier
  199 + | VL: i Entier
  200 + | VL: j Entier
  201 + |
  202 + | Pour i de 1 à n Faire
  203 + | | Pour j de 1 à m Faire
  204 + | | | Afficher v[i][j]
  205 + | | FinPour
  206 + | FinPour
  207 + |
  208 +FinAction
  209 +
  210 +```
  211 +
  212 +* Remplissage de Matrice
  213 +
  214 +
  215 +```
  216 +Action affiche_element (Mat, n,m) : { Affiche les element 1 à 1 de mon vecteur}
  217 + | D : Mat Matrice d'entier de dimension n,m
  218 + | D : n Entier
  219 + | D : m Entier
  220 + | VL: i Entier
  221 + | VL: j Entier
  222 + |
  223 + | Pour i de 1 à n Faire
  224 + | | Pour j de 1 à m Faire
  225 + | | | Lire Mat[i][j]
  226 + | | FinPour
  227 + | FinPour
  228 + |
  229 +FinAction
  230 +
  231 +```
  232 +
  233 +## Structures
  234 +Les structures permettent aux concepteurs de créer leurs propres type, les rendant ainsi plus libre dans la conception et leurs facilitant le travail pour des sujets complexe.
  235 +
  236 +```
  237 +type <ST> = structure
  238 + | <Nom Variable> : <Type>
  239 + | <Nom Variable> : <Type>
  240 + | <Nom Variable> : <Type>
  241 + Fin
  242 +```
  243 +
  244 +
  245 +# Structure de contrôle
  246 +
  247 +## Introduction
  248 +Il faut toujours avoir à l'esprit que le programmeur est un fainéant.
  249 +Il a donc naturellement construit des outils pour lui facilité le travail. Certains de ces outils sont sans aucun doutes les structures de contrôle. Elle permette d'utiliser un même programme dans plusieurs cas différent et de simuler l'écriture d'un nombre non calculable de ligne en seulement trois ou quatre.
  250 +
  251 +## Alternative
  252 +Les alternative permette de tester si une condition est vrai, et dans ce cas, exécuter ou non un certain nombre de commande. En Algorithmie nous appelons ça le SI..Fin SI
  253 +
  254 +Une Condition est en réalité une expression [booléenne](les_types.md).
  255 +###Exemple
  256 +Le code suivant affiche "bleu"
  257 +```
  258 +A<-1
  259 +B<-2
  260 +SI (A<B) FAIRE
  261 +| Afficher "bleu"
  262 +FinSi
  263 +```
  264 +
  265 +Maintenant avec un booléen
  266 +```
  267 +A<-1
  268 +B<-2
  269 +C<- FAUX
  270 +SI (A<B ET C) FAIRE
  271 +| Afficher "bleu"
  272 +FinSi
  273 +```
  274 +Ici le code n'affiche rien car d'après l'algèbre de Boole ```VRAI ET FAUX ->FAUX```
  275 +
  276 +## Boucle
  277 +Les boucles sont les structures permettant de répéter plusieurs fois le même code. Elles sont divisé en deux grands groupe. Celle qui "boucle" un nombre de fois définit. Et celle qui continue tant qu'une condition est rempli.
  278 +### Tant Que
  279 +La boucle tant que est celle du deuxième type. Elle entoure du code qui sera effectuer tant que une condition est rempli.
  280 +```
  281 +TantQue A<B Faire
  282 +| <code>
  283 +FinTantQue
  284 +```
  285 +Attention. Vous devez vous assurer que la condition ```A<B``` passe à FAUX un moment. Sinon vous créer une boucle infini.
  286 +```
  287 +I<-12
  288 +TantQue A<B ET I<56Faire
  289 +| <code>
  290 +| I<-I+1
  291 +FinTantQue
  292 +```
  293 +### Pour
  294 +La boucle Pour ne doit être utilisé que lorsque vous connaissez exactement le nombre de fois que vous souhaitez répéter le code
  295 +```
  296 +B<-1
  297 +A<-12
  298 +Pour I de B à A Faire
  299 +| Afficher "Je repete du code"
  300 +| Afficher I
  301 +| Afficher fois
  302 +FinPour
  303 +```
  304 +
  305 +# Le C
  306 +
  307 +Nous supposerons que vous avez déjà lu la partie sur l'Algorithmie. Tout ne sera donc pas décrit ici.
  308 +
  309 +## La base
  310 +En C tout est fonction.
  311 +Cela signifie que les Actions n'existent pas. Une action sera donc représenter par une Fonction sans type de retour ```void```
  312 +
  313 +## Les fonctions
  314 +Une fonction est composé de deux grandes parties.
  315 +
  316 +Tout d'abord le prototype. Il est composé du type de retour, du nom de la fonction et enfin des paramètres.
  317 +
  318 +Puis le corps de la fonction composé de l'ensemble des instruction à exécuter. Le corps est entouré par deux accolade ```{ <coprs> }```
  319 +
  320 +La fonction principal appelé au début de l'exécution du programme est le main. Elle accepte deux paramètre qui correspondent au arguments que nous donnerons à notre programme depuis notre shell.
  321 +### Main
  322 +```int main(int argc, char* argv[]){ <corps> }```
  323 +###Exemple fonction
  324 +```
  325 +int multiplication (int a, int b){ // Prototype
  326 + return (a*b); // Corps de la fonction
  327 +}
  328 +```
  329 +Nous voyons que les fonctions ce termine par la 'commande' ```return``` suivit d'une variable correspondant au type de retour.
  330 +###Exemple fonction/action
  331 +Comme expliqué ci-dessus. En C les actions sont représenté par une fonction sans type de retour;
  332 +```
  333 +void hello_world(){
  334 + printf("Hello World !");
  335 +}
  336 +```
  337 +
  338 +##Instructions
  339 +Une instruction est une commande à exécuter en C suivit de ses paramètres entre parenthèses et fini par un **';'**.
  340 +
  341 +# Type en C
  342 +
  343 +Tout les types peuvent être représenter en C. Mais nous allons diviser les types primitifs et les autres.
  344 +
  345 +## Types primitifs
  346 +1. ```int``` : Entier
  347 +2. ```float``` : Réel (taille normal)
  348 +3. ```double``` : Réel (taille plus grande)
  349 +4. ```char``` : Caractère.
  350 +
  351 +### Exemple
  352 +```
  353 +int i, j; // Déclaration de deux variable de type Entier.
  354 +i = 3; // Affectation de la valeur 3 à i
  355 +```
  356 +
  357 +## Tableau (Vecteur)
  358 +Un tableau est déclaré par le type du tableau, suivi de son nom suivit de deux crochets avec la taille du tableau.
  359 +
  360 +En C, et en programmation de manière générale, on commence à compter en 0. La première case du tableau est donc la case 0.
  361 +
  362 +Un tableau de caractère permet donc de représenter une chaîne de caractère.
  363 +###Exemple
  364 +```
  365 +int i[12]; // Déclaration d'un tableau de 12 Entiers
  366 +char j[30] = "Bonjour"; // Déclaration d'une chaîne de caractère et son affectation.
  367 +```
  368 +
  369 +## Structures
  370 +Afin de définir des types plus complexe nous pouvons créer des Structures en C. Une structure peux aussi être composé d'élément étant des structrues.
  371 +
  372 +```
  373 +typedef struct {
  374 + int a;
  375 + double b;
  376 + MaStruct c;
  377 +} NomDeMaStructure;
  378 +```
  379 +
  380 +# Pointeur :-(
  381 +
  382 +En C les variables peuvent être passé de différente manière au fonction. Nous pouvons donner la valeur de la variable ou son adresse dans la mémoire. C'est ce que l'on appelle les pointeurs.
  383 +
  384 +Pour récupérer l'adresse mémoire d'une variable il suffit d'utiliser l'opérande ```&``` avant le nom de la variable. Pour accéder à la place ciblé par un pointeur il faut utiliser l'opérande ```*``` placé devant la variable.
  385 +
  386 +**Il ne faut pas utiliser les pointeurs pour les tableaux. Un tableau est déjà utilisé comme un pointeur en C**
  387 +
  388 +## Exemple
  389 +Avec pointeur :
  390 +```
  391 +void affecte(int *a){
  392 + *a = 2;
  393 +}
  394 +
  395 +int main(void){
  396 + int a = 1;
  397 + affecte(&a);
  398 + printf("%d",a); // Affiche 2
  399 + return 0;
  400 +}
  401 +```
  402 +
  403 +Sans pointeur :
  404 +```
  405 +void affecte(int a){
  406 + a = 2;
  407 +}
  408 +
  409 +int main(void){
  410 + int a = 1;
  411 + affecte(a);
  412 + printf("%d",a); // Affiche 1
  413 + return 0;
  414 +}
  415 +```
  416 +
  417 +Tableaux :
  418 +```
  419 +void rempli(int t[]){
  420 + int a;
  421 + for(a=0;a<12;++a){
  422 + scanf("%d", t[a]);
  423 + }
  424 +}
  425 +
  426 +int main(void){
  427 + int t[12];
  428 + rempli(t);
  429 + return 0;
  430 +}
  431 +```
  432 +
  433 +# C - Structure de contrôle
  434 +
  435 +Les structures de contrôle sont similaire en C et en Algorithmie.
  436 +
  437 +##Alternative ... Exemple
  438 +
  439 +```
  440 +int a = 1;
  441 +if (a == 1){
  442 + <corps si vrai>
  443 +} else if (a == 2) {
  444 + <corps si vrai>
  445 +} else {
  446 + <corps si tout le reste est faux>
  447 +}
  448 +
  449 +```
  450 +
  451 +##Boucle Pour ... Exemple
  452 +
  453 +```
  454 +int a;
  455 +for(a=0;a<12;a++){
  456 + <Corps>
  457 +}
  458 +```
  459 +
  460 +##Boucle TantQue ... Exemple
  461 +```
  462 +int a = 0;
  463 +int b = 1;
  464 +while (a<b){
  465 + <Corps>
  466 +}
  467 +```