ALGORITHME ESCARGOT

Salut !

L'algorithmique est simplement la programmation sans la syntaxe pointilleuse d'un langage de programmation. C'est exprimer les instructions que tu vas répéter pour accomplir une action.
Genre :
- utilisateur saisit le nombre de colonnes dans x
- utilisateur saisit le nombre de lignes dans y
- ligne <- 1 ---[ affecter 1 à la variable ligne
- colonne <- 1
- répéter
- répéter
- ligne <- ligne + 1
- remplir la cellule (colonne, ligne)
- jusque (ligne = y) ou (cellule (colonne, ligne) déjà remplie)
- répéter
- colonne <- colonne + 1
- remplir la cellule (colonne, ligne)
- jusque (colonne = x) ou (cellule (colonne, ligne) déjà remplie)
etc

Ce que j'ai écrit ne correspond à aucun langage du marché, pourtant n'importe qui entrevoit ce que je cherche à faire.

Je te laisse me corriger et continuer.

Bonsoir,
Merci de ta réponse aussi rapide, en fait je cherche à l'écrire d'une manière plus structuré;
Un exemple vaut mieux qu'un long discours :

Exemple calcul table des carrés entre 2 valeurs

Procedure tabcar(init :entier,Final :entier)
Var nb, nbcarré :entier
Début
Nb:=init
tantque nb <=final faire
nbcarré:=nb*nb;
ecrire (nb,nbcarrée)
nb:=nb+&
fin tanque
fin

Voici ce que j'ai fait mais, moi même j'ai du mal à me relire et comprendre et ne suis pas certain que ce que j'ai ecrit ne comporte pas des erreurs.
Program escargot
Var entier n,p,x,l,c

Procedure colonne_gauche
Var entier L
De L:=L0 à L1
Ecrire (x,L,C1)
Si C0<C1 alors ligne_basse (L0,L1,C0+1,C1)
Fin Si
Fin procedure

Procedure ligne_basse
Var entier C
De C:=C0 à C1
Ecrire (x,L1,C1)
Si L0<L1 alors colonne_droite (L0,L1-1,C0,C1)
Fin Si
Fin procedure

Procedure colonne_droite
Var entier L
De L:=L1 à L0
Ecrire (x,L,C1)
Si C0<C1 alors ligne_haute (L0,L1,C0+1,C1)
Fin Si
Fin procedure

Procedure ligne_haute
Var entier C
De C:=C1 à C0
Ecrire (x,L0,C)
Si L0<L1 alors colonne_gauche (L0+1,L1,C0,C1)
Fin Si
Fin procedure

Procedure escargot
Debut
X:=0
Colonne_gauche (1,n,1,p)

Debut
Afficher("nombre de ligne?")
Lire n
Afficher("nombre de colonne?")
Lire p
Escargot (n,p)
Fin

Explication :
Soit un tableau A de N lignes et P colonnes et X=1 placé dans la première case. On remplit
alors, tant qu'elles sont vides, les cases de la première colonne, de la dernière ligne, de la
dernière colonne de bas en haut, et enfin de la première ligne de droite à gauche, avec X
incrémenté à chaque fois. Puis on recommence avec le sous-tableau de N-2 lignes et P-2
colonnes encore libre et le X suivant la dernière valeur qui a été placée.

Remarque : l'idée suivant laquelle on peut chercher une formulation du terme d'indice i et j
dans A, constitue un autre algorithme mais encore n'apporterait pas d'amélioration au programme : il y aura toujours N*P "affectations".

On désignera par X la dernière valeur logée dans une case, et par L0,L1,C0,C1 les numéros de lignes et de collonnes à remplir dans le tableau.

tu vois, le tabcar(...) est écrit proprement car il est spécifié les interfaces (arguments / paramètres) ainsi que les variables qui lui sont locales.
dans ce que tu as écrit:
- tu cherches à faire du modulaire (c'est bien), mais tu ne précises pas les interfaces, ça ne facilite pas la lecture.
- tu précises la fin de la portée de ton SI, il faudrait faire de même pour ton DE ... À.

J'ai pas vérifié dans le détail (je te laisse ce soin) mais ce que tu as écrit semble cohérent (excepté les fautes de frappe et les remarques ci-dessus)

Et si tu continues à avoir du mal à te relire, n'hésite pas à être verbeux... genre :
Remplir_colonne_gauche_du_rectangle(ligne_debut, ligne_fin, colonne_debut, colonne_fin)
.
.
.
si ... alors Remplir_ligne_basse( Ligne_debut, Ligne_fin, Colonne_debut + 1, Colonne_fin)
.
.
.
fin Remplir_colonne_gauche_du_rectangle
etc... tu te retrouveras dans la peau d'un auteur célèbre : écrivant bcp mais étant immédiatement compris :)