String umdrehen

[Aphton]

Mein Ketchup dazu:

Delphi-Quellcode:

function ReverseString(const S: String): String;
var
  i, Len: Integer;
begin
  Len := Length( S );
  SetLength( Result, Len );
  for i := 1 to Len do
    Result[i] := S[Len+1-i];
end;

function PosEx(const SubStr: String; Str: String; const From: Integer): Integer;
begin
  Str := Copy( Str, From, Length( Str ) - From + 1 );
  Result := Pos( SubStr, Str );
  if Result > 0 then
    inc( Result, From - 1 );
end;

function ReverseSentence(const S: String; const Separator: Char = ' '): String;
var
  i, Len,
  p: Integer;
  Word: String;
begin
  Result := S;
  Len := Length( S );
  i := 1;
  while i < Len do
  begin
    p := PosEx( Separator, S, i );
    if p = 0 then
      p := Len + 1 - i
    else
      p := p - i;
    Word := ReverseString( Copy( S, i, p ) );
    Move( Word[1], Result[i], p );
    inc( i, p + 1 );
  end;
end;

[himitsu]

@Aphton:
Bitte Anfänger nicht unbedingt gleich mit Move, MoveMemory und Co. behelligen.

Vorallem da dein Code ab Delphi 2009 nicht mehr funktioniert, weil wieder mal nicht beachtet wurde, daß sich Char/String verändern können.
PS: PosEx sollte TDE aber schon kennen.



Wenn es ein Text nur aus Wörtern und Leerzeichen ist, dann ginge auch noch

- TStringList mit Leerzeichen als Delimiter
- darüber den Text aufsplitten (geht auch mit Explode, wie z.B. eines aus unserer CodeLib)
- dann ist in jeder Zeile ein Wort, welches man umdrehen kann
und zum Schluß alles wieder zurück in einen String.

[p80286]

Zitat von Aphton:

Delphi-Quellcode:

function ReverseSentence(const S: String; const Seperator: Char = ' '): String;
var
  i, Len,
  p: Integer;
  Word: String;
begin

das "Word" halte ich für nicht so gelungen, da es auch den Typ Word gibt. In diesem Falle bevorzuge ich dann doch Denglisch weil es dann keine Probleme mit Doppeldeutigkeiten geben kann.

Gruß
K-H

[Aphton]

Zitat von p80286:

Zitat von Aphton:

Delphi-Quellcode:

function ReverseSentence(const S: String; const Seperator: Char = ' '): String;
var
  i, Len,
  p: Integer;
  Word: String;
begin

das "Word" halte ich für nicht so gelungen, da es auch den Typ Word gibt(...)

Da bin ich anderer Meinung!

@Himitsu - ja, da hast du Recht! Das kann zu Problemen führen.
Was das "Move" angeht - ich finde, so dürfte das schneller sein?!

Edit: Das sollte separator heißen

[rollstuhlfahrer]

Zitat von Aphton:

@Himitsu - ja, da hast du Recht! Das kann zu Problemen führen.
Was das "Move" angeht - ich finde, so dürfte das schneller sein?!

Ab D2009 (mit Unicode) führt das zu Problemen. Man kann diese Version aber etwas abändern und dann wird sie in allen weiteren Delphi-Versionen funktionieren (auch mit UTF-32):
Move( Word[1], Result[i], p * SizeOf(Char)); .
Das SizeOf(Char) ist der Multiplikator. Vor D2009 ist der 1 (weil 1 Zeichen -> 1 Byte), danach ist der 2 (weil 1 Zeichen -> 2 Bytes oder so), auf jeden Fall ist der dann zu der Delphi-Version passend und es sollte nicht zu Problemen kommen.

Bernhard

[himitsu]

Allerdings muß man nicht immer alles extremst optimieren,
denn soo oft wird diese Funktion bestimmt nicht aufgerufen, als daß da 'ne Microsekunde wirklich auffällt ... in soeinem Fall lieber einfachen Code verwenden, da weniger fehleranfällig und übersichtlicher.

[-187-]

Tja grade wenn er eine Aufgabe für die Schule bearbeitet wird er glaube ich mit Move nicht glücklich werden

Das sind einfach keine Basics mehr...

[roboter202]

Hallo,

umdrehen geht auch so

Delphi-Quellcode:

for i := 1 to length(input) do
  begin
  output := output + input[length(input)-(i-1)]
  end;

Warum immer so Kompliziert

[Aphton]

Das ist sehr unperformant, denn du fügst einem String einen weiteren String hinzu, was zu einem stetigen Erweitern und somit Speicher neu allozieren führt, das ja bekannterweise langsam ist!

[roboter202]

Hallo,

Zitat von Aphton:

Das ist sehr unperformant, denn du fügst einem String einen weiteren String hinzu, was zu einem stetigen Erweitern und somit Speicher neu allozieren führt, das ja bekannterweise langsam ist!

Das mag sein allerdings würde es funktionieren und wenn man nicht gerade von einem string mit millionen von zeichen ausgeht würde es nicht merklich länger dauern