Discussion :

[diden138]

son code ne peut pas marcher (en tous cas pas sous pascal) je l'ai expliqué précédemment en pascal la pile qui est réservé au sous programme et aux variable qui vont avec est limité à 16 ko.
donc trop d'appel récursive implique beaucoup de sauvegarde implique débordement de la pile rien à faire donc.
la seul solution peut être c'est d'utiliser des pointeur mais la encore tu aura le même problème je pense.
cordialement @+

[krachik]

je parle de ton code du moins la correction que tu as apporté à son code
bien sûr en corrigeant les String[256]

Code diden138 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
 uses wincrt;
var Phrase : string[256];
    Car : char;
    NbreOcc : byte;
 
procedure Occurence(Ph:string[256];C:char;var Nbre:byte) ;
var 
    SPh : string[256];
begin
if (length(Ph) = 0) then
     Nbre:=0;
 
SPh:=copy(Ph,1,1);
delete(Ph,1,1);
if(length(Ph) >0) then
   begin
   if (SPh[1]=C) then
       Nbre := Nbre + 1;
   Occurence(Ph,C,Nbre);
   end
else
 if (SPh[1]=C) then Nbre:=1;
 
end;
begin
NbreOcc:=0;
writeln('Saisir une phrase :');
readln(Phrase);
writeln('Saisir un caractère :');
readln(Car);
Occurence(Phrase,Car,NbreOcc);
writeln('l''occurence de la lettre <<',Car,'>> = ',NbreOcc);
end.

Bon on va eviter une polemique sur le sujet

[diden138]

bien sûr en corrigeant les String[256]

j'ai expliqué pourquoi j'avais mis 256,il me semble que tous le monde se trompe encore plus qu'on est fatigué (je vais pas raconter ma vie sur le forum comme même)
j'ai comme l'impression que tu me prend au mot là
bon revenons à nos moutons comme on dit je n'ai pas bien compris ce que tu veux: pourquoi le code ne fonctionne pas (du moins quand la chaine dépasse un certain nombre de caractères) ce que j'ai expliqué ou veux tu qu'on trouve une solution pour que ce code marche ?
si c'est le cas je t'ai dis de regarder du coté des pointeurs mais ça donnera toujours la même erreur et pour cause le problème vient de l'algo
cordialement @+

[blackbird1]

merci les gars pour vos contributions

[krachik]

merci les gars pour vos contributions

Alors tu as réussi à faire tourner ton code ?
@+

[diden138]

après une bonne analyse de l'erreur j'ai réalisé que le problème venait de la pile d'appel exactement . et j'ai revu ton code et la comme par magie je remarque dans ta procédure que t'a pas mis un "var" avant le Ph et Car ce qui a pour effet de dupliquer les variables Ph et car à chaque appel récursive d'où le débordement .
et après une petite modification de ton code ça donne ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
program incroyable;
uses crt;
var Phrase      : string;
     Car           : char;
     NbreOcc    : byte;
 
procedure Occurence(var Ph:string;var C:char;var Nbre:byte) ;
var
    SPh : string;
begin
if (length(Ph) = 0) then   Nbre:=0;
SPh:=copy(Ph,1,1);
delete(Ph,1,1);
if(length(Ph) >0) then
   begin
   if (SPh[1]=C) then
       Nbre := Nbre + 1;
   Occurence(Ph,C,Nbre);
   end
{// j'ai enlevé ici le else qui servait à rien ///}
end;
begin
NbreOcc:=0;
writeln('Saisir une phrase :');
readln(Phrase);
writeln('Saisir un caractère :');
readln(Car);
Occurence(Phrase,Car,NbreOcc);
writeln('l''occurence de la lettre <<',Car,'>> = ',NbreOcc);
readln;
end.

voila tu tenait vraiment à faire marcher ce code voila qui est fait
Ps: si c'est résolu merci de le mettre
cordialement @+

[krachik]

C'est vrai que tu te donnes vraiment du mal pour faire marcher ce code
Juste un truc en ce qui concerne le else que tu mets en commentaire (comme quoi il ne sert à rien).c'est toi même qui l'a mis dans le code :mouarf . Pour verifier regardes le premier post son code et le deuxieme code (le tien (version corrigé du premier)).
Un autre point si je comprend bien ,tu veux dire que pour ces genres d'appels recursifs pour eviter les debordements de pile il faut à chaque fois passer tous les parametres par adresses ?
Dernier point je me suis donné la peine juste pour toi gràce ton code pour l'executer sous TP7 et je peux te dire que ça à un comportement aléatoire à l'execution
Ex:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
              Test 1
    Entréés: chaine: azza
                 caractere:a
     Sortie :   Nb Occurence : 1
              Test 2
     Entréés: chaine: zaaz
                 caractere:a
     Sortie :   Nb Occurence : 2
              Test 3
    Entréés: chaine: zaaz
                 caractere:z
     Sortie :   Nb Occurence : 1

Qu'en dis-tu?
@+

[droggo]

Dio,

après une bonne analyse de l'erreur j'ai réalisé que le problème venait de la pile d'appel exactement . et j'ai revu ton code et la comme par magie je remarque dans ta procédure que t'a pas mis un "var" avant le Ph et Car ce qui a pour effet de dupliquer les variables Ph et car à chaque appel récursive d'où le débordement .
et après une petite modification de ton code ça donne ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
program incroyable;
uses crt;
var Phrase      : string;
     Car           : char;
     NbreOcc    : byte;
 
procedure Occurence(var Ph:string;var C:char;var Nbre:byte) ;
var
    SPh : string;
begin
if (length(Ph) = 0) then   Nbre:=0;
SPh:=copy(Ph,1,1);
delete(Ph,1,1);
if(length(Ph) >0) then
   begin
   if (SPh[1]=C) then
       Nbre := Nbre + 1;
   Occurence(Ph,C,Nbre);
   end
{// j'ai enlevé ici le else qui servait à rien ///}
end;
begin
NbreOcc:=0;
writeln('Saisir une phrase :');
readln(Phrase);
writeln('Saisir un caractère :');
readln(Car);
Occurence(Phrase,Car,NbreOcc);
writeln('l''occurence de la lettre <<',Car,'>> = ',NbreOcc);
readln;
end.

voila tu tenait vraiment à faire marcher ce code voila qui est fait
Ps: si c'est résolu merci de le mettre
cordialement @+

C'est un moyen de repousser le problème : les variables locales étant réservées sur la pile, son débordement n'en est que reculé en diminuant la quantité utilisée pour passer les paramètres.

D'autre part, comme tu autorises la procédure à modifier les données originales, il faut te méfier :

quand tu écris ceci, et compte tenu de la déclaration de la procédure et de ses variables locales :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
SPh:=copy(Ph,1,1);
delete(Ph,1,1);

cela implique que tu sauves la chaine originale dans une variable locale (==> cette copie sera perdue en sortant de la procédure), et que tu modifies la chaîne originale avec le delete !!
Ce n'est pas le but.
Donc, attention quand on autorise les modifications.

Cela aurait était évité en utilisant const au lieu de var pour la chaîne : le compilateur aurait détecté la tentative de modification.

ici, édité

De plus, ta copie locale de la chaîne ne sert qu'à tester son premier caractère.

Et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
delete(Ph,1,1);
if(length(Ph) >0) then
   begin
   if (SPh[1]=C) then
       Nbre := Nbre + 1;

fait que l'algorithme est faux : tu ne comptes pas le dernier caractère de la chaîne d'origine.

ET quand tu fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
if (length(Ph) = 0) then   Nbre:=0;
SPh:=copy(Ph,1,1);
...

si (length(Ph) = 0), alors tu utilises des caractères qui ne font pas partie de la chaîne !!
C'était là l'occasion d'utiliser un magnifique else.
etc...

Bref, un peu de sérieux dans tes programmes serait le bienvenu.

[diden138]

bonjour,

C'est un moyen de repousser le problème : les variables locales étant réservées sur la pile, son débordement n'en est que reculé en diminuant la quantité utilisée pour passer les paramètres.

1er point les variables seront réservé une seul foie sur la pile (c'est à dire le premier empilement qui correspond à celui du programme principal)
2éme point de quel pile tu parle (du display ou de la pile d'appel) il faut savoir de quoi tu parle je l'ai dit et je le redit pascal utilise une pile d'appel qui fais 16ko (procédure+variables locales) en négligeant les octets nécessaire aux (chainage dynamique,chainage statique,@retour,NT,et le display) il nous faut à chaque appel (longueur de la chaine *8octets ) +1octet du caractère je te laisse faire le calcul.
3éme point ceci n'est pas mon programme (veuillez lire en haut mes propositions) .

D'autre part, comme tu autorises la procédure à modifier les données originales, il faut te méfier

de quoi ce méfier modifier la chaine n'importe quoi on en a rien à faire, c'est juste pour compter le nombre d'occurrence d'un caractère donné.

cela implique que tu sauves la chaine originale dans une variable locale (==> cette copie sera perdue en sortant de la procédure), et que tu modifies la chaîne originale avec le delete !!
Ce n'est pas le but.
Donc, attention quand on autorise les modifications.

pas du tout ça sert juste à copier le caractère courant dans la chaine.

Cela aurait était évité en utilisant const au lieu de var pour la chaîne : le compilateur aurait détecté la tentative de modification.

oui mais on aurait pas pu faire un delete(Ph,1,1)

De plus, ta copie locale de la chaîne ne sert qu'à tester son premier caractère.

exacte est ce un problème ? j'en doute (un octet un octet même si on avait utiliser un char )

fait que l'algorithme est faux : tu ne comptes pas le dernier caractère de la chaîne d'origine.

pas du tout les chaines en pascal commence à partir de 1 pourquoi donc tester le ph[0] .

si (length(Ph) = 0), alors tu utilises des caractères qui ne font pas partie de la chaîne !!
C'était là l'occasion d'utiliser un magnifique else.

non pas du tout si tu allait voir la doc de la proc delete tu verrais dans sa première ligne ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Procedure Delete (Var S : WideString; Index,Size: SizeInt);
 If Length(S)=0 then
   exit;

cordialement @+

[droggo]

Fio,

1) révise tes notions sur les variables locales

2) vérifie ce que fait ta procédure (j'entends par là : regarde ce qu'elle fait effectivement, pas ce que tu penses qu'elle fait)
En clair, crayon + papier + chaîne exemple, et tu suis tout ce qui se passe réellement avec toutes les variables.

Et ensuite, si tu penses que ta procédure fonctionne correctement, reviens me le prouver, et pouquoi.

[darrylsite]

Vous vous etes detournées du probleme réel de l' auteur de cette discussion.
je crois que c' est meme devenu un truc du genre " c' est moi le plus fort sur ce forum".
Sinon on peut construire l' algo de l' exercice les yeux fermés en moins d' une minute.
Si vous voulez vraiment savoir le plus fort (c' est ce qui ressort dans la discussion), je crois que c' est mieux que vous vous lanciez des defis digne de ce nom.
Si vous ne le voulez pas (ou ne pouvez pas), calmez vous car nul n' est plus fort que l' autre sur ce forum.
On est tous là pour apprendre quelque chose (biensur qu' il y' en a qui sont là juste pour aider les autres).

Peace!!!!!!!!

[diden138]

je crois que c' est meme devenu un truc du genre " c' est moi le plus fort sur ce forum".

personne ne l'a dit

1) révise tes notions sur les variables locales

tu t'obstines sans avancer d'arguments, rien

2) vérifie ce que fait ta procédure (j'entends par là : regarde ce qu'elle fait effectivement, pas ce que tu penses qu'elle fait)

ok je propose mieux faisons ça ensemble.

En clair, crayon + papier + chaîne exemple, et tu suis tout ce qui se passe réellement avec toutes les variables.(j'ai apporté une petite modif notamment le else que j'avais enlever je ne sais pourquoi)

j'ai mieux un programme tout prêt qu'il va t'afficher tout

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
program incroyable;
uses crt;
var  Phrase      : string;
      Car            : char;
      NbreOcc     : byte;
 
procedure Occurence(var Ph:string;var C:char;var Nbre:byte) ;
var
    SPh : string;
begin
if (length(Ph) = 0) then   Nbre:=0;
SPh:=copy(Ph,1,1);
delete(Ph,1,1);
if(length(Ph) >0)  then
   begin
   if (SPh[1]=C) then
       Nbre := Nbre + 1;
   Occurence(Ph,C,Nbre);
   end
else if Sph[1]=c then Nbre:=Nbre+1;
writeln('Taille de Sph=',length(Sph)+1,'octets');{// un octet qui represente la longeur de la chaine//}
end;
begin
NbreOcc:=0;
writeln('Saisir une phrase :');
readln(Phrase);
writeln('Saisir un caractère :');
readln(Car);
Occurence(Phrase,Car,NbreOcc);
writeln('l''occurence de la lettre <<',Car,'>> = ',NbreOcc);
readln;
end.

alors la procédure marche correctement ou non ?
cordialement @+

[droggo]

Fio,

ok je propose mieux faisons ça ensemble.

j'ai mieux un programme tout prêt qu'il va t'afficher tout

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
program incroyable;
uses crt;
var  Phrase      : string;
      Car            : char;
      NbreOcc     : byte;
 
procedure Occurence(var Ph:string;var C:char;var Nbre:byte) ;
var
    SPh : string;
begin
if (length(Ph) = 0) then   Nbre:=0;
SPh:=copy(Ph,1,1);
delete(Ph,1,1);
if(length(Ph) >0)  then
   begin
   if (SPh[1]=C) then
       Nbre := Nbre + 1;
   Occurence(Ph,C,Nbre);
   end
else if Sph[1]=c then Nbre:=Nbre+1;
writeln('Taille de Sph=',length(Sph)+1,'octets');{// un octet qui represente la longeur de la chaine//}
end;
begin
NbreOcc:=0;
writeln('Saisir une phrase :');
readln(Phrase);
writeln('Saisir un caractère :');
readln(Car);
Occurence(Phrase,Car,NbreOcc);
writeln('l''occurence de la lettre <<',Car,'>> = ',NbreOcc);
readln;
end.

alors la procédure marche correctement ou non ?
cordialement @+

Bel essai, mais la procédure dont je parlais était :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
procedure Occurence(var Ph:string;var C:char;var Nbre:byte) ;
var
    SPh : string;
begin
if (length(Ph) = 0) then   Nbre:=0;
SPh:=copy(Ph,1,1);
delete(Ph,1,1);
if(length(Ph) >0) then
   begin
   if (SPh[1]=C) then
       Nbre := Nbre + 1;
   Occurence(Ph,C,Nbre);
   end
{// j'ai enlevé ici le else qui servait à rien ///}
end;

Tu t'es donc empressé de la corriger.

Tu n'espérais quand même pas je ne remarquerais pas ça ?

tu t'obstines sans avancer d'arguments

Puisque tu y tiens, tu as écrit

1er point les variables seront réservé une seul foie sur la pile (c'est à dire le premier empilement qui correspond à celui du programme principal)
2éme point de quel pile tu parle (du display ou de la pile d'appel) il faut savoir de quoi tu parle je l'ai dit et je le redit pascal utilise une pile d'appel qui fais 16ko (procédure+variables locales) en négligeant les octets nécessaire aux (chainage dynamique,chainage statique,@retour,NT,et le display) il nous faut à chaque appel (longueur de la chaine *8octets ) +1octet du caractère je te laisse faire le calcul.

1er point, c'est bien ce que je dis : tu n'as pas compris ce que sont les variables locales.
Si tu veux t'en convaincre, essaye ta procédure avec une chaine de 100 ou 110 caractères, et tu verras.

2ème point, ce serait presque vrai, sauf que
- la limite à 16K est due au Turbo Pascal, pas au Pascal en général (quand on parle de telles limites, il faut préciser le contexte, sinon ça ne veut rien dire)
- et cette limite n'est pas absolue, on peut la modifier.
je te laisse chercher un peu, on en a parlé il n'y a pas si longtemps dans un sujet.

pas du tout les chaines en pascal commence à partir de 1 pourquoi donc tester le ph[0]

Ce n'était pas un problème de Ph[0], mais que telle qu'était la procédure en question, tu ne prenais jamais en compte le dernier caractère de la chaîne.
Essaye la telle qu'elle était, pas ta version modifiée, et tu verras.

[diden138]

Tu t'es donc empressé de la corriger.

Tu n'espérais quand même pas je ne remarquerais pas ça ?

waw quel sens de la remarque

1er point, c'est bien ce que je dis : tu n'as pas compris ce que sont les variables locales.
Si tu veux t'en convaincre, essaye ta procédure avec une chaine de 100 ou 110 caractères, et tu verras.

rien à voir avec les variables locales le nombre d'appel récursif en pascal tout comme le C est limité par la pile d'appel, les modification que j'ai porté au code n'ont rien à voir
donc si je te suis le problème du débordement viens de la variable Sph qui reste parceque chaque appel en créera une copie ? comme je suis du genre à parler toujours avec des arguments voici le même code modifié :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
program incroyable;
uses crt;
var  Phrase      : string;
      Car            : char;
      NbreOcc     : byte;
      sph         :string[1];
procedure Occurence(var Ph:string;var C:char;var Nbre:byte) ;
begin
if (length(Ph) = 0) then   Nbre:=0;
SPh:=copy(Ph,1,1);
delete(Ph,1,1);
if(length(Ph) >0)  then
   begin
   if (SPh[1]=C) then
       Nbre := Nbre + 1;
   Occurence(Ph,C,Nbre);
   end
else if Sph[1]=c then Nbre:=Nbre+1;
writeln('Taille de Sph=',length(Sph)+1,'octets');{// un octet qui represente la longeur de la chaine//}
writeln(integer(@Sph));
end;
begin
clrscr;
NbreOcc:=0;
writeln('Saisir une phrase :');
readln(Phrase);
writeln('Saisir un caractère :');
readln(Car);
Occurence(Phrase,Car,NbreOcc);
writeln('l''occurence de la lettre <<',Car,'>> = ',NbreOcc);
readln;
end.

essaye avec 110 ou 150 caractères comme tu l'a dit il y aura un débordement

2ème point, ce serait presque vrai, sauf que
- la limite à 16K est due au Turbo Pascal, pas au Pascal en général (quand on parle de telles limites, il faut préciser le contexte, sinon ça ne veut rien dire)
- et cette limite n'est pas absolue, on peut la modifier.
je te laisse chercher un peu, on en a parlé il n'y a pas si longtemps dans un sujet.

t'a raison et pas que Turbo pascal tous compilateur 16 bits mais je n'ai pas estimé que cela était nécessaire.

Ce n'était pas un problème de Ph[0], mais que telle qu'était la procédure en question, tu ne prenais jamais en compte le dernier caractère de la chaîne.
Essaye la telle qu'elle était, pas ta version modifiée, et tu verras.

oui c'est vrai mais si tu lisais le début de ce topic tu verrais que le else était la et on l'avait enlevé.
maintenant si tu persiste j'aimerais bien voir ta ou tes propositions
cordialement @+

[droggo]

Fei,

Pour ta dernière remarque, figure-toi que je ne suis pas censé faire la compilation de tous tes morceaux de code, mais regarder le dernier code publié, en l'occurrence celui qui était cité dans mon message.

Si tu veux réellement progresser, apprends comment fonctionnent les variables locales, car me soutenir que ça n'a pas de rapport avec la pile montre que tu n'as absolument pas compris.

Les variable locales sont réservées sur la pile pour chaque appel de la procédure, c'est pour ça qu'elles s'appellent locales.

Pour t'en convaincre, prends ta procédure précédente, et ta nouvelle version, et regarde quelles sont les limites atteintes pour le nombre de caractères, ou reprends ton ancienne procédure, et ajoute-lui l'affichage de l'adresse de ta chaîne locale.

Bon, je laisse tomber. Pas faute d'argument, mais face à ton entêtement.

[diden138]

Les variable locales sont réservées sur la pile pour chaque appel de la procédure, c'est pour ça qu'elles s'appellent locales.

ce que j'ai dit précédemment

les appels récursive sont très couteux car ça implique la sauvegarde de tous l'environnement de travail (pile(@de retour,cs,cd...)+le display(qui indique à chaque foie ou débute le programme d'exécution) ) donc une chaine de 20 caractères implique 20 appel récursives les 16ko de la pile(en pascal) ne suffisent plus.

et

les variables seront réservé une seul foie sur la pile (c'est à dire le premier empilement qui correspond à celui du programme principal)

... pascal utilise une pile d'appel qui fais 16ko (procédure+variables locales) en négligeant les octets nécessaire aux (chainage dynamique,chainage statique,@retour,NT,et le display) il nous faut à chaque appel (longueur de la chaine *1octet ) +1octet du caractère je te laisse faire le calcul.

j'ai l'impression tu lis pas ce que j'écris
cordialement @+

[droggo]

Foi,

j'ai l'impression tu lis pas ce que j'écris

Bon cette fois, c'est vraiment la dernière : pour la pile, tu as dit et redis que ça ne dépendait pas des variables locales, entre autres parmi tes rappels ci-dessus:

les variables seront réservé une seul foie sur la pile (c'est à dire le premier empilement qui correspond à celui du programme principal)

"Une seule fois", ce n'est pas "pour chaque appel de la fonction"

les appels récursive sont très couteux car ça implique la sauvegarde de tous l'environnement de travail (pile(@de retour,cs,cd...)+le display(qui indique à chaque foie ou débute le programme d'exécution) ) donc une chaine de 20 caractères implique 20 appel récursives les 16ko de la pile(en pascal) ne suffisent plus.

Si tu vois là-dedans le fait que tu parles des variables globales, je vais avoir besoin d'une explication de texte.

... pascal utilise une pile d'appel qui fais 16ko (procédure+variables locales) en négligeant les octets nécessaire aux (chainage dynamique,chainage statique,@retour,NT,et le display) il nous faut à chaque appel (longueur de la chaine *1octet ) +1octet du caractère je te laisse faire le calcul.

Là, ça transparait un peu, mais tu confonds allègrement la taille occupée par ta chaîne, soit 256 octets, et sa longueur.

Je n'ajouterais pas tes litanies de mauvaise foi qui sont si claires que tous les lecteurs les ont remarquées, mais petit exemple :

En publiant une nouvelle version de ta procédure, tu dis

alors la procédure marche correctement ou non

Étant donné que ce n'est plus celle que je critiquais, je n'ai pas dit le contraire, mais

Bel essai, mais la procédure dont je parlais était ...

et après quelques remarques, tu ajoutes

oui c'est vrai mais si tu lisais le début de ce topic tu verrais que le else était la et on l'avait enlevé.

Oui, tu l'avais enlevé, et je n'ai pas dit que tu n'en avais pas le droit, mais ne vient pas faire péter ça après coup, car, dans la version que j'ai critiquée, il y avait ceci :

{// j'ai enlevé ici le else qui servait à rien ///}

donc il ne sert à rien, mais quand il faut que tu le remettes, tout à coup tu te vantes de l'avoir remis.

Si ce n'est pas de la mauvaise foi, alors je suis le fils du pape.

--------------------

Et là, je change de ton : je te rappelle que je n'ai fait que critiquer ta procédure, qui, en l'état, ne fonctionnait pas du tout correctement, et il y avait dedans tant de choses mal conçues que j'ai ajouté : une peu de sérieux etc.

Opinion que je maintiens totalement, car je constate qu'il t'a quand même fallu pas mal de remarques, pas seulement les miennes, pour que tu réussisses à pondre une version fonctionnelle.

Et ne me redemande pas d'en faire une à mon tour, j'ai assez insisté sur le fait qu'utiliser la récursivité pour un tel problème était absurde.
En plus, écrire une procédure dont le temps de création dépend essentiellement de ma vitesse de frappe au clavier n'a pas le moindre intérêt

[katrena99]

En plus, écrire une procédure dont le temps de création dépend essentiellement de ma vitesse de frappe au clavier n'a pas le moindre intérêt

J'adore cette phrase !
Je crois que je vais en faire ma signature dans ce forum...

[droggo]

Xoe,

J'adore cette phrase !
Je crois que je vais en faire ma signature dans ce forum...