C 整数数组的位异或和移位

假设一个大小为M的位序列和另一个大小为N的位序列，M>>N。M和N都可以保存在整数数组中：如果N的长度为30，则只需要一个具有一个整数的数组，但如果N的长度为300，则需要一个具有10个整数的数组来存储它

我试图做的是在M中移动N，对于M中的每个可能位置k，通过XORing来找到N和M（k）之间的差异数。如果M有10000位，N有100位，则有10000-100=9900个位置将执行异或比较

您是否知道有一个库可以做到这一点，或者提出一个算法？我知道有很多其他的方法可以做到，但是我相信最快的方法就是这里提出的方法。如果你能想出一个更快的方法，那么我愿意接受建议

我更喜欢C或C++的一些东西，但是其他语言，甚至伪代码也是可以接受的。 提前感谢。

简单方法：

while N < M * (original N) do
  compute and tally up M xor N
  multiply each word (unsigned) in N by 2,   // i.e. shift left 1 bit
    and add in the carry (= overflow) from the previous word.

而N

现代CPU功能强大，即使是10000位和100位，也只需要几毫秒

“计算并汇总M xor N”

sum=0
对于（i=0；i这里有一个完整且有效的解决方案。轻微的疏忽留给读者作为练习：）

#包括“stdio.h”
#包括“stdlib.h”
#包括“string.h”
#定义M_尺寸100
#定义N_尺寸25
#定义位字节（n）（（n+7）/8）
typedef无符号字符字节；
无效转储字节（字节*arr，大小\u t大小）{
int b；
对于（b=0；b您可以将N向上移位到M上，也可以将M向下移位到N上。当移位N时，如果输入与字大小不一致，您还需要将掩码移位。移位可以缓存到一个以位为单位的字大小数组中，但假定跨多个字的移位是每个字1条指令（如果使用RCR指令）可能不值得冒着重击一级缓存的风险

除非您可以使用POPCNT指令对Core i7处理器进行计数，否则最重要的部分还是位计数。有关位计数的快速实现，请参阅

对于较小长度的N（机器字），通过特殊的内循环，你会获得速度的大幅提高。对于N，我很难理解你的算法！在“计算和汇总M xor N”中，你在哪里使用N？当N向左移位时，整数极限不会有问题吗？还有，Nint
是32位的，请注意它依赖于编译器，尤其是ma对于64位平台，y不适用。算法非常简单；对于10000位和100位，我只需要0.48秒。
sum = 0
for (i=0; i<M/8; i++)
   if M[i] != 0
      w = M[i]
      while w != 0
      if ((w & 1) != 0) sum++   // test LSB
      w /= 2                    // shift right 1 bit

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

#define M_SIZE 100
#define N_SIZE 25
#define bitsToBytes(n) ((n + 7)/8)

typedef unsigned char byte;

void dumpBytes(byte *arr, size_t size) {
   int b;
   for (b=0; b<size; b++) {
      printf("%02x", *arr++);
   }
   printf("\n");
}

int main(int argc, char *argv[]) {

   byte M[bitsToBytes(M_SIZE)], N[bitsToBytes(N_SIZE)];

   /* Fill M and N with random bits */

   int b;

   for (b=0; b<sizeof(M); b++) {
      M[b] = 0xff & rand();
   }
   for (b=0; b<sizeof(N); b++) {
      N[b] = 0xff & rand();
   }

   /* Create a couple of arrays big enough for M_SIZE + N_SIZE, 
      to allow shifting N all the way before the left of M. */
   #define MN_SIZE (M_SIZE + N_SIZE)
   #define MN_BYTES (bitsToBytes(MN_SIZE))
   byte MM[MN_BYTES], NN[MN_BYTES];

   /* Zero out MM, NN, then copy M, N there (right justified). */
   int offset = sizeof(MM) - sizeof(M);
   memset (MM, 0, sizeof(MM)); memcpy(MM+offset, M, sizeof(M));
   offset = sizeof(NN) - sizeof(N);
   memset (NN, 0, sizeof(NN)); memcpy(NN+offset, N, sizeof(N));

   dumpBytes(MM, MN_BYTES);
   /* Count up "difference bits" until NN has been left-shifted into oblivion. */
   int s;
   for (s=0; s<MN_SIZE; s++) {
      int sum = 0;
      for (b=0; b<MN_BYTES; b++) {
  int xor = MM[b] ^ NN[b];
  while (xor != 0) {
     sum += (xor & 1);
     xor >>= 1;
  }
      }
      dumpBytes(NN, MN_BYTES);
      printf("Shift: %4d; bits: %3d.\n", s, sum);
      /* shift NN one bit to the left */
      for (b=0; b<MN_BYTES; b++) {
  NN[b] <<= 1;
  if (b < (MN_BYTES - 1) && ((NN[b+1] & 0x80) != 0)) NN[b] |= 1;
      }
   }
}