L'algorithmique

Pour aborder le sujet de l'intelligence artificielle demandé par Yus, je suis obligé d'introduire la notion d'algorithme. C'est pourquoi, plutôt que de d'embrouiller les gens expliquant briévement le principe de l'algorithmique (ou algorithmie) entre deux exemples d'intelligence artificielle, je préfére aborder et expliquer clairement et immédiatement ce qu'est l'algorithmique.
Certains d'entre vous connaissent sûrement ; toute personne se considérant un minimum informaticien, se doit d'en connaître les bases ; d'autre vont complétement découvrir ce "langage" et c'est pour eux que cet exposé est destiné.

Tout dabord, inutile de s'affoler, en dépis de sa 'complexité' phonétique, l'algorithmique est un langage qui est à portée de l'homme puisqu'il n'existe que pour nous faciliter la compréhension de problèmes complexes.

Il existe plusieur niveau d'algorithme, une infinité si on le désire, dans notre cas nous en expliquerons 3.

Problème : une personne devant une porte fermée veut l'ouvrir, la passer, et la refermer.

Algorithme de niveau 0 :

Code:

Début
                  Ouvrir la porte
                  Passer la porte
                  Fermer la porte
Fin

Très compliqué n'est ce pas ?

Algorithme de niveau 1 :

Code:

Début
                  Tendre la main vers la poignée //main droite
                  Serrer la poignée
                  Pivoter la main pour baisser la poignée  //le côté de la main qui est vers l'extrêmité de la poignée doit aller vers le bas
                  Tirer la main vers l'extérieur // bras tendu vers la droite
                  Deserrer la poignée
                  Avancer le pied droit
                  Avancer le pied gauche //suffisament pour passer la porte
                  Se retourner vers la porte
                  Tendre la main vers la poignée //main droite
                  Serrer la poignée
                  Pivoter la main pour baisser la poignée
                  Tirer la main vers l'extérieur // bras serré contre nous pour refermer la porte
                  Deserrer la poignée
Fin

Nous pouvons faire une analogie entre le niveau 0 et le niveau 1, en effet, chaque ligne du niveau 0 a, le plus souvent, été décomposée en plusieurs lignes dans le niveau 1. on a ainsi :

Ouvrir la porte :
Tendre la main vers la poignée
Serrer la poignée
Pivoter la main pour baisser la poignée
Tirer la main vers l'extérieur
Deserrer la poignée

Passer la porte :
Avancer le pied droit
Avancer le pied gauche
Se retourner vers la porte

Fermer la porte
Tendre la main vers la poignée
Serrer la poignée
Pivoter la main pour baisser la poignée
Tirer la main vers l'extérieur

On a donc la décomposition d'un gros problème en problèmes plus petit, qui se focalisent d'avantage sur un certain point. Et plus on avance dans les niveau d'algorithme, plus, on va décomposer chaque problèmes en plus petit problèmes. le texte situé après les double barres est un commentaire, il permet de préciser des informations nécèssaire au déroulement de l'action.

D'une façon générale, l'utilité d'un algorithme de niveau bas ( 0 et 1) est de faire comprendre l'évolution d'une procédure ou le fonctionnement d'un système à un ensemble de personnes.
Ces niveaux peuvent s'utiliser dans n'importe quel domaine et quelque soit la spécialisation de chacun, un biologiste peut tout a fait expliquer à un roboticien, via ce type d'algorithme ce qu'il attend de son robot. (par exemple).

Au niveau 2, on va se spécialiser au domaine d'application, dans notre cas, cela sera pour de l'intelligence artificielle et donc plus généralement, de l'informatique. Ainsi, avant de vous présenter l'algorithme de niveau 2 d'ouverture d'une porte, il vous faut connaître différent éléments incontournable :

Les variables

Une variable est une "boîte" qui va permettre de stocker un élement d'un certain type.

Il existe une infinité de type, parmi eux, on utilisera :
les entiers (-8 ; -1 ; 0 ; 5 ; 15 ; 342...)
les réels (-8,32 ; 0,721 ; 5 ; 18,7 ...)
Les réels englobent également les entiers.
les caractères ( A ; a ; @ ; & ; . ; C ...)
Les booléens ( VRAI ou FAUX)

