Groß u. Kleinschreibung eines Strings umkehren

[k6n]

Hi,

Wie kann ich die Groß und Kleinschreibung eines String umkehren?

Aus HaLLo soll z.B hAllO werden.

Danke

[Satty67]

Könnte funktionieren:

Delphi-Quellcode:

function SwitchUpperLower(Str : String): String;
var
  i : Integer;
begin
  Result := Str;
  for i := 1 to Length(Result) do
    if UpperCase(Result[i]) = Result[i] then 
      Result[i] := LowerCase(Result[i])[1]
    else 
      Result[i] := UpperCase(Result[i])[1];
end;

[jaenicke]

Das ist etwas schneller: ;-)

Delphi-Quellcode:

function SwitchLowerUpper(Value: String): String;
var
  i: Integer;
begin
  Result := Value;
  for i := 1 to Length(Value) do
    if Value[i] in ['a'..'z'] then
      Result[i] := Chr(Ord(Value[i]) - 32)
    else if Value[i] in ['A'..'Z'] then
      Result[i] := Chr(Ord(Value[i]) + 32);
end;

[Sir Rufo]

Zitat:

Zitat von jaenicke

Das ist etwas schneller: ;-)

Delphi-Quellcode:

function SwitchLowerUpper(Value: String): String;
var
  i: Integer;
begin
  Result := Value;
  for i := 1 to Length(Value) do
    if Value[i] in ['a'..'z'] then
      Result[i] := Chr(Ord(Value[i]) - 32)
    else if Value[i] in ['A'..'Z'] then
      Result[i] := Chr(Ord(Value[i]) + 32);
end;

... logisch, lässt ja auch einiges aus ... äöü ?

[Satty67]

Ganz vergessen, wenn man Umlaute braucht, dann AnsiUpperCase bzw. AnsiLowerCase (in dem Fall wäre auch die schnellere Variante überfordert)

[jaenicke]

So meinte ich das mit dem schneller nicht :lol: , die Umlaute hatte ich vergessen :oops: :

Delphi-Quellcode:

function SwitchLowerUpper(Value: String): String;
var
  i: Integer;
begin
  Result := Value;
  for i := 1 to Length(Value) do
    if Value[i] in ['a'..'z', 'ä', 'ö', 'ü'] then
      Result[i] := Chr(Ord(Value[i]) - 32)
    else if Value[i] in ['A'..'Z', 'Ä', 'Ö', 'Ü'] then
      Result[i] := Chr(Ord(Value[i]) + 32);
end;

[Sir Rufo]

Allerdings in den Zeiten von Unicode würde ich das nicht verwenden wollen ...

[k6n]

Danke an alle, funktioniert super. :thumb:

[himitsu]

Delphi-Quellcode:

function SwitchLowerUpper(const Value: String): String;
var
  i: Integer;
begin
  Result := Value;
  for i := 1 to Length(Result) do
    if Result[i] in ['a'..'z', 'ä', 'ö', 'ü', 'A'..'Z', 'Ä', 'Ö', 'Ü'] then
      Result[i] := Chr(Ord(Result[i]) xor $20);

Delphi-Quellcode:

function SwitchUpperLower(Value: String): String;
var
  uValue: String;
  i: Integer;
begin
  Result := LowerCase(Value);
  uValue := UpperCase(Value);
  for i := 1 to Length(Result) do
    if Result[i] = Value[i] then
      Result[i] := uValue[i];
end;

:angel:

[Satty67]

Ach, das gibt es schon... und viele Wege führen nach Rom :?

Ich hab' wieder mal auf möglichst wenige Variablen geachtet. Ist zwar sicher unwichtig, aber welche Version ist die schnellste?

Ich durchlaufe Length(Str) nur einmal und mache ein paar Vergleiche. Die Delphi Version 3x, wenn am Anfang jeweils der komplette Str in eine Upper/Lower-Version gewandelt wird? Bei jaenicke's Version hängt es wohl von den verwendeten Zeichen ab.

[himitsu]

Zitat:

Zitat von Satty67

Ich hab' wieder mal auf möglichst wenige Variablen geachtet. Ist zwar sicher unwichtig

keine Sorge, bin nich neidisch, dafür hab ich doch möglichs wenige Funktionsaufrufe :angel:

das schnellste/kleinste :gruebel: vermutlich, wenn ich meine erste Version nach PChar oder gleich nach ASM konvertiere :angel2:

Aber da du bei deinem Lower-/Uppercase jedes mal erst aus dem Char 'nen String machst und dann diese Funktionen auch noch mehrmals aufrufst, wird ein Aufruf dieser Funktionen schneller sein.

[Satty67]

Also hab's jetzt mal getestet...

meine Version ist die langsamste... und zwar mit Abstand die langsamste :oops:

[Sir Rufo]

Das war ja auch zu erwarten ... nicht weil du es gemacht hast ;) sondern wie himitsu schreibt es eben zu 2*[LängeDesStrings] Aufrufen der Funktion UpperCase bzw. LowerCase kommt

Da ist natürlich eine Lösung, die diese Funktionen erst gar nicht nutzt (jaenicke), oder eben nur 2x aufruft (himitsu) wesentlich schneller.

Dafür ist die Lösung von Dir und himitsu auch Unicode-kompatibel und somit allgemeingültig :)

cu

Oliver

[himitsu]

