Effizienteste Datenverarbeitung eines Strings

[himitsu]

Was verstehst du unter Effizient?
- einfach
- einfach + etwas schneller
- noch schneller (nicht so einfach)

[hedie]

Danke für eure antworten...

Zitat von himitsu:

Was verstehst du unter Effizient?
- einfach
- einfach + etwas schneller
- noch schneller (nicht so einfach)

- theoretisch ja noch schneller, aber da es nachvolziehbar sein sollte: einfach + etwas schneller...
es sei den etwas schneller ist zu langsam

Es handelt sich um bis zu 128000 Zeichen

Kannst du ein paar beispiele machen oder suchworte liefern?
Danke

Zitat von Furtbichler:

Am effizientesten?

Code:

start = 1;
wiederhole
  posG = Pos('G', Start);
  Verlasse die Schleife, wenn posG = 0;
  posKomma = Pos(',') ab PosG;
  Zahl1 = TextZwischen(posG + 1, posKomma - 1);
  posSemikolon =Pos(';') ab PosKomma;
  Zahl2 = TextZwischen(posSemikolon + 1, posKomma2 - 1);
  Start = posSemikolon + 1

Das ist aber nicht wirklich am effizientesten, aber dafür am einfachsten zu implementieren. Optimal geht das eigentlich nur mit einer Schleife und ein wenig Fallunterscheidung.

Danke... werde ich mal versuchen...

[bernau]

Ungewünschte Zeichen herausfiltern geht auch mit stringReplace.

Delphi-Quellcode:

begin
  deinString := stringReplace(deinString, '<', '', [rfReplaceAll]);
  deinString := stringReplace(deinString, '>', '', [rfReplaceAll]);
  deinString := stringReplace(deinString, 'G', '', [rfReplaceAll]);
  deinString := stringReplace(deinString, ';', #13+#10, [rfReplaceAll]);
  deinString := stringReplace(deinString, ',', #13+#10, [rfReplaceAll]);
end;

[hedie]

Zitat von bernau:

Ungewünschte Zeichen herausfiltern geht auch mit stringReplace.

Delphi-Quellcode:

begin
  deinString := stringReplace(deinString, '<', '', [rfReplaceAll]);
  deinString := stringReplace(deinString, '>', '', [rfReplaceAll]);
  deinString := stringReplace(deinString, 'G', '', [rfReplaceAll]);
  deinString := stringReplace(deinString, ';', #13+#10, [rfReplaceAll]);
  deinString := stringReplace(deinString, ',', #13+#10, [rfReplaceAll]);
end;

Interessanter ansatz....

Das dürfte wohl das schnellste sein
Danke!

[himitsu]

StringReplace ist eher sehr langsam ... je länger der String und um so mehr Ersetzungen, um so langsamer wird es.

Aber wenn schon, dann könnte man ";G" in ein "," tauschen, dann noch "<G" und ">" entfernen (Delete) und das Ganze dann als DelimitedText mit "," als Delimiter an eine TStringList übergeben.


Ansonsten würde ich es noch mit PosEx und Copy versuchen.

[Bummi]

das meine ich könnte relativ flott sein ....

eine Bremse könnte SetLength(a,High(a)+2);
sein, hier gegf. einfach in größeren Blöcken anfordern und eine Zähler mitlaufen lassen ...

Delphi-Quellcode:

  TPointF=Record
    x:Double;
    y:Double;
  End;
  TPointArray=Array of TPointF;

mit

Delphi-Quellcode:

Procedure FillArray(var a:TPointarray;Const s:AnsiString);
var
  s1,s2:AnsiString;
  i,l,x1,x2:Integer;
  isFirst:Boolean;
begin
  s1 := StringOfChar(#0,10);
  s2 := StringOfChar(#0,10);
  x1 := 0;
  x2 := 0;
  i := 1;
  l := Length(s);
  while i<l do
    begin
      if s[i] = 'G' then
        begin
            x1 := 0;
            isFirst := true
            end
      else if s[i] = ',' then
        begin
            x2 := 0;
            isFirst := false;
            inc(x1);
            s1[x1] := #0;
        end
      else if s[i] = ';' then
        begin
            x1 := 0;
            inc(x2);
            s2[x2] := #0;
            SetLength(a,High(a)+2);
            a[High(a)].X   := StrToFloat(s1);
            a[High(a)].Y   := StrToFloat(s2);
        end
      else if s[i] = '.' then
        begin
            if isFirst then
              begin
              inc(x1);
              s1[x1] := AnsiChar(Decimalseparator);
              end
            else
              begin
              inc(x2);
              s2[x2] := AnsiChar(Decimalseparator);
              end;
        end
      else if s[i] in ['0'..'9'] then
            begin

            if isFirst then
              begin
                inc(x1);
                s1[x1] := s[i];
              end
               else
              begin
               inc(x2);
               s2[x2] := s[i];
              end;
            end;

      inc(i);
    end;

end;

[himitsu]

Falls der String immer genau so aufgebaut ist,
also mit einem Buchstaben beim ersten Wert und mit abschließenden ";", dann ginge auch Folgendes

"<" + "Gxxxx,yyyy;" + "Gxxxx,yyyy;" + ... + ">"

Delphi-Quellcode:

var
  S: String;
  L: TStringList/TStrings;
  i, i2: Integer;

S := '<G48.51123,9.71545;G48.51123,9.71545;G48.51123,9.71545;G48.51123,9.71545;>';
L.Clear;
i := 1;
while True do begin
  i2 := PosEx(',', S, i);
  if i2 = 0 then Break;
  L.Add(Copy(S, i + 2, i2 - i - 2));
  i := PosEx(';', S, i2);
  if i = 0 then Break;
  L.Add(Copy(S, i2 + 1, i - i2 - 1));
end;

Statt dem Zwischenspeichern, in der StringListe, könnte man die beiden Zahlen auch direkt verarbeiten, am Ende der Schleife.

[BoolString]

Vielleicht auch ein Ansatz, wenn deine Terminus 'Einfachheit' bedeutet, daß du auf möglichst wenig fertige Funktionen (Pos, PosEx, etc.) verzichten willst:

Zahlen aus Strings extrahieren

Nicht der optimalste und hübscheste Code, sollte aber für deine Geschichten funzen.

Jan

[Furtbichler]

Zitat von himitsu:

Delphi-Quellcode:

var
  S: String;
  L: TStringList/TStrings;
  i, i2: Integer;

S := '<G48.51123,9.71545;G48.51123,9.71545;G48.51123,9.71545;G48.51123,9.71545;>';
L.Clear;
i := 1;
while True do begin
  i2 := PosEx(',', S, i);
  if i2 = 0 then Break;
  L.Add(Copy(S, i + 2, i2 - i - 2));
  i := PosEx(';', S, i2);
  if i = 0 then Break;
  L.Add(Copy(S, i2 + 1, i - i2 - 1));
end;

Eine gelungene Umsetzung des ersten Vorschlags, nur das auf das Prüfen von 'G' verzichtet wird.

[himitsu]

Oh, das sah da irgendwie anders aus, hatte mir den Code nicht komplett angesehn.
Pos sah nicht wie PosEx aus (waren ja nur zwei Parameter) und ich hate am Ende einfach (ohne hinzgucken) irgendwo ein Delete erwartet

Nja, k.A. ob eine RegEx-Prüfung (da sie ja mehr prüfen muß) doch schneller ist ... zumindestens nicht, wenn das RegEx in Delphi geschrieben wäre X'D

Hey, dann war ja gleich der erste Vorschlag so mit das Schnellste, was man wohl mit delphieigenen Mitteln so hinbekommen können würde