Il existe d'autre types de variable, mais je les préciserais quand ils seront utilisés.

une variable a donc un nom, un type et un contenu. pour créer une variable en algorithmique, je procéde comme il suite :

Code:

début
                  type nom=contenu
fin

ainsi, pour créer une variable nommée Chiffre, de type entier et y mettre 5, j'écris :

Code:

début
                  entier Chiffre=5
fin

De cette façon, pour tout le reste de l'algorithme et tant que son contenu n'aura pas été modifié, Chiffre contiendra 5.

Si j'écris

Code:

début
                entier A
fin

j'ai créé une variable A de type entier mais je ne lui ai assigné aucun contenu, je ne peux donc pas m'en servir, sauf pour stocker un contenu :

Code:

début
                entier A
                A=17
fin

Ici, j'ai créé, de la même façon, ne variable A de type entier sans lui assigner de contenu, et à la ligne suivante, j'ai mis 17 dans cette variable.

Un peu de calcul :

Code:

début
                entier A,B,C
                A=4
                B=2
                C=8

                A=B+C
fin

Dans cet exemple, j'ai créé 3 variables nommées A, B et C, chacune de type entier ;
j'ai ensuite mis 4 dans A, 2 dans B et 8 dans C.
Enfin, j'ai mis B+C dans A, or, B vaut 2 et C vaut 8, ainsi B+C valent 10, ce qui signifie que j'ai mis 10 dans A.

A la fin de cet algorithme, A contient 10, et le 4 que j'avais mis à l'origine n'existe plus.


Depuis le début des exemples, nous sommes en présence de variable de type Entier, ainsi, nous pouvons faire des calculs sensé avec ces entiers, nous pourrions tout à fait faire des calculs avec des caractères mais il faut avoir une bonne raison, quoi qu'il en soit, chaque caractère vaut une valeur entière bien spécifique que l'on peut trouver dans la table ASCII.
partie 1
partie 2

Nous n'aurons pas trop à aborder ces méthodes pour l'instant.

Les fonctions - 1

Les fonctions sont des appels à d'autre algorithmes créés ultérieurement, par nous même ou par d'autre gens.
une fonction se présente sous la forme suivante :
nomdelafonction(paramètre1,paramètre2,...,paramètreN)
Il existe une quantité de fonction que l'on a le droit d'utiliser dans n'importe quel algorithme, parmis celle que vous connaissez sûrement :
racinecarrée()

Ainsi, la fonction racine carré s'utilise comme il suit :

Code:

début
                entier A=9
                entier B

                B=racinecarrée(9)
fin

Ici, B sera égal à la racinecarrée de 9, soit, 3.

Des fonctions plus spécifique à l'informatique peuvent également être librement utilisée :

Code:

début
                entier A=9
                entier B

                B=racinecarrée(9)
                Afficher(B)
fin

Dans cet algorithme, après avoir calculer la racine carrée de 9 et avoir affecté le résultat à B, on affiche le contenu de B à l'écran via la fonction Afficher()

L'utilisateur verrait alors s'afficher 3.

La fonction Lire() permet elle de récuperer l'information tapée au clavier par l'utilisateur :

Code:

début
                  entier toto                 
                  toto=Lire()
                  Afficher(racinecarrée(toto))
fin

Ici nous créons une variable toto de type entier et l'utilisateur va y placer la valeur qu'il désire via le clavier, ensuite la racine carrée de cette valeur est affichée.

Il est tout a fait possible de créer ses propres fonctions et de les utiliser les une dans les autres pour mettre au point un algorithme avancé ou plus compliqué, chose que nous verrons dans la prochaine étape reservée aux fonctions.

Les tableaux

Nous avons vu qu'une variable ne peut contenir qu'un élément, et bien un tableau est une variable qui peut contenir plusieurs éléments, chacun rangé dans une case du tableau.
Chaque case du tableau est repéré par un entier, attention, la numérotation commence à zéro, ainsi, un tableau de 10 cases sera numéroté de 0 à 9.

Code:

début
              type nomdelavariable[nombredecase]
fin

On peut choisir de stocker les informations où on veut dans le tableau :

Code:

