Discussion :

[bremer]

Bonjour,

Y a t il un moyen en Delphi de faire une boucle for avec un incrément de pas de 3.

Je sait le faire en PHP mais en delphi...

Merci d'avance,

Laurent

[ShaiLeTroll]

Soit écrire un While
Soit faire "iReel := iFor * 3"
Soit il faut te faire soigner, si tu tente

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 ForDeMalade();
var
  I: Integer;
begin
  for I := 0 to 9+2 do // 9 la limite voulu, +2 pour la tricherie
  begin
    ShowMessage(IntToStr(I));
    // Inc(I);
    asm
      INC EBX;
      INC EBX;
    end;
  end;
end;

Moi aussi, j'étais habitué au langage des calculatrices HP, et tu pouvais fixer le STEP, cela m'a aussi étonné que l'on ne puisse pas le faire en Delphi, mais en 10 ans, je m'y suis fait

[mick605]

Soit écrire un While
Soit faire "iReel := iFor * 3"

Moi aussi, j'étais habitué au langage des calculatrices HP, et tu pouvais fixer le STEP, cela m'a aussi étonné que l'on ne puisse pas le faire en Delphi, mais en 10 ans, je m'y suis fait

Le mieux je pense, c'est de multiplier par 3 ...
Je programmais aussi sur calculatrice, meme remarque ...

Mais en fait, je trouve assez rare d'utiliser un incrément différent de 1 ...

[FullSpeed]

les jeunes
Cela ne vient pas des HP mais du basic
car il n'existait pas de while ou repeat alors le For etait muscle

I y a Fullspeed qui me souffle a l'oreille

Toujours préférer le repeat à un for ou un while (quand c'est possioble)
(et cela l'est toujours)
SAUF avec Delphi car seules les boucles For sont optimis"es
(les petits malins verront que D6 les remplace par des repeat;:

Shai: c'est très vilain de faire comme tu le dis. Je suis sup que c'est un programmeur C++ qui te l'as appris

Boris

[peter27x]

Moi aussi je trouve que le mieux c'est de multiplier par 3 (par ex. si tu voulais faire "step 3"):

Code :

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

1
2
3
4
5
6
7
8
 
for i := 0 to 4 do
begin
  j := i * 3;
 
  // et là tu as plus qu'à utiliser j... qui vaudra 0,3,6,9 et enfin 12 (pour i = 0,1,2,3,4)
  ...
end;

[bremer]

Merci à tous.

C'est ok avec la dernière solution.

Laurent

[sat83]

Je n'ai pas Delphi sous la main, mais si mes souvenirs sont bons, il est possible de spécifier directement le pas d'incrément :

Code :

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

1
2
3
4
for i:=0 to 100 step 3 do
begin
//
end;

[Cl@udius]

Je n'ai pas Delphi sous la main, mais si mes souvenirs sont bons, il est possible de spécifier directement le pas d'incrément :

Code :

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

1
2
3
4
for i:=0 to 100 step 3 do
begin
//
end;

Non pas du tout, le step n'a jamais existé sous Delphi.

[peter27x]

Je n'ai pas Delphi sous la main, mais si mes souvenirs sont bons, il est possible de spécifier directement le pas d'incrément :

Code :

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

1
2
3
4
for i:=0 to 100 step 3 do
begin
//
end;

LOL tes souvenirs sont sûrement oniriques.

[peter27x]

Non pas du tout, le step n'a jamais existé sous Delphi.

Ou bien : la steppe n'a jamais existé sous Delphine.

Delphine ? Ma voisine de 150kg.

[FullSpeed]

C'est exactement se que l'optimiseur fait lorsqu'il inverse les boucles
il creer un nouvel indice different de I
Boris

[mick605]

les jeunes
Cela ne vient pas des HP mais du basic
car il n'existait pas de while ou repeat alors le For etait muscle

I y a Fullspeed qui me souffle a l'oreille

Toujours préférer le repeat à un for ou un while (quand c'est possioble)
(et cela l'est toujours)
SAUF avec Delphi car seules les boucles For sont optimis"es
(les petits malins verront que D6 les remplace par des repeat;:

Shai: c'est très vilain de faire comme tu le dis. Je suis sup que c'est un programmeur C++ qui te l'as appris

Boris

1 > Je n'ai jamais parlé de HP ... Je programmais sur TI en TIBasic
2 > Le while ET le repeat existent en TIBasic, ainsi que le for avec incrément différent de 1
3 > rien que pour la compréhension et la lisibilité, je préfererai toujours un for a un repeat ou un while

[peter27x]

1 > Je n'ai jamais parlé de HP ... Je programmais sur TI en TIBasic
2 > Le while ET le repeat existent en TIBasic, ainsi que le for avec incrément différent de 1
3 > rien que pour la compréhension et la lisibilité, je préfererai toujours un for a un repeat ou un while

C'est donc bien là ce que tu penses dans ton for intérieur ?

[elootam]

Bonjour.

Moi aussi je voulais lire un fichier texte "pas à pas" par saut de 3 donc.. Après réflexion j'ai écris cela et.. ça marche puisque (cerveau tordu !!) si on divise le "pas" par 3 et s'il n'y a pas de partie décimale, on est sur un multiple de 3 !!!

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
function decoupe(chaine:string);
var
  i:integer;
  m,n:real;
  Longueur: Integer;
begin
  Longueur := Length(chaine);
  i:=0;
  while i<longueur+1 do
  begin
    m:=i / 3;
    n:=round(i / 3);
    if m-n=0 then
    begin
      // Multiple de 3    
    end;
    i:=i+1;
  end;
end;

[ALWEBER]

La réponse de chatgpt :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
program BoucleForStepModulo;
 
var
  i: integer;
 
begin
  // Boucle de 1 à 100 par pas de 3
  for i := 1 to 100 do
  begin
    // Vérifie si i est divisible par 3 en utilisant le modulo
    if (i mod 3 = 0) then
      writeln(i);
  end;
end.

[Andnotor]

Et si tu faisais juste i := i +3

ps: comparer des réels sans epsilon est voué à l'échec.

[ShaiLeTroll]

Tu devrais créer un nouveau sujet sur l'objectif réel de ta fonction decoupe, on pourrait réfléchir peut-être à un algo plus adapté (surtout que ce sujet est déjà marqué comme résolu)


on peut aussi écrire Inc(i, 3); qui aurait ma préférence dans une boucle, cette syntaxe attire l'œil plus qu'un i := i + 3;


comment gères-tu le cas du reliquat ?

Tu commences à zéro, pour une chaine ? tu n'utilise que des fonctions zero-based par la suite ?

Tu arrives à la fin, la longueur de la chaine (soit le dernier élément) n'est pas un multiple de 3, tu dois penser à ne traiter que les caractères restants sans dépasser.


il semble plus prudent d'écrire un while, permettant plus de liberté que contourner le for ! non ?

Pourquoi écrire des divisions ou du modulo, opération lente lorsque l'on peut travailler avec de simple addition ?

la réponse de ChapGPT est loin du compte, une boucle à itération statique au lieu d'une longueur de chaine, c'est bien cet outil, cela va créer une nouvelle génération de développeur encore plus débile que celle qui ne connait pas la touche F1, le fossé entre les bons développeurs et la grande majorité constituée des développeurs moyens voire médiocres ne va que se creuser. Déjà que beaucoup ne savent pas faire une recherche Google qui solutionne 99% des problèmes selon mon expérience, il n'y aura même plus d'effort à fournir vers le beau métier de Prompt Engineer

le temps avec mod c'est 3 fois plus lent sur la boucle nue, c'est affligeant !
Cependant, le temps de boucle peut sembler négligeable lorsque l'on manipule des chaines, l'écart se réduit à 20% de plus avec mod

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
var
  I, RMod, RInc: Integer;
  K, KMod, KInc: Int64;
  TickStart, TickEnd, TickPerSec: Int64;
  TimeMod, TimeInc: Double;
  S, SRMod, SRInc: string;
begin
  QueryPerformanceFrequency(TickPerSec);
 
  SetLength(S, 10000);
  for I := 1 to Length(S) do
    S[I] := Chr(Ord('0') + (I mod 10));
 
  QueryPerformanceCounter(TickStart);
 
  KMod := 0;
  // stupide de commencer à 1 avec (i mod 3 = 0) puisque cela est True qu'à partir de 3 !
  for I := 3 to Length(S) do
  begin
    // Vérifie si i est divisible par 3 en utilisant le modulo
    if (I mod 3 = 0) then
      Inc(KMod);
  end;
 
  QueryPerformanceCounter(TickEnd);
  TimeMod := (TickEnd - TickStart) / TickPerSec * MSecsPerSec;
 
  QueryPerformanceCounter(TickStart);
 
  KInc := 0;
  I := 3; // On commence avec un multiple de 3, soit 0 soit 3 selon le besoin
  while I <= Length(S) do
  begin
    inc(KInc);
 
    Inc(I, 3);
  end;
 
  QueryPerformanceCounter(TickEnd);
 
  TimeInc := (TickEnd - TickStart) / TickPerSec * MSecsPerSec;
  ShowMessage(KMod.ToString() + ' -> ' + TimeMod.ToString()
    + sLineBreak + KInc.ToString() + ' -> ' + TimeInc.ToString()
    + sLineBreak + (TimeMod / TimeInc).ToString());
 
  QueryPerformanceCounter(TickStart);
 
  KMod := 0;
  RMod := 3;
  // stupide de commencer à 1 avec (i mod 3 = 0) puisque cela est True qu'à partir de 3 !
  for i := 3 to Length(S) do
  begin
    // Vérifie si i est divisible par 3 en utilisant le modulo
    if (i mod 3 = 0) then
    begin
      K := Copy(S, I - 2, 3).ToInteger();
      Inc(KMod, K);
 
      RMod := I;
    end;
  end;
  if RMod <= Length(S) then
    SRMod := Copy(S, RMod, Length(S) - RMod + 1);
 
  QueryPerformanceCounter(TickEnd);
  TimeMod := (TickEnd - TickStart) / TickPerSec * MSecsPerSec;
 
  QueryPerformanceCounter(TickStart);
 
  KInc := 0;
  I := 3; // On commence avec un multiple de 3, soit 0 soit 3 selon le besoin
  RInc := I;
  while I <= Length(S) do
  begin
    // Vérifie si i est divisible par 3 en utilisant le modulo
    K := Copy(S, I - 2, 3).ToInteger();
    Inc(KInc, K);
 
    RInc := I;
    Inc(I, 3);
  end;
  if RInc <= Length(S) then
    SRInc := Copy(S, RInc, Length(S) - RInc + 1);
 
  QueryPerformanceCounter(TickEnd);
 
  TimeInc := (TickEnd - TickStart) / TickPerSec * MSecsPerSec;
  ShowMessage(KMod.ToString() + ' -> ' + TimeMod.ToString() + ' + ' + SRMod
    + sLineBreak + KInc.ToString() + ' -> ' + TimeInc.ToString() + ' + ' + SRInc
    + sLineBreak + (TimeMod / TimeInc).ToString());
 
end;

SRMod et SRInc montre le reliquat non traité dans la boucle à éventuellement prendre en compte

[ALWEBER]

la réponse de ChapGPT est loin du compte, une boucle à itération statique au lieu d'une longueur de chaine, c'est bien cet outil, cela va créer une nouvelle génération de développeur encore plus débile que celle qui ne connait pas la touche F1, le fossé entre les bons développeurs et la grande majorité constituée des développeurs moyens voire médiocres ne va que se creuser. Déjà que beaucoup ne savent pas faire une recherche Google qui solutionne 99% des problèmes selon mon expérience, il n'y aura même plus d'effort à fournir vers le beau métier de Prompt Engineer

ChapGPT répond correctement dans 70% des cas selon mon expérience et aussi si tu lui pose la bonne question ... La partie résiduelle n'est pas traitée ici mais peut l’être aisément

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
 
program BoucleForStepModulo;
var
  i: integer;
  .../...
begin
  for i := 1 to  Length(chaine) do
  begin
    // Vérifie si i est divisible par 3 en utilisant le modulo
    if (i mod 3 = 0) then
    begin
      // Multiple de 3    
    end;
  end;
end.

[Andnotor]

on peut aussi écrire Inc(i, 3); qui aurait ma préférence dans une boucle, cette syntaxe attire l'œil plus qu'un i := i + 3;

C'était plus pour exprimer le côté mathématique de la chose

[anapurna]

Bonjour
algorithmiquement parlant
la boucle for et while sont identique
le for n'est qu'une spécialisation du while
qui dit spécialisation dit aussi optimisation

il y a une multitude de choix mais les principeaux sont donc

Code :

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

1
2
3
4
5
6
7
8
 
i:=0 ;
While i < Value do 
Begin 
   // j:= i DIV 3 
   // Ici je fais ce que j'ai à faire 
    Inc(i,3) ;//3;6;9;...
End;

L'autre solution

Code :

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

1
2
3
4
5
6
7
8
9
 
i:=0 ;
MaxVal := (Value Div 3); 
For j := 0 to  MaxVal Do 
Begin
   I:= J*3;//0;3;6;9;....
   // Ici je fais ce que j'ai à faire  
   // Inc(i,3) ;//3;6;9;...
End;

A toi de voir ce que tu préfère comme syntaxe
le "repeat until" est un peu diffèrent
il passe au moins une fois dans la boucle