तुलना सरणियों डेल्फी

Question

में मैं 3 सरणियों है, उदाहरण के लिए:

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); 

वहाँ की तुलना करने और सही एक के सूचकांक प्राप्त करने के लिए, के बजाय 1 से प्रत्येक बाइट 1 जाँच करने का एक तरीका है? उदाहरण के लिए:

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

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

अग्रिम धन्यवाद।

Answer 1

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; 

Answer 2

एंड्रियास उत्तर here का एक पुनर्वित्तित संस्करण यहां दिया गया है।

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. 

बम्स का जवाब पसंद करना है, हालांकि। काफी बेहतर।

---

टिप्पणियों में उल्लेख की गई एक टिप्पणी।

छोटे डेटासेट के लिए BytePosByteArrayPos से अधिक प्रदर्शन करता है, जबकि बड़े डेटासेट (10000 आइटम) के प्रदर्शन को उलट दिया जाता है।

यह 32-बिट मोड के लिए है, जहां असेंबलर Pos() सिस्टम फ़ंक्शन अनुकूलित करता है, बड़े डेटासेट के लिए सबसे अच्छा काम करता है।

हालांकि 64-बिट मोड में, कोई असेंबलर अनुकूलित पॉज़() फ़ंक्शन नहीं है। मेरे बेंचमार्क परीक्षण में, BytePos सभी प्रकार के डेटासेट आकारों के लिए ByteArrayPos से 4-6 गुना तेज है।

---

अद्यतन

बेंचमार्क परीक्षण XE3 साथ किया गया था।

परीक्षण के दौरान मैंने System.pas फ़ंक्शन Pos() में एक दोषपूर्ण purepascal पाश की खोज की।

एक सुधार अनुरोध जोड़ा गया है, QC111103, जहां प्रस्तावित कार्य लगभग 3 गुना तेज है।

मैंने उपरोक्त BytePos को थोड़ा सा अनुकूलित किया और इसे नीचे 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;