début
              entier pipicaca[5]
             
              pipicaca[0]=7
              pipicaca[4]=2
fin

Ici, nous avons stocké 7 dans la case 0 du tableau pipicaca et 2 dans la case 4 du tableau pipicaca, les autres cases elles, restent indéfinies.

Les boucles

Les boucles sont des parties d'algorithmes qui vont se répéter tant qu'une condition ne sera pas effectuée.

Chaque type de boucle possède un début et une fin, une fois arrivée à la fin, on retourne au début, ceci, en fonction de la condition.

Code:

début
              caractère mdp
              caractère mdp='n'
             
              tantque mdp != 'o' faire
                    mdp=lire()
              ftq
fin

Dans cet exemple, on crée une variable mdp de type caractère et on y place n dedans (on utilise les ' pour encadrer la valeur afin de bien préciser que c'est un unique caractère et qu'il n'y a pas d'espaces ou que ce n'est pas une autre variable nommée n).
Puis, on entre dans une boucle tantque :
tantque condition faire
dans notre cas la condition est mdp != 'o'
!= signifie différent
ainsi, tant que ce qu'il y a dans mdp sera différent de o, on fera tout ce qu'il y a écrit jusqu'à ftq et on reviendra au début de la boucle.
dans notre cas, on permet à l'utilisateur de mettre quelque chose au clavier qui sera placé dans mdp, si l'utilisateur tape o, alors on sortira de la boucle.

il existe d'autre type de boucles, comme la boucle pour qui est l'une des plus utilisée :

Code:

début
            entier i
           
            pour(i=1;i<=10;i++) faire
                    afficher(" Ergrim le gros gay")
            fpour
fin

L'algorithme précédent va afficher 10 fois "Ergrim le gros gay" ;
explications :
pour > type de boucle
i=1 : on affecte une valeur à i, ici, 1, cette affectation n'est valable qu'à la première entrée dans la boucle, elle ne prendra pas effet aux répétitions.
i<=10 : condition pour rester dans la boucle, ici, i inférieur ou égal à 10, ce qui signifie que tant que i est inférieur ou égal à 10, on reste dans la boucle
i++ : on incrément i de 1 ce qui équivaudrait à écrire i=i+1, ainsi, à chaque tour de boucle, i va s'incrémenter jusqu'à ateindre 10 et on sortira alors de la boucle.

On peut se servir de boucles, pour, par exemple, stocker des phrases tapée au clavier.

Code:

début
                caractère texte[11]
                entier i

                pour(i=-1;i<=9;i++)
                        texte[i]=lire()
                fpour
                afficher(texte)
fin

dans le code précédent, après avoir initialisé les variables, on entame une boucle qui va varier de 0 à 10 et que je vais détailler :
1 ° on entre dans la boucle,
i est initialisé -1 et, après avoir vérifié la condition, passe à 0
l'utilisateur tape par exemple 'H' au clavier ce qui est stocké dans la case i du tableau texte, i étant égal à 0 cela sera donc la case 0 du tableau texte.
texte contient donc : [H,?,?,?,?,?,?,?,?,?,?]

2° on arrive à la fin de la boucle, et on remonte au début ;
i vaut 0 et est toujours inférieur à 9, il est donc incrémenté;
i=1
'utilisateur tape par exemple 'e' au clavier ce qui est stocké dans la case i du tableau texte, i étant égal à 1 cela sera donc la case 1 du tableau texte.
texte contient donc : [H,e,?,?,?,?,?,?,?,?,?]

3° on arrive à la fin de la boucle, et on remonte au début ;
i vaut 1 et est toujours inférieur à 9, il est donc incrémenté;
i=2
'utilisateur tape par exemple 'l' au clavier ce qui est stocké dans la case i du tableau texte, i étant égal à 2 cela sera donc la case 2 du tableau texte.
texte contient donc : [H,e,l,?,?,?,?,?,?,?,?]

4° on arrive à la fin de la boucle, et on remonte au début ;
i vaut 2 et est toujours inférieur à 9, il est donc incrémenté;
i=3
'utilisateur tape par exemple 'l' au clavier ce qui est stocké dans la case i du tableau texte, i étant égal à 3 cela sera donc la case 3 du tableau texte.
texte contient donc : [H,e,l,l,?,?,?,?,?,?,?]

