Tìm một mảng (byte []) bên trong một mảng khác?

Question

Cách đơn giản nhất để tìm một byte [] bên trong một byte [] khác là gì? tôi có một cảm giác tôi có thể làm điều đó với LINQ nhưng tôi không biết làm thế nào.

Lưu ý: Tôi đã thực hiện tìm kiếm với [c#] và không tìm thấy bất cứ điều gì, tôi ngạc nhiên.

Answer 1

Đây là một cách (ngây thơ?) Đơn giản để làm điều đó:

static int search(byte[] haystack, byte[] needle) 
{ 
    for (int i = 0; i <= haystack.Length - needle.Length; i++) 
    { 
     if (match(haystack, needle, i)) 
     { 
      return i; 
     } 
    } 
    return -1; 
} 

static bool match(byte[] haystack, byte[] needle, int start) 
{ 
    if (needle.Length + start > haystack.Length) 
    { 
     return false; 
    } 
    else 
    { 
     for (int i = 0; i < needle.Length; i++) 
     { 
      if (needle[i] != haystack[i + start]) 
      { 
       return false; 
      } 
     } 
     return true; 
    } 
} 

Answer 2

bạn có thể đã tự tìm ra điều này nhưng đôi khi tôi thích làm điều đơn giản.

bool found = false; 
int i = 0; 
for(; i < byteArray.Length || found; i++) 
{ 
    if(byteArray[i] == lookingFor) 
    { 
    found = true; 
    } 
} 

Answer 3

Hãy thử này với việc sử dụng các biểu thức lambda:

private bool CheckPatternInArray(byte[] array, byte[] pattern) 
{ 
    int fidx = 0; 
    int result = Array.FindIndex(array, 0, array.Length, (byte b) => 
      { 
       fidx = (b == pattern[fidx]) ? fidx + 1 : 0; 
       return (fidx == pattern.Length); 
      }); 
    return (result >= pattern.Length - 1); 
} 

Nếu bạn đang theo đuổi những nhanh nhất, kiểm tra các giải pháp here.

Answer 4

Dưới đây là một phiên bản nhanh hơn của Ergwun's excellent answer:

static int SearchBytes(byte[] haystack, byte[] needle) { 
    var len = needle.Length; 
    var limit = haystack.Length - len; 
    for(var i = 0; i <= limit; i++) { 
     var k = 0; 
     for(; k < len; k++) { 
      if(needle[k] != haystack[i+k]) break; 
     } 
     if(k == len) return i; 
    } 
    return -1; 
} 

Trong một thử nghiệm ngắn với một đống cỏ khô 11MB và 9 byte kim, đây là nhanh hơn khoảng ba lần.

Các tối ưu là:

• Không có chức năng cuộc gọi mỗi lần thông qua các vòng ngoài.
• Độ dài của kim và giới hạn tìm kiếm được lưu trong bộ nhớ cache.
• Kiểm tra độ dài dư thừa ở đầu match() bị xóa.

Tất nhiên đối với mảng byte dài bạn muốn sử dụng cái gì đó như tìm kiếm Boyer-Moore, nhưng với nhiều mục đích, một thuật toán đơn giản như thế này đủ tốt và có đặc điểm ngắn gọn và dễ hiểu và xác minh.