string inkrementieren

[FredlFesl]

Wofür doch so die Lebenszeit draufgeht...

[shmia]

Zitat von Lannes:

Hast Du es noch etwas ultimativer irgendwo

Gibt es eigentlich eine Steigerung zu "ultimativer" ?

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

[Stevie]

epeen contest?

[Lannes]

Zitat von shmia:

PS: Ohhjee, jetzt haben wir 2 Implementierungen

und beide sind ultimativer

Meinen besten Dank an shmia und himitsu

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

[himitsu]

Disoptimieren geht ganz schnell um 1000x die 0 zusammenzubekommen
s := ''; for i := 1 to 1000 do s := s + '0';

[Lannes]

Zitat von Stevie:

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

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

@himitsu:

damit es richtig langsam wird, Verkettung umdrehen:
s := ''; for i := 1 to 1000 do s := '0' + s;

[Coffeecoder]

Zitat von Coffeecoder:

Zitat von mkinzler:

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]

temp := '0' + temp; in einer Schleife = Aua
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)
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.