5° on arrive à la fin de la boucle, et on remonte au début ;
i vaut 3 et est toujours inférieur à 9, il est donc incrémenté;
i=4
'utilisateur tape par exemple 'o' au clavier ce qui est stocké dans la case i du tableau texte, i étant égal à 4 cela sera donc la case 4 du tableau texte.
texte contient donc : [H,e,l,l,o,?,?,?,?,?,?]

6° on arrive à la fin de la boucle, et on remonte au début ;
i vaut 4 et est toujours inférieur à 9, il est donc incrémenté;
i=5
'utilisateur tape par exemple ' ' au clavier ce qui est stocké dans la case i du tableau texte, i étant égal à 5 cela sera donc la case 5 du tableau texte.
texte contient donc : [H,e,l,l,o, ,?,?,?,?,?]

7° on arrive à la fin de la boucle, et on remonte au début ;
i vaut 5 et est toujours inférieur à 9, il est donc incrémenté;
i=6
'utilisateur tape par exemple 'W' au clavier ce qui est stocké dans la case i du tableau texte, i étant égal à 6 cela sera donc la case 6 du tableau texte.
texte contient donc : [H,e,l,l,o, ,W,?,?,?,?]

8° on arrive à la fin de la boucle, et on remonte au début ;
i vaut 6 et est toujours inférieur à 9, il est donc incrémenté;
i=7
'utilisateur tape par exemple 'o' au clavier ce qui est stocké dans la case i du tableau texte, i étant égal à 7 cela sera donc la case 7 du tableau texte.
texte contient donc : [H,e,l,l,o, ,W,o,?,?,?]

9° on arrive à la fin de la boucle, et on remonte au début ;
i vaut 7 et est toujours inférieur à 9, il est donc incrémenté;
i=8
'utilisateur tape par exemple 'r' au clavier ce qui est stocké dans la case i du tableau texte, i étant égal à 8 cela sera donc la case 8 du tableau texte.
texte contient donc : [H,e,l,l,o, ,W,o,r,?,?]

10° on arrive à la fin de la boucle, et on remonte au début ;
i vaut 8 et est toujours inférieur à 9, il est donc incrémenté;
i=9
'utilisateur tape par exemple 'l' au clavier ce qui est stocké dans la case i du tableau texte, i étant égal à 9 cela sera donc la case 9 du tableau texte.
texte contient donc : [H,e,l,l,o, ,W,o,r,l,?]

11° on arrive à la fin de la boucle, et on remonte au début ;
i vaut 9 il n'est plus inférieur à 9 mais il est égal à 9 ce qui respecte la condition, il est donc incrémenté;
i=10
'utilisateur tape par exemple 'd' au clavier ce qui est stocké dans la case i du tableau texte, i étant égal à 10 cela sera donc la case 10 du tableau texte.
texte contient donc : [H,e,l,l,o, ,W,o,r,l,d]

12° on arrive à la fin de la boucle, et on remonte au début ;
i vaut 10, il est supérieur à 9, on sort immédiatement de la boucle sans y passer.

13° afficher(texte), le contenu du tableau texte est affiché à l'écran, on voit donc : Hello World

Une dernière "boucle" pour la forme, qui n'est pas vraiment une boucle :
si alors sinon

Code:

début
                entier age

                Afficher("avez vous plus de 18ans ? o/n")
                age=lire()
                si age!='o' alors
                        Afficher("désolé, le contenu de ce site risque de vous choquer")
                        quitter()
                sinon
                        Afficher("amusez vous bien")
                fsi
fin

Ici, la boucle n'est pas trop compliquée à comprendre, si la condition est respectée alors blabla, sinon blabla
dans notre cas, si la réponse n'est pas o à savoir, oui, l'ordinateur affiche le message et la fonction quitter() quitte le programme.

Les fonctions - 2

Revenons sur nos chères fonctions.
Il est temps pour nous d'apprendre à en créer :

nomdelafonction(paramètres type):valeurretournée

Nous avons vu plus tôt que la fonction racinecarrée() récupére un réel en calcule la racine carrée et retourne le résultat : un réel
(n'oublions pas qu'un entier est un réel).

