string inkrementieren

[FredlFesl]

Wofür doch so die Lebenszeit draufgeht...:stupid:

[shmia]

Zitat:

Zitat von Lannes (Beitrag 1104194)

Hast Du es noch etwas ultimativer irgendwo

Gibt es eigentlich eine Steigerung zu "ultimativer" ? :hi:

Delphi-Quellcode:

function FastCharPos(const S: AnsiString; const C: AnsiChar): Integer;
begin
  for Result := 1 to Length(S) do
    if S[Result] = C then
       Exit;
  Result := 0;
end;

function IncSingleDigit(var c:AnsiChar; n : Integer; const d:string):Integer;
var
   z : Integer;
   len : Integer;
begin
   len := length(d);
   z := FastCharPos(d, c) - 1;
   if z < 0 then z := 0;
   z := z + n;

   c := d[(z mod len) +1];
   Result := z div len;
end;

function IncBinary(var x:Byte; n : Integer):Integer;
var
   z : Integer;
begin
   z := Ord(x) + n;
   x := z and $FF;
   Result := z div 256;
end;

{**************************************************************************
 * NAME:    IncrementWithMask
 * DESC:    erhöht eine Nummer (die als String vorliegt) um den Wert N
 *          Dabei darf "Number" an bestimmten Stellen auch Buchstaben enthalten
 *          "Mask" bestimmt, an welchen Positionen Ziffern oder Buchstaben erlaubt sind
 * Mask:  0 = Ziffern     (0..9)
 *        2 = Binär       (0..1)
 *        A = Buchstaben  (A..Z)
 *        a = Buchstaben  (a..z)
 *        Z = Ziffern & Gross-Buchstaben
 *        z = Ziffern & Klein-Buchstaben
 *        H = Hex-Ziffern  (0..9, A..F)
 *        h = Hex-Ziffern  (0..9, a..f)
 *        B = Zeichen wird binär erhöht
 *          = diese Stelle bleibt
 * PARAMS:  [-]
 * RESULT:  die erhöhte Nummer
 * CHANGED: 03-06-2011/shmia
 *************************************************************************}
function IncrementWithMask(const Number, Mask:AnsiString; N : Integer):AnsiString;

   function IncrementDigit(x:PAnsiChar; m:Char; n:Integer):Integer;
   const
      digits :   AnsiString = '0123456789';
      alpha :    AnsiString = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
      hex :      AnsiString = '0123456789ABCDEF';
      numalpha : AnsiString = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
   begin
      case m of
         '0': Result := IncSingleDigit(x^, n, digits);
         '2': Result := IncSingleDigit(x^, n, '01');
         'A': Result := IncSingleDigit(x^, n, alpha);
         'a': Result := IncSingleDigit(x^, n, LowerCase(alpha));
         'Z': Result := IncSingleDigit(x^, n, numalpha);
         'z': Result := IncSingleDigit(x^, n, LowerCase(numalpha));
         'H': Result := IncSingleDigit(x^, n, hex);
         'h': Result := IncSingleDigit(x^, n, LowerCase(hex));
         'B': Result := IncBinary(PByte(x)^,n);
         ' ':
            Result := n;
      else
         begin
            Result := n;
            x^ := m;
         end
      end;
   end;

var
   i : Integer;
begin
   Result := Number;
   UniqueString(Result);
   for i := Length(Result) downto 1 do
   begin
      N := IncrementDigit(@result[i], Mask[i], N);
      if N = 0 then
         Break;
   end;
end;

PS: Ohhjee, jetzt haben wir 2 Implementierungen :shock:

[Stevie]

epeen contest? :twisted:

[Lannes]

Zitat:

Zitat von shmia (Beitrag 1104439)

PS: Ohhjee, jetzt haben wir 2 Implementierungen :shock:

und beide sind ultimativer :mrgreen:

Meinen besten Dank an shmia und himitsu :thumb:

Die Codes funktionieren vorzüglich und sind etwa gleich performant.
Sie sind ca. 170 mal schneller als die Möglichkeit mit einer Schleife: http://www.delphipraxis.net/1104375-post18.html

[himitsu]

Dabei könnte man in meinem Code auch noch mit PChars rumpfuschen, um den noch schneller zu machen.

Am Ende bin ich aber auch immer wieder "schockiert" wie schnell solche Stringmanipulationen doch sein können, falls man keine großen und immer wieder begangen Designfehler verbaut.
Bei der http://www.delphipraxis.net/135569-m...athelib-_.html hatte ich auch erwartet, daß sie wesentlich langsamer arbeitet.
OK, gegen eine etwas höheroptimiertere Mathe-Lib ist sowas zwar immernoch noch sehr lahm, aber für den einfachen Gebrauch isses doch schon oftmals flott genug.

[Stevie]

Wenn ich string Operationen und Optimierung in einem Satz lese, könnt ich schon wieder :kotz:

[himitsu]

Disoptimieren geht ganz schnell um 1000x die 0 zusammenzubekommen

Delphi-Quellcode:

s := ''; for i := 1 to 1000 do s := s + '0';

:stupid:

[Lannes]

Zitat:

Zitat von Stevie (Beitrag 1104513)

Wenn ich string Operationen und Optimierung in einem Satz lese, könnt ich schon wieder :kotz:

da kann man mal sehen wie das Leben so spielt. Mir war übel weil ich mit Strings operieren muss und es nicht performant hinbekommen habe. Nun geht es mir besser:wink:

@himitsu:

damit es richtig langsam wird, Verkettung umdrehen:

Delphi-Quellcode:

s := ''; for i := 1 to 1000 do s := '0' + s;

:zwinker:

[Coffeecoder]

Zitat:

Zitat von Coffeecoder (Beitrag 1104075)

Zitat:

Zitat von mkinzler (Beitrag 1104071)

Die wäre u.U. auch für andere interessant, obwohl Format() das ja auch kann

OK :) Ich poste die dann wenn ich an meinem Rechner sitze.

Hey,

Mir ist klar, dass mittlerweile sehr viele Möglichkeiten gepostet worden sind.
Ich hab ein wenig nach meiner Funktion gesucht und habe sie endlich gefunden.
Hier mal meinen Vorschlag:

Delphi-Quellcode:

function erweiternFuehrendeNull(laenge : integer; zahl : string) : string ;
var
        temp : string;
begin
        temp := zahl;

        while (length(temp) < laenge) do
        begin
                temp := '0' + temp;
        end;

        result := temp;
end;

[himitsu]

Delphi-Quellcode:

temp := '0' + temp;

in einer Schleife = Aua

Delphi-Quellcode:

result := temp;

- Warum nicht gleich Result verwenden? (Wir sind hier nicht in C, wo das zuweisen des Results [return] die Funktion verläßt)
Aber statt Temp hätte man auch Zahl verändern können (solange man den Parameter nicht als CONST übergibt)

Delphi-Quellcode:

while (...) do

- Delphi kommt mit wesentlich weniger Klammern aus.

Und dann noch völlig unnötige Leerzeilen entfernt (hier machen die ja nichts übersichtlicher) und schon kommt man von 13 auf 6 Code-Zeilen.

Delphi-Quellcode:

function ErweiternFuehrendeNull(const Zahl: String; Laenge: Integer): String;
begin
  Result := Zahl;
  while Length(Result) < Laenge do
    Include('0', Result, 1); //Result := '0' + Result; ist aber dennoch nicht viel besser (Aua)
end;

Delphi-Quellcode:

function ErweiternFuehrendeNull(const Zahl: String; Laenge: Integer): String;
begin
  Result := DupeString('0', Laenge - Length(Zahl)) + Zahl;
end;

PS: Nicht wundern, aber "Zahl soll Länge lang werden", also hab ich die Parameter getauscht.