jupp ruft 2*LängeDesStrings CharToStr und eine der Stringfunktionen(Lower/Upper) auf und diese Funktionen sind alle nicht unbedingt schnell.

Aber das langsamste ist hier eigentlich dieses interne CharToStr (Result[i] ist ja ein Char und Upper-/LowerCase wollen einen String, also muß erst ein String erstellt werden)

Code:

// Satty67's Funktion
function SwitchUpperLower(Str: String): String;
var
  i : Integer;
begin
  Result := Str;
  for i := 1 to Length(Result) do
    if UpperCase([b]CharToStr[/b](Result[i])) = Result[i] then
      Result[i] := LowerCase([b]CharToStr[/b](Result[i]))[1]
    else
      Result[i] := UpperCase([b]CharToStr[/b](Result[i]))[1];
end;

OK, das ist also nicht unbedingt schnell, aber vom Prinzip her isses nicht falsch und es funktioniert immerhin :angel:

[Satty67]

Zitat:

Zitat von Sir Rufo

Das war ja auch zu erwarten ... nicht weil du es gemacht hast ;)

Doch, liegt an mir bzw. meiner Art zu programmieren. Ich sehe den Code oft zu oberflächlich... aber da ich nichts kommerziell entwickle, darf ich das. :)

Mit himitsus Auflösung wird es deutlich, so sehe ich es dann auch.

[himitsu]

Ich arbeite auch meistens nicht kommerziell, das aktuelle Projekt ist sogar nur für mich alleine :shock:

Aber man lernt mit der Zeit und auch du wirst es in Zukunft (irgendwann) mal besser machen :zwinker:
(hab ja auch schon einige Jährchen an Lernprozessen und Fehlschlägen hinter mir)
Und wie gesagt, es funktionierte dennoch und das ist doch auch schonmal etwas :angel:

[Satty67]

Ob das noch besser wird :stupid:

Programmier seit 1993 in Pascal (Turbo Pascal 6.0), allerdings mit teilweise monatelangen Pausen dazwischen. Da muss man wohl die Nettozeit sehen. Hab' nur im Moment wieder eine aktive Phase, weil ich mir eine Anwendung mit einer SQL-Datenbank schreibe.

[Luckie]

Warum weißt ihr alle schon gleich am Anfang Result einen Wert zu? Damit verliert der Compiler das EAX Register für den Rückgabewert. Wenn ihr eine Zwischenvariable nutzt, kann der Compiler besser optimieren, weil er noch ein zusätzliches Register zur Verfügung hat. Also so habe ich bisher gedacht. Sollte ich falsch liegen, bitte meine Aussage korrigieren.

[himitsu]

Wer sagt, daß Result immer (wärend der Laufzeit der Prozedur) in EAX liegt?

der Compiler legt es auch gerne mal auf'm Stack ab und kopiert erst am Ende nach EAX :angel2:

PS: der Compiler verschiebt doch auch (oftmals) beim Start der Procedur die Parameter von den Registern auf den Stack.



OK, Turbo Pascal kenn ich auch noch ... sogar 'ne Zeit lang Basic/QBasic :oops: , aber CCBasic war wieder nett :angel2:

[Satty67]

Zitat:

Zitat von Luckie

Warum weißt ihr alle schon gleich am Anfang Result einen Wert zu?

Gemacht habe ich das, weil ich damit Result gleich richtig initialisiert hatte (auch bei Leerstring) und dazu kommt meine Manie, immer so wenig wie möglich Variablen zu verwenden.

Meine Priorität liegt wohl mehr auf "Übersichtlich" als "Effizient"

PS: Vor Pascal war eine kurze Zeit Basic for GEM-Desktop, also Windows-Programmierung vor Windows. :wink:

[jbg]

Zitat:

Zitat von himitsu

Wer sagt, daß Result immer (wärend der Laufzeit der Prozedur) in EAX liegt?

Luckie :mrgreen:

Dumm ist nur, dass das nicht stimmt. Ganz im Gegenteil, wenn man eine weitere lokale Variable einführt, kann es passieren, dass der Compiler unter einen zusätzlichen CPU Register-Druck gerät und verbannt die Variable auf den Stack, was zu mehr Speicherzugriffen führt. Bei kleinen/engen Schleifen kann dass dann schon mal Auswirkungen auf die Geschwindigkeit haben.

Übrigens zu TurboPascal 7.0 und Delphi 1 Zeiten war Luckies Aussage richtig. Aber ab Delphi 5 (die anderen Delphi Versionen habe ich jetzt gerade nicht zur Hand) ist die Optimierung schlau genug.

[Luckie]

OK, dann nehme ich meine Aussage wieder zurück. Aber ichmeine hagen hätte dies mal so dargestellt. Kann natürlich auch sein, dass ich das falsch verstanden oder in Erinnerung habe.

[himitsu]

Zitat:

Zitat von Satty67

Meine Priorität liegt wohl mehr auf "Übersichtlich" als "Effizient"

Hauptsache du verstehst es ... bringt ja nichts, wenn du immer alle möglichen Optimierungen einbaust und am Ende nicht mehr verstehst was da in der Prozedur überhaupt gemacht wird. :shock:

@Luckie: wer versteht schon alle Compiler"Optimierungen" ... womöglich kann es ja unter bestimmten Umständen ja doch anders sein :gruebel: