Remplacement de chaine dans un string

Version imprimable

Voir 40 message(s) de cette discussion en une page

29/01/2009, 21h27
BuzzLeclaire

Remplacement de chaine dans un string

Bonjour à tous,

J'ai besoin d'un coup de main.
Comment intervertire 2 chaines à l'interieur d'une même chaine.

Chaine de départ :
"FC000040411010000121208Fact FC000040 test Test test 01 35,88 0,00"

j'aimerais intervertire dans cette chaine
la chaine 1 : " 35,88"
avec la chaine 2 : " 0,00"

Je sais précisement où se trouve ces deux chaines
chaine 1 : commence à 84 et fait 20 caracteres de long
chaine 2 : commence à 104 et fait 20 caracteres de long

Pour obtenir ce résultat :
"FC000040411010000121208Fact FC000040 test Test test 01 0,00 35,88"

Je cherche encore mais j'ai pas trouvé.

Je ne peux pas utiliser StringReplace car la valeur de chaine 1 et chaine 2 change à chaque string, seul 84,20 ne change pas.

Merci pour vos lumière.
29/01/2009, 22h12
dragonno

1) mettre dans la variable "partie1" la sous-chaine commençant à la position N de la chaine.

2) mettre dans la variable "partie2" la sous-chaine commençant à la position M de la chaine.

3) Mettre la variable "partie1" à la place de la chaine se trouvant en position M de la chaine.

4) Mettre la variable "partie2" à la place de la chaine se trouvant en position N de la chaine.

salut

par exemple comme ça..
Code:

1 2 3 4 5 6 7 8 9 10 11 12 function TForm1.permute(st:string):string; var temp:string; deb,fin:integer; begin result:=''; deb:=55; // debut de la 1er chaine fin:=6; // fin de la 1er chaine temp:=copy(st,deb,fin); delete(st,deb,fin); result:=st+temp; end;
Avec ta ligne exemple tes valeurs ne marche pas, j'ai pris 55 et 6
chaine 1 : commence à 84 et fait 20 caracteres de long

bye

Merci de vos reponsés.

Impossble d'utiliser ta proposition, car je ne pourrais pas faire la deuxième permutation qui se trouve sur la même ligne ?

si je remplace "32,88" par "0,00"
et ensuite "0,00" par "32,88"
attention dans le même string
Lors du premier remplacement le nouveau string à 2 fois "0,00" et donc il me remplacera ensuite le premier "0,00" par "32,88"..

je reviens au départ...

Voilà ce que j'ai fais, mais vous aller rire j'arrice pas à faire marcher Lenght()

ptr...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 .. .. // Chaine1 devient chaine2 et vice et versa... // Ligne est à ma ligne de string. Chaine1 := AnsiMidStr(Ligne,84,20); Chaine2 := AnsiMidStr(Ligne,104,20); Ligne := AnsiMidStr(Ligne,0,83)+Chaine2 +Chaine1 +AnsiMidStr(Ligne,124,1254); // 1254 car Lenght(Ligne) marche pas !!!! .. ..

salut

Code:

1
2
3
4
5
  ChaineRoot := Copy(Ligne,1,84);
  Chaine1 := Copy(Ligne,84,20);
  Chaine2 := Copy(Ligne,104,20);
  ChaineFin := Copy(Ligne,124,length(Ligne)-124);
  Ligne :=   ChaineRoot+Chaine2+Chaine1+ChaineFin;

@+ Phil

Encore une autre proposition ;)

Code:

1
2
3
4
5
6
7
function Permute(aValue :string) :string;
begin
  SetLength(Result, 124);
  Move(aValue[1],   Result[1],   83);
  Move(aValue[104], Result[84],  20);
  Move(aValue[84],  Result[104], 20);
end;

30/01/2009, 09h37
cincap

Exemple concret !

Bonjour,

@ Andnotor, je suis intéressé par ta fonction mais apparemment je ne sais pas l'utiliser comme il se doit.

