StringReplace und doppelte Zeichen

[Dax]

aChar wird bei dir aber auch nicht verwendet

[grenzgaenger]

der code von DAX ist schneller, weil er die länge des strings zu anfang setzt, bei meinen aktuellen code, wird bei jeden hinzufügen eines zeichens der speicher umgeschichtet. das kannst auf zweierlei arten lösen

• mit setlengh, zu anfang und am schluss, wie bei DAX oder
• in dem du aus String 'n ShortString machst, dann ist es aber auf 255 zeichen beschränkt

grüss und noch 'n schönes weihnachten

GG, der mit den dynamischen arrays noch immer nicht umgehen kann

[grenzgaenger]

Zitat von Opa:

Opa - 00-00-00-156 - Ich x bin x der x schnellste x Hase x der der Welt
grenzgenger - 00-00-00-125 - Ich x bin x der x schnellste x Hase x der der Welt
DAX - 00-00-00-031 - Ich x bin x der x schnellste x Hase x der der Welt
----------------------------------------------------
Opa - 00-00-00-172 - Ich x bin x der x schnellste x Hase x der der Welt
grenzgenger - 00-00-00-125 - Ich x bin x der x schnellste x Hase x der der Welt
DAX - 00-00-00-016 - Ich x bin x der x schnellste x Hase x der der Welt
----------------------------------------------------
Opa - 00-00-00-172 - Ich x bin x der x schnellste x Hase x der der Welt
grenzgenger - 00-00-00-125 - Ich x bin x der x schnellste x Hase x der der Welt
DAX - 00-00-00-031 - Ich x bin x der x schnellste x Hase x der der Welt

DAX, deine ist wirklich die Schnellste, Respekt.
Meine kommt dann in die Tonne
MFG

@Opa: ich kann dein Ergebnis nicht nachvollziehen...
Variante Opa: 35 Ticks mit dem Ergebnis: Erfolgreich
Ergebnisstring: Dies ist ein Test xCCCx mit Zeichen

Variante DAX: 10 Ticks mit dem Ergebnis: Falsche Konvertierung
Ergebnisstring: Dies ist ein Test xCx mit Zeichen

Variante alzaimar: 9 Ticks mit dem Ergebnis: Falsche Konvertierung
Ergebnisstring: Dies ist ein Test xCx mit Zeichen

Variante Grenzgaenger: 28 Ticks mit dem Ergebnis: Erfolgreich
Ergebnisstring: Dies ist ein Test xCCCx mit Zeichen

die Variante von DAX ist zwar die zweit schnellste, aber vom Ergebnis her...

[grenzgaenger]

habe das ganze mal, statt als Funktion als Procedure impelentiert...

hier das Ergebnis:

Code:

Variante Opa: 35 Ticks mit dem Ergebnis: Erfolgreich
Ergebnisstring: Dies ist ein Test xCCCx mit Zeichen

Variante DAX: 10 Ticks mit dem Ergebnis: Falsche Konvertierung
Ergebnisstring: Dies ist ein Test xCx mit Zeichen

Variante alzaimar: 9 Ticks mit dem Ergebnis: Falsche Konvertierung
Ergebnisstring: Dies ist ein Test xCx mit Zeichen

Variante Grenzgaenger: 11 Ticks mit dem Ergebnis: Erfolgreich
Ergebnisstring: Dies ist ein Test xCCCx mit Zeichen

Variante himitsu: 10 Ticks mit dem Ergebnis: Falsche Konvertierung
Ergebnisstring: Dies ist ein Test xCx mit Zeichen

und der Code:

Delphi-Quellcode:

procedure ReplaceDChar(Var Quelle: string; aChar: char);
var
  i, j: integer;
begin
  j := 1;
  for i := 2 to length(quelle) do
   if (quelle[i]<>quelle[j]) or (aChar<>quelle[j]) then
   begin
    j := j + 1;
    quelle[j] := quelle[i];
   end;
  setlength(quelle, j); 
end;

[alzaimar]

Ick bin ja auch blöd: Übergebe ein Zeichen, dessen doppelte Vorkommen weggeschnippelt werden sollen, und dann wird dieses Zeichen ignoriert...

Delphi-Quellcode:

Function RemoveCharRepetitions(Const aText: String; aChar: Char): String;
Var
  i, j: Integer;
  c: Char;

Begin
  setLength(Result, Length(aText));
  If Length(aText)=0 Then Exit;
  j := 1;
  c := aText[1];
  Result[1] := c;
  For i := 2 To Length(aText) Do
    If (c<>aChar) or (aText[i] <> c) Then Begin
      Inc(j);
      c := aText[i];
      Result[j] := c;
    End;
  SetLength(Result, j);
