Vergleichen von arrays in Delphi

Ich habe 3 arrays, zum Beispiel:

const
  A: Array[0..9] of Byte = ($00, $01, $AA, $A1, $BB, $B1, $B2, $B3, $B4, $FF);
  B: Array[0..2] of Byte = ($A1, $BB, $B1);
  C: Array[0..2] of Byte = ($00, $BB, $FF);

Gibt es eine Möglichkeit zu vergleichen und erhalten Sie den index des richtigen, anstelle der überprüfung jedes byte 1 von 1? Zum Beispiel:

function GetArrayIndex(Source, Value: Array of Byte): Integer;
begin
..
end;

GetArrayIndex(A, B); // results 3
GetArrayIndex(A, C); // results -1

Vielen Dank im Voraus.

  • Hier ist die Antwort, gibt es irgendwelche "Pos" - Funktion zu finden bytes?.
  • Tolle und schnelle Antwort. (ich habe über 1h und die Hälfte, um nichts zu finden ist, während u hat es in ..5'?). Danke!!! Ich habe zu studieren, etwas mehr über Zeiger und solche, um die Nutzung dieser Funktionen.
  • Ich werde eine überarbeitete version von Andreas Antwort für Sie, um zu studieren.
InformationsquelleAutor Dimitris Nats | 2012-12-01
  1. 12
    function ByteArrayPos(const SearchArr : array of byte; const CompArr : array of byte) : integer;
//  result=Position or -1 if not found
var
  Comp,Search : AnsiString;
begin
  SetString(Comp, PAnsiChar(@CompArr[0]), Length(CompArr));
  SetString(Search, PAnsiChar(@SearchArr[0]), Length(SearchArr));
  Result := Pos(Search,Comp) - 1;
end;
    • Genial! Genau das, was ich suchte.
    • Ich Frage mich, wenn Ihre Antwort ist ja oder Nein. Ich meine, muss Pos führen Sie eine überprüfen Sie jedes byte 1 von 1?
    • Ja und Nein, irgendwo muss getan werden überprüfen Sie byte für byte, aber es gibt keine müssen reimplementiert werden.
    • Ok, es macht Sinn.
    • Da diese Funktion behandelt die Daten als strings intern ich war mir nicht sicher, ob das funktionieren würde, wenn Sie Nullen in den Daten, aber ich habe es ausprobiert und es funktioniert.
    • Es funktioniert, denn es arbeitet auf strings und nicht dann, PAnsiChar.

    InformationsquelleAutor bummi
  2. 7

    Hier ist eine überarbeitete version von Andreas Antwort hier.

    function BytePos(const Pattern: array of byte; const Buffer : array of byte): Integer;
var
  PatternLength,BufLength: cardinal;
  i,j: cardinal;
  OK: boolean;
begin
  Result := -1;
  PatternLength := Length(Pattern);
  BufLength := Length(Buffer);
  if (PatternLength > BufLength) then
    Exit;
  if (PatternLength = 0) then
    Exit;
  for i := 0 to BufLength - PatternLength do
    if Buffer[i] = Pattern[0] then
    begin
      OK := true;
      for j := 1 to PatternLength - 1 do
        if Buffer[i + j] <> Pattern[j] then
        begin
          OK := false;
          Break;
        end;
      if OK then
        Exit(i);
    end;
end;

begin
  WriteLn(BytePos(B,A)); // 3
  WriteLn(BytePos(C,A)); // -1
  ReadLn;
end.

    Bummis Antwort ist zu bevorzugen, wenn. Viel besser.

    Nur eine Bemerkung wie bereits in den Kommentaren.

    Für kleine Datensätze BytePos übertrifft ByteArrayPos, während für große Datensätze (10.000 Stück) der Leistung ist es Umgekehrt.

    Dies ist für die 32-bit-Modus, wo der assembler optimiert Pos() system-Funktion funktioniert am besten für große datasets.

    Im 64-bit Modus gibt es aber keinen assembler optimiert, Pos () - Funktion.
    In meinem Vergleichstest BytePos ist 4-6 mal schneller als ByteArrayPos für alle Arten von dataset-Größen.

    Update

    Den benchmark-test wurde mit XE3.

    Während des Tests entdeckte ich eine fehlerhafte purepascal loop in das System.pas-Funktion Pos().

    Einer Verbesserung Anforderung wurde Hinzugefügt, QC111103, wo die vorgeschlagene Funktion ist etwa 3 mal schneller.

    Ich auch optimiert, der oben BytePos ein bisschen und präsentieren Sie hier unten als ByteposEx().

    function BytePosEx(const Pattern,Buffer : array of byte; offset : Integer = 0): Integer;
var
  LoopMax    : Integer;
  OK         : Boolean;
  patternP   : PByte;
  patStart   : Byte;
  i,j        : NativeUInt;
begin
  LoopMax := High(Buffer) - High(Pattern);
  if (offset <= LoopMax) and
     (High(Pattern) >= 0) and
     (offset >= 0) then
  begin
    patternP := @Pattern[0];
    patStart := patternP^;
    for i := NativeUInt(@Buffer[offset]) to NativeUInt(@Buffer[LoopMax]) do
    begin
      if (PByte(i)^ = patStart) then
      begin
        OK := true;
        for j := 1 to High(Pattern) do
          if (PByte(i+j)^ <> patternP[j]) then
          begin
            OK := false;
            Break;
          end;
        if OK then
          Exit(i-NativeUInt(@Buffer[0]));
      end;
    end;
  end;
  Result := -1;
end;
    • Ja, ich kann verstehen, Ihre überarbeitete Funktion viel leichter, als das original. Ich danke Ihnen so sehr für Ihre Mühe.
    • Es ist nicht so einfach zu Lesen wie Bummi der Umsetzung, aber in der Theorie könnte dies viel schneller, da es nicht die Daten kopieren. Daher +1 für diese ein. Könnte es einen Unterschied machen, wenn es oft oder auf großen Datenmengen. Ich wollte eigentlich nicht den Unterschied Messen wenn.
    • Ich habe ein benchmark auf einem kleinen Datensatz (oben) und einem großen dataset (10000 Elemente). Für einen Treffer am Ende BytePos ist ein wenig mehr als 3 mal schneller in dem kleinen Datensatz, während für die großen Datensatz das Ergebnis ist das Gegenteil. Schlussfolgerung: Die Zuordnung der beiden Zeichenfolgen in ByteArrayPos geben eine Leistungseinbuße für kleine Datensätze, während die optimierte Pos system-Funktion zeichnet sich für große Datensätze.
    • hast du die Optimierung ausgeschaltet oder eingeschaltet?
    • Optimierung auf, läuft im release-Modus.
    • Sorry, gelöscht, Letzte Bemerkung. Dies ist, was ich ment, um zu sagen: Oh, ich sollte erwähnen, dass der bench mark wurde in der 32-bit-Modus. Im 64 bit-Modus, es gibt keine assembler optimiert Pos() Funktion. Und die performance ist viel schlechter als BytePos. Ein Faktor von 4-6 für kleine und große Datenmengen.
    • u verpassen eine weitere Optimierung - und der Grund, PByte wäre besser als der Zugriff auf Arrays in Schleifen 🙂 es sei denn Pattern[0] = Pattern[1] sollten Sie überspringen den rest des Puffers gesucht, der inneren Schleife. Ich erinnere mich nicht, wer waren die Personen, die 1. geprägt ist dieser Algorithmus, noch sollten Sie haben eine variable distance als offset zum nächsten auftreten des 1. byte in das Muster, so, dass Sie möchten, überspringen Sie einfach die grundlose Suche nach Pattern[0] für die nächsten J Zeichen 🙂
    • verfolgen Sie alternative Muster beginnen innerhalb der inneren Schleife wäre vielleicht effektiv. Hast du das probiert? Ich studierte, wie die purepascal Implementierung von Pos gemacht wurde. Ja, es wurde kurz in der Anleitung, aber viel weniger effektiv, als BytePos. Ich habe eine optimierte version der BytePos, die Geschwindigkeit Dinge ein wenig für große datasets " im 32-bit-Modus, mit PByte.
    • Nein, nur spekulieren. Eigentlich brauche ich keine schnelle Suche mit Buchstabenfolgen 🙂 Aber ich habe mal darüber nachgedacht und schließlich zwei Namen gegoogelt und verglichen Ihre algo mit meinen Ideen. Und eigentlich ist mir es würde nicht schwer sein, dieser code in x86-assembler, wenn ich brauche, so dass ich nur don ' T Pflege über DCC codegen Effizienz zu Messen. BTW, ist SetString kopieren von Inhalten wie UniqueString tut ? außer, dass ich nicht sehen kann, warum Ihr code kann schneller sein als die bummi ist ein
    • wenn das "keeping track" bedeutet, dass der Sprung zum nächsten ungescannte char, I+J, dann ist das weniger efective. Betrachten Muster "ABCDAB" in Puffer wie "ABDEFABCDAB". Aktuelle code Scannen würde, "B" und "D" Buchstaben zweimal und den rest einmal. Mit I+J änderung alle Briefe würde einmal gescannt werden. Mit distance var Buchstaben "E" und "F" wäre übersprungen und nie in Betracht gezogen. Okay, in diesem Beispiel würde es wahrscheinlich keinen Unterschied machen - der Puffer würde trotzdem vollständig gezogen in CPU-cache, aber auf einige mehr sparse-Muster, es könnte einen Unterschied machen.
    • href="http://docwiki.embarcadero.com/Libraries/XE2/en/System.SetString" >SetString lässt sich eine Kopie. Ich kann nicht sehen, wie überspringen von E und F, da Sie den Beginn einer neuen Muster. Und für hand-coding, assembler, haben Sie nicht getan, für die letzten 25 Jahre 🙂
    • u hast wahrscheinlich Recht über E und F, mein Gedächtnis wohl versagt mir. en.wikipedia.org/wiki/Boyer–Moore_string_search_algorithm
    • waren Sie vielleicht denken, der die Boyer-Moore-Algorithmus, bis-Sprung-Tabellen zu überspringen, Teile der such-string.

    InformationsquelleAutor LU RD
Schreibe einen Kommentar