Aurais tu un exemple de code avec la chaine de départ ?

Merci d'avance,

@+,

Cincap

La chaîne de départ ne correspond pas exactement à la donnée (Offsets, longeurs) :roll:

Construis-en une toi-même:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function Permute(aValue :string) :string;
begin
  SetLength(Result, 123);
  Move(aValue[1],   Result[1],   83);
  Move(aValue[104], Result[84],  20);
  Move(aValue[84],  Result[104], 20);
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  ShowMessage(Permute(StringOfChar('a', 83)
                     +StringOfChar('b', 20)
                     +StringOfChar('c', 20)));
end;

30/01/2009, 10h12
cincap

Ok merci pour l'info !

@ andnotor, merci pour l'info, c'est toujours bon à savoir.

@+,

Cincap

Bonjour et merci à vous.

Anapurna, ta proposition fonctionne trés bien.
Code:

1 2 3 4 5 ChaineRoot := Copy(Ligne,1,84); Chaine1 := Copy(Ligne,84,20); Chaine2 := Copy(Ligne,104,20); ChaineFin := Copy(Ligne,124,length(Ligne)-124); Ligne := ChaineRoot+Chaine2+Chaine1+ChaineFin;
AndNotOr, ta proposition, ne fonctionne pas Le string final est tronqué et je perd des informations je passe de 1254 de long à 124.
Code:

1 2 3 4 5 6 7 function Permute(aValue :string) :string; begin SetLength(Result, 124); Move(aValue[1], Result[1], 83); Move(aValue[104], Result[84], 20); Move(aValue[84], Result[104], 20); end;
La mienne, fonctionne bien également, mais je suis obligé de focer la longueur de mon string car lenght ne foncitonne pas lol.
Code:

1 2 3 4 // Le debit devient credit et vice et versa... Debit := AnsiMidStr(ReplaceLigne,84,20); Credit := AnsiMidStr(ReplaceLigne,104,20); ReplaceLigne := AnsiMidStr(ReplaceLigne,0,83)+Credit+Debit+AnsiMidStr(ReplaceLigne,124,1254); // 1254 car lenght(Ligne) marche pas...
Pour le moment j'opte pour la solution de anapurna qui est meilleur que la mienne. J'attends la correction d'AndNotOr ou ces remarques.

Merci encore à vous.

Rebonjour

j'ai trouvé mon erreur, donc voici ma proposition qui utilise moins de variable que celle de anapurna.
Code:

1 2 3 4 Debit := AnsiMidStr(ReplaceLigne,84,20); Credit := AnsiMidStr(ReplaceLigne,104,20); ReplaceLigne := AnsiMidStr(ReplaceLigne,0,83)+Credit+Debit+AnsiMidStr(ReplaceLigne,124,length(Ligne)); // pour info Ligne et la variable envoyé dans cette procedure déclarer procedure TFPrincipal.Traitement(const ligne :String);
Mais est-elle plus rapide que celle d'anapurna ? (ou la futur de AndNotor )

Voilà chef ;)

Code:

1
2
3
4
5
6
7
8
function Permute(aValue :string) :string;
begin
  SetLength(Result, Length(aValue));
  Move(aValue[1],   Result[1],   83);
  Move(aValue[104], Result[84],  20);
  Move(aValue[84],  Result[104], 20);
  Move(aValue[124], Result[124], Length(aValue) -123);
end;

Code:

1
2
3
4
5
6
function Permute(aValue :string) :string;
begin
  Result := aValue;
  Move(aValue[104], Result[84],  20);
  Move(aValue[84],  Result[104], 20);
end;

30/01/2009, 11h59
BuzzLeclaire

Rebonjour à tous.

Voilà lles resultat
j'ai pris un fichier réelle comportant 7000 lignes