elle s'écrit alors comme il suit :
racinecarrée(paramètre réel):réel
début
blablabla tonnes de calculs à partir de paramètre blablabla
retourner valeurdurésultatducalcul
fin

ainsi, en utilisant la fonction racinecarrée() comme il suit :

Code:

début
            réel toto
           
            toto=racinecarrée(16)
fin

on passera en paramètre la valeur 16 sur lequel sera effectué le calcul et on affectera à toto la valeurdurésultatducalcul,

Si nous voulions faire une fonction qui multiplie par 3 un entier nous devrions procéder comme il suit :

Code:

multi(valeur entier):entier
début
          retourner valeur*3
fin

ici la valeur passée en paramètre est immédiatement multipliée par 3 et retournée, voyons comment l'utiliser :

Code:

début
          entier tata=7
          entier result

          result=multi(tata)
          afficher(result)
fin

ici, on utilise la fonction multi écrite juste avant, et on lui passe en paramètre, tata, qui vaut 7 ; si on regarde plus haut, dans ce que l'on a écrit plus tôt, on remarque le paramètre passé est multiplié par 3 puis retourné. donc result = 21
on affiche donc 21.

Bien sûr, dans un ca aussi simple il aura été bien plus évident de remplacer multi(tata) par tata*3 mais pour illustrer simplement l'exemple, je préfére prendre un exemple tout bête.
Les fonctions sont utilisées pour effectuer des tâches plus complexe telle que les fonctions mathématique ou autre manipulation avancée de variable que l'on ne peut écrire en brut.
(n'oubliez pas, il faut décomposer en éléments plus simple, on écrit donc pas tout d'un coup mais on utilise des fonctions, et les fonctions vont elles même utiliser des fonctions, etc etc etc....)


Ainsi, l'exemple de l'ouverture de la porte illusté au début se décomposerait, avec un algorithme de niveau 3, comme il suit :

Code:

début
          booléen poignée_atteinte //poignée_atteinte passe automatiquement et toute seule à 1 lorsqu'une main la touche

          entier porte_atteinte // passe à 1 lorsque l'encadrement de la porte est obstrué, passe à 2 lorsque l'encadrement a été obstruée par autre chose que la porte, et ne l'est plus.
         
          tantque poignée_atteinte != 1 faire
                tendre(main,poignée) // le premier paramètre est l'élément à tendre, le second sa destination
          ftq

          serrer(main,1)

          tantque pivoter(poignée,droite) != 0 faire
                  rien
          ftq  // pivoter() retourne zero quand l'élement pivoté ne peut plus l'être
 
          tantque tirer(main,droite,tendre) != 1 faire
                  rien
          ftq // tirer() passe à 1 lorsque l'action est à son maximal

          serrer(main,0)
   
          répéter
                  avancer(pied gauche)
                  avancer(pied droit)
          jusqu'à porte_atteinte == 2

          rotation (corps,180)
         
          tantque poignée_atteinte != 1 faire
                tendre(main,poignée)
          ftq

          serrer(main,1)

          tantque pivoter(poignée,droite) != 0 faire
                  rien
          ftq


          tantque tirer(main,milieu,plier) != 1 faire
                  rien
          ftq // tirer() passe à 1 lorsque l'action est à son maximal

          serrer(main,0)
fin

Essayer de comprendre par vous même le déroulement de cet algorithme, il n'est pas très compliqué mais j'ai volontairement utilisé une écriture qui peut embrouiller, il y a également des petites choses que je n'ai pas expliqué et même une boucle surprise.

N'hésitez pas à poser des questions si quelque chose vous échappe.



Si tout ceux qui veulent comprendre l'intelligence artificielle comprennent ça, alors je passerais à cet exposé, durant lequel je rajouterais des notions d'algo telle que les structures ou autre.

Enfin, il faut savoir que l'algorithmique est un langage quasi-individuel, chaque fait le sien pour lui, pour le comprendre sois-même ; il doit bien sûr rester compréhensible de tous, mais chaque personne écrit différement. alors même si les grandes lignes restes toujours respectées, il est très probable que pour ceux qui ont déjà fait de l'algo, que de nombreuses choses soient légérement différentes, mais tout de même parfaitement compréhensible.