End;

Eigentlich der gleiche Code wie vom Grenzgaenger... Optimieren kann man das, indem man z.B. bis zum ersten Auftreten des Zeichens springt. Insbesondere der Code von Grenzgaenger wird dann schneller.

[grenzgaenger]

Wunderbar

Code:

Variante Opa: 35 Ticks mit dem Ergebnis: Erfolgreich
Ergebnisstring: Dies ist ein Test xCCCx mit Zeichen

Variante DAX: 10 Ticks mit dem Ergebnis: Falsche Konvertierung
Ergebnisstring: Dies ist ein Test xCx mit Zeichen

Variante alzaimar: 9 Ticks mit dem Ergebnis: Erfolgreich
Ergebnisstring: Dies ist ein Test xCCCx mit Zeichen

Variante Grenzgaenger: 10 Ticks mit dem Ergebnis: Erfolgreich
Ergebnisstring: Dies ist ein Test xCCCx mit Zeichen

Variante himitsu: 10 Ticks mit dem Ergebnis: Falsche Konvertierung
Ergebnisstring: Dies ist ein Test xCx mit Zeichen

keine Ahnung wie Alzaimar das geschafft hat... denke, da kann man dann nur noch mit Assembler was rausholen... viel wirds aber nicht mehr werden...

[alzaimar]

Zitat von grenzgaenger:

keine Ahnung wie Alzaimar das geschafft hat...

Ich habe eine Stringindizierung weniger als Du. Also ich nicht, sondern der Code.

Versuch doch mal:

Delphi-Quellcode:

procedure ReplaceDChar(Var Quelle: string; aChar: char);
var
  i, j: integer;
  c : Char;
label 
  1;

begin
  // Erstmal zum ersten Auftreten von aChar hüpfen.
  For j := 1 to Length (Quelle) Do 
    if Quelle[j]=aChar then 
      goto 1; // Nicht hauen, soll ja schnell sein

  Exit;
// --------
1:c := quelle[j];
  for i := j+1 to length(quelle) do
   if (quelle[i]<>c) or (aChar<>c) then
   begin
    j := j + 1;
    c := quelle[i];
    quelle[j] := c;
   end;
  setlength(quelle, j);
end;

Könnte funktionieren und könnte auch noch schneller sein.

Dann könnte man noch darauf verzichten, jedesmal ein einzelnen Zeichen zu bewegen. Erst wenn sich (j-i) ändert, kopiert man per Copy (was schneller ist, als Zeichen-für-Zeichen zu kopieren) das letzte Teilstück. Auch das könnte was bringen.

[grenzgaenger]

tja, war wohl nicht ganz so gut ... mit dem goto ...

Code:

Variante Opa: 34 Ticks mit dem Ergebnis: Erfolgreich
Ergebnisstring: Dies ist ein Test xCCCx mit Zeichen

Variante DAX: 11 Ticks mit dem Ergebnis: Falsche Konvertierung
Ergebnisstring: Dies ist ein Test xCx mit Zeichen

Variante alzaimar: 11 Ticks mit dem Ergebnis: Erfolgreich
Ergebnisstring: Dies ist ein Test xCCCx mit Zeichen

Variante Grenzgaenger: 11 Ticks mit dem Ergebnis: Erfolgreich
Ergebnisstring: Dies ist ein Test xCCCx mit Zeichen

Variante himitsu: 10 Ticks mit dem Ergebnis: Falsche Konvertierung
Ergebnisstring: Dies ist ein Test xCx mit Zeichen

2 ticks langsamer...

[Dax]

Delphi-Quellcode:

function ReduceMultiples(const s: string; c: char): string;
var
  pe, pr, pc: PChar;
  i: integer; 
begin
  if s = '' then exit;
  SetLength(result, Length(s));
  pc := @s[1];
  i := 0;
  while pc^ <> c do begin
    Inc(pc);
    Inc(i);
  end;
  if i > 0 then begin
    Move(s[1], result[1], i);
    pe := @s[i+1] + Length(s) - i;
    pr := @result[i+1];
  end else begin
    pe := @s[1] + Length(s);
    pr := @result[1];
  end;
  while pc <> pe do begin
    while (pr^ = pc^) and (pc^ = c) do
      Inc(pc);
    pr^ := pc^;
    Inc(pr);
    Inc(pc);
  end;
  SetLength(result, pr - @result[1]);
end;

Gehts so?

[grenzgaenger]

Fehlermeldung:

Delphi-Quellcode:

  if i > 0 then begin
    Move(@s[1], @result[1], i); << E2036 Variable erforderlich
    pe := @s[i+1] + Length(s) - i;
    pr := @result[i+1];