Ma fonction : 4 secondes et 1 centièmes (4,1)
Anapurna : 3 secondes et 8 centièmes (3,8)
AndNotOr (1): 3 secondes et 6 centièmes (3,6)
AndNotOr (2) : 4 secondes et 3 centièmes (4,3) (la plus courte)

C'est clair la mienne qui pourtant utilise moin de variable est la plus lente !! ptr..

Je prends donc celle d'AndNotOr (a moins que quelqu'un soit plus rapide)

MErci encore à vous deux.

Franchement chapeau !!
30/01/2009, 12h18
BuzzLeclaire

Juste pour finir

j'ai fait un test sur 70000 lignes

Ma fonction : 1 minutes 44 secondes et 9 centièmes (01:44.9)
Anapurna : 1 minutes 33 secondes et 9 centièmes (01:33.9)
AndNotOr (1): 1 minutes 43 secondes et 6 centièmes (01:43.6)

Hallucinant c'est celle de Anapurna qu'il l'emporte maintenant !!! :aie:

Bon bah je change...

MErci probleme résolu.
30/01/2009, 12h53
anapurna

salut

si tu veut moins de variable

Code:

Chaine := Copy(Ligne,1,84)+Copy(Ligne,104,20)+Copy(Ligne,84,20)+Copy(Ligne,124,length(Ligne)-124);

@+ Phil

Le Move doit de toute façon être beaucoup plus rapide! Ce qui prend du temps sur tes boucles est les 70'000 appels à la fonction Permute (70'000 sauvegarde/restauration des registres, SetLength, etc.).

Trois petits tests rapides (1'000'000 de boucles).

Le premier Prend 938 ms (La fonction que j'ai proposée précédemment).
Code:

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 function Permute(aValue :string) :string; begin SetLength(Result, Length(aValue)); Move(aValue[1], Result[1], 83); Move(aValue[104], Result[84], 20); Move(aValue[84], Result[104], 20); Move(aValue[124], Result[124], Length(aValue) -123); end; procedure TForm1.FormCreate(Sender: TObject); var s1 :string; i, t :Integer; begin s1 := StringOfChar('a', 83) +StringOfChar('b', 20) +StringOfChar('c', 20) +StringOfChar('d', 1000); t := GetTickCount; for i := 1 to 1000000 do s1 := Permute(s1); Caption := inttostr(GetTickCount -t); end;
Dans ce deuxième exemple, le paramètre de Permute est déclaré Const ce qui évite de perdre du temps à réallouer une deuxième chaîne temporaire pour la fonction:

Le temps est déjà réduit à 594 ms.

Code:

function Permute(const aValue :string) :string;

Dans ce troisième exemple, une chaîne tampon de 20 caractères et créée une fois et la permutation se fait directement dans la boucle sur la chaîne d'origine.

Ce troisième essai ne prend plus que 47 ms 8-)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 procedure TForm1.FormCreate(Sender: TObject); var s1, s2 :string; i, t :Integer; begin s1 := StringOfChar('a', 83) +StringOfChar('b', 20) +StringOfChar('c', 20) +StringOfChar('d', 1000); t := GetTickCOunt; SetLength(s2, 20); for i := 1 to 1000000 do begin Move(s1[84], s2[1], 20); Move(s1[104], s1[84], 20); Move(s2[1], s1[104], 20); end; Caption := inttostr(GetTickCount -t); end;

30/01/2009, 13h57
ero-sennin

Alors là, je dis :king:

Explications très claires. Etant grandement intéressé aussi par le côté optimisation, j'aurai jamais cru qu'une simple allocation comme tu l'as fait pour s2 ait un impact à ce point.

12/13 fois plus rapide que la version sans allocation, voilà qui est clair !
Chapeau. :mrgreen:

Re-salut

Moi je dis que ce AndNotOr est un malade :mouarf:
C'est un sacré PGM..

Alors j'ai fais mes tests qui evidement ne fait pas que permuté une chaine dans une chaine d'ou la longueur que j'ai temporisé plus bas, et comme le dis trés justement AndNotOr.