halala je suis en plein projet de C
C'est parfaitement compréhensible ton truc..., faut dire quand on a déjà fait de l'algo c'est compréhensible sans explication

C'est quoi ton projet ?

Hum, dsl je passe en survolant, je lirai tout demain, mais me semble que tu t'es trompé dans ta boucle (je dis ca très vite j'ai ptet faux ^^)

Code:

début
                entier age

                Afficher("avez vous plus de 18ans ? o/n")
                age=lire()
                si age!='o' alors
                        Afficher("désolé, le contenu de ce site risque de vous choquer")
                        quitter()
                sinon
                        Afficher("amusez vous bien")
                fsi

Si oui, alors faut afficher amuser vous bien, sinon faut dire : dsl le site patati patata, no ?

si age!='o'

si la réponse n'était pas o donc, si la personne n'a pas plus de 18ans alors désolé patata

ok, justement je t'ai dis je survolais, donc je n'étais pas sur, ignorant la signification du !=
J'ai plus l'habitude du if then else sans raffinement derrière

!= c'est du C

Oula c'est un peu long a expliquer mon projet mais voila ce qu'on doit faire:

4. SUJET DU PROJET
Vous êtes le skipper d’un voilier qui fait du cabotage au large des côtes. Vous souhaiteriez disposer d’un logiciel qui vous permettrait de déterminer à quelles heures vous pourriez rejoindre un port déterminé et quels sont les ports dans lesquels vous pourriez accoster à une heure déterminée.



Cela parait simple comme ca mais c'est chiant.

Je vais pas mettre les données des annexes parce qu'il y a une 10ene de pages...;
Heure de basse marée, heure de haute marée, hauteur de l'eau, vitesse du bateau, position du bateau, profondeur du bateau, pression atmosphérique, vitesse de la marée....

Yahou ^^ Beaucoup de facteurs à gérer en même temps pour beaucoup de résultats.

Amuses toi bien

j'adore l'exemple d'Ergrim

Tres bon boulot comme d'hab HR

Merci

Oula ca fé long à lire je me le réserve pour plus tard

(Surtout que la l'algo c'est overdose en ce momant)

Yus, tu me diras si tout ça c'est bon pour toi, vu que le sujet de l'ia c'est toi qui l'a demandé =D

car je ne sais pas si tu connaissais déjà ou si tu as pas encore vu ce topic.

Tu peux poursuivre Je connaissais les principes de l'algorithme. Bien expliqué

A y est j'ai pu tout lire Ca me rappel mes premiers arbres programatiques et mes premiers programmes en Ada ^^
Non c'est claire et bien fait. Good job... Y'a plus qu'a faire pareil avec la programation objet et c'est tout bon ^^

ça tombe bien, toi qui n'a rien à faire, tu vas pouvoir faire l'algo POO =)

euh... laisse moi réflechir à la réponse négative ^^

tout bien réflechis je le ferai dès que j'aurai un peu de temps ca me fera de la révision.... Mais pas tt de suite par contre.

Euh question à part Hr mais en POO je dois faire un projet... le soucis c'est que c'est nous qui devons trouver les idées de projets sur lesquels travaillés... Le mieux serai quelque chose de simple mais efficace (Cout horaire faible (entre 20 et 30h) pour un truc qui peu tennir la route...) si tu as ou si qui que ce soit à une idée celle ci est la bienvenue

je peux te fournir les codes sources d'un moteur 3D high tech, tu as plus qu'à changer les noms par le tient =D



Plus sérieusement, tu es seul ? aucun matériel (purement software) ?
avec interface graphique ? un logiciel qui permet de rennomer tout les fichiers selectionner avec une incrémentation définie par l'utilisateur ou, quelque soit le nom du fichier, de lui rajouter une incrémentation.

c'est une idée, faut voir si c'est dans tes cordes.

En fait c'est en binome... Niveau materiel c'est à voir sachant que le budjet est environ égal à 0^^ et niveau interface vu qu'on voie en détail les Mfc cette année vaudrai mieux les utilisés je pense....

Merci pour l'idée je prends note