Avec la dernière solution je viens de gagner 15 secondes sur un fichier de 70000 lignes soit
AndNotOr : 1 minutes 18 secondes et 5 centièmes (1:18.5)

Tout simplement incroyable.

Alors je me suis dis ça se trouve si je donne l'ensemble du traitement il se peux que notre AndNotor deviennent carémment Chtarbé et nous ponds un de ces truc que seul lui à le secret alors voilà.. :

Code:

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
procedure TFPrincipal.Traitement(const ligne :String);
Var
  ReplaceLigne, Debit, Credit : String;
  Fichier: TextFile;
  CheminEtFichierDestination: String;
  ChaineRoot, ChaineFin: String;
  s2 :string;
Begin
 
  CheminEtFichierDestination := CheminFichierDat + FichierDestination;
 
// On remplace le premier 411 trouvé par LabCompteFrs
  if AnsiMidStr(Ligne,9,3) = '411' then
    ReplaceLigne := StringReplace(Ligne,AnsiMidStr(Ligne,9,3),LabCompteFrs.Text,[])
  else
// On remplace le premier 707 trouvé par LabCompteAchat
    if AnsiMidStr(Ligne,9,3) = '707' then
      ReplaceLigne := StringReplace(Ligne,AnsiMidStr(Ligne,9,3),LabCompteAchat.Text,[])
    else
// On remplace le premier 4457 trouver par LabCompteTVA
      if AnsiMidStr(Ligne,9,4) = '4457' then
        ReplaceLigne := StringReplace(Ligne,AnsiMidStr(Ligne,9,4),LabCompteTVA.Text,[]);
 
 
// Ma fonction // Pour Mémoire
// Le debit devient credit et vice et versa...
//  Debit := AnsiMidStr(ReplaceLigne,84,20);
//  Credit := AnsiMidStr(ReplaceLigne,104,20);
//  ReplaceLigne := AnsiMidStr(ReplaceLigne,0,83)+Credit+Debit+AnsiMidStr(ReplaceLigne,124,length(Ligne));//1254);
 
// Andnotor
// 1) ReplaceLigne := Permute(ReplaceLigne); // Pour Mémoire
// 2) 
  SetLength(s2, 20);
  Move(ReplaceLigne[84],  s2[1],   20);
  Move(ReplaceLigne[104], ReplaceLigne[84],  20);
  Move(s2[1],   ReplaceLigne[104], 20);
 
// Anapurna // Pour mémoire
//  ChaineRoot := Copy(Ligne,1,84);
//  Debit := Copy(Ligne,84,20);
//  Credit := Copy(Ligne,104,20);
//  ChaineFin := Copy(Ligne,124,length(Ligne)-124);
//  ReplaceLigne := ChaineRoot+Credit+Debit+ChaineFin;
 
// Affectation de la variable Fichier vers le fichier
  AssignFile(Fichier, FichierDestination);
// Ouverture du fichier
  if not FileExists(FichierDestination) then
    Rewrite(Fichier)
  else
  Begin
    Reset(Fichier);
    Append(Fichier);
  end;
// Ecriture dans le fichier
  Writeln(Fichier, ReplaceLigne);  // On écris le resultat ligne à ligne
  // Fermeture du fichier
  CloseFile(Fichier);
 
end;

La procédure qui fait appel au traitement.
Je met l'ensemble du fichier dans un TStringList puis je traite ligne par ligne.

Code:

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
procedure TFPrincipal.JvTraitementClick(Sender: TObject);
Var
  i: Integer;
begin
  JvProgress.Visible := True;
  Label1.Visible := True;
  GroupBox1.Visible := False;

  with TStringList.Create do
  Begin
    Try
      LoadFromFile(CheminEtFichierDat);
      JvProgress.Visible := True;
      JvProgress.Min := 0;
      JvProgress.Max := Count;
      For i:= 0 to Count-1 do
      begin
        Traitement(Strings[i]); // Appel de la procedure de Traitement
        JvProgress.Position := JvProgress.Position + 1;
        Application.ProcessMessages;
      end;
      JvProgress.Position := JvProgress.Max;
      JvTraitement.Visible := False;
      Label1.Caption := 'Traitement Terminé';
      StatusBar1.SimpleText := 'Le Fichier : ' + FichierDat + ' a été traité. Destination : ' + CheminFichierDat + FichierDestination;
    Finally
      Free;
    end;
  end;
end;

On ne sais jamais je peux peut-être encore espérer un traitement plus rapide.

Je remt ce tag non-résolu juste pour suivre.
Si pas de réponse évidement je prends la procédure d'AndNotOr.

PS : AndNotOr.. je l'aurai un jour...je l'aurai.... ;)

Tout ca ma donner envie de réflechir un peu plus voici les résultat

1minutes 4secondes et 3centièmes (01:04.3)

64843 ms

Code:

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
procedure TFPrincipal.JvTraitementClick(Sender: TObject);
Var
  i: Integer;
begin
  JvProgress.Visible := True;
  Label1.Visible := True;
  
  GroupBox1.Visible := False;
  with TStringList.Create do
  Begin
    Try
      LoadFromFile(CheminEtFichierDat);
      JvProgress.Visible := True;
      JvProgress.Min := 0;
      JvProgress.Max := Count;
      For i:= 0 to Count-1 do
      begin
        Strings[i] := Traitement(Strings[i]);
        JvProgress.Position := JvProgress.Position + 1;
        Application.ProcessMessages;
      end;
      SaveToFile(CheminFichierDat+FichierDestination);
      JvProgress.Position := JvProgress.Max;
      JvTraitement.Visible := False;
      Label1.Caption := 'Traitement Terminé';
      StatusBar1.SimpleText := 'Le Fichier : ' + FichierDat + ' a été traité. Destination : ' + CheminFichierDat + FichierDestination;
    Finally
      Free;
    end;
  end;
end;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
function TFPrincipal.Traitement(const ligne :String): String;
Var
  ReplaceLigne, s2 :string;
Begin
  result := '';
 
  if AnsiMidStr(Ligne,9,3) = '411' then
    ReplaceLigne := StringReplace(Ligne,AnsiMidStr(Ligne,9,3),LabCompteFrs.Text,[])
  else
    if AnsiMidStr(Ligne,9,3) = '707' then
      ReplaceLigne := StringReplace(Ligne,AnsiMidStr(Ligne,9,3),LabCompteAchat.Text,[])
    else
      if AnsiMidStr(Ligne,9,4) = '4457' then
        ReplaceLigne := StringReplace(Ligne,AnsiMidStr(Ligne,9,4),LabCompteTVA.Text,[]);
 
// Andnotor
  SetLength(s2, 20);
  Move(ReplaceLigne[84],  s2[1],   20);
  Move(ReplaceLigne[104], ReplaceLigne[84],  20);
  Move(s2[1],   ReplaceLigne[104], 20);
 
  result := ReplaceLigne;
 
end;

J'ai transformé la procedure traitement en function qui retourne le resultat du calcul d'AndNotOr.
Donc je n'ecris qu'une fois sur le fichier destination via :
Savetofile de TStringlist.

Mais là j'ai une question sur un comportement totalement inattendu.

Si je laisse le programme en Sayontop (traitement et progress bar visible) le temps est celui indiqué ci-dessus 64832 ms, maintenant si je le mets en dessous comme une tâche cachée alors là..
incroyable j'atteinds un temps en dessous des 15 secondes pour l'ensemble 9454 ms... 8O !!!!!!!!!!

31/01/2009, 12h19
BuzzLeclaire

Merci encore AndNotOr

:king::king:

Voir 40 message(s) de cette discussion en une page