Question

通过整数枚举并返回打开的每个位的指数的最快方法是什么？看过使用＆lt;＆lt;＆lt;＆lt;＆lt;另一个使用Math.Pow。想知道是否有其他事情真的很快。

感谢。

Answer 1

最快的方式？查找表几乎总是最快的方式。构建一个包含40亿个条目的int [] []数组，每个int一个，包含所需数字的数组。当然，初始化表需要一些时间，但查找速度将非常快。

我注意到你还没有说出“最快”的含义是否足以让任何人真正回答这个问题。假设启动成本可以忽略，这是否意味着最快的摊还时间，包括启动时间或边际查询时间？我的解决方案草图假定后者。

显然，具有20亿字节地址空间的32位机器将没有足够的地址空间来存储300亿字节的数组。给自己一台64位机器。如果你想让它快速安装，你至少需要安装那么多的物理内存 - 否则分页会杀了你。

我确信希望在每次查找时节省的几纳秒值得购买所有额外的硬件。或者你可能实际想要最快的方式？

： - ）

Answer 2

我认为位移是最快的。未经测试，但我认为以下内容应该很快（至少与IEnumerables一样快）。

IEnumerable<int> GetExponents(Int32 value)
{
    for(int i=0; i<32; i++)
    {
        if(value & 1)
            yield return i;
        value >>= 1;
    }
}

如果您想要更快，可以考虑返回List<int>。

Answer 3

IEnumerable无法执行。优化本主题中的一些示例：

第一个（最快 - 10M运行2.35秒，范围1..10M）：

static uint[] MulDeBruijnBitPos = new uint[32] 
{
  0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 
  31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
};

static uint[] GetExponents(uint value)
{
    uint[] data = new uint[32];
    int enabledBitCounter = 0;

    while (value != 0)
    {
        uint m = (value & (0 - value));
        value ^= m;
        data[enabledBitCounter++] = MulDeBruijnBitPos[(m * (uint)0x077CB531U) >> 27];
    }

    Array.Resize<uint>(ref data, enabledBitCounter);
    return data;
}

另一个版本（第二快 - 对于10M运行为3秒，范围为1..10M）：

static uint[] GetExponents(uint value)
{
    uint[] data = new uint[32];
    int enabledBitCounter = 0;

    for (uint i = 0; value > 0; ++i)
    {
        if ((value & 1) == 1)
            data[enabledBitCounter++] = i;
        value >>= 1;
    }

    Array.Resize<uint>(ref data, enabledBitCounter);
    return data;
}

Answer 4

一个字节的位的查找数组应该接近安全C＃代码中最快的速度。将4个字节中的每个字节移出整数（根据需要转换为uint）并索引到数组中。

查找数组的元素可以是指数数组，或者，取决于您对这些位执行的操作，也许是可以使用的委托。

Answer 5

只是为了好玩，这是使用LINQ的单线程。

这当然不是最快的方法，尽管它与使用yield和迭代器块的其他答案相差不远。

int test = 42;

// returns 1, 3, 5
//   2^1 + 2^3 + 2^5
// =   2 +   8 +  32
// = 42
var exponents = Enumerable.Range(0, 32).Where(x => ((test >> x) & 1) == 1);

为了更快速的解决方案，我可能会返回一个普通的集合，而不是使用迭代器块。像这样：

int test = 2458217;

// returns 0, 3, 5, 6, 9, 15, 16, 18, 21
//   2^0 + 2^3 + 2^5 + 2^6 + 2^9 +  2^15 +  2^16 +   2^18 +    2^21
// =   1 +   8 +  32 +  64 + 512 + 32768 + 65536 + 262144 + 2097152
// = 2458217
var exponents = GetExponents(test);

// ...

public static List<int> GetExponents(int source)
{
    List<int> result = new List<int>(32);

    for (int i = 0; i < 32; i++)
    {
        if (((source >> i) & 1) == 1)
        {
            result.Add(i);
        }
    }

    return result;
}

Answer 6

最快给出输入的分布？如果通常只设置一个位，那么这可能比寻找设置位的循环更快。

从接受的答案中找出position of the least significant bit，它取自Bit Twiddling Hacks，此解决方案循环，查找，清除并返回每个连续最低有效位的位置。

   static int[] MulDeBruijnBitPos = new int[32] 
    {
      0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 
      31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
    };

    static IEnumerable<int> GetExponents(UInt32 v)
    {
        UInt32 m;

        while( v != 0 ) {
          m = (v & (UInt32) (-v));
          yield return MulDeBruijnBitPos[((UInt32) (m * 0x077CB531U)) >> 27];
          v ^= m;
        }
    }

它只会循环次数设置。

Answer 7

我猜比特移位（＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;

Answer 8

如果你不想用一点C ++：

 void func(int i, int& n, int a[]){
  n = 0;
  if (i < 0) a[n++] = 31;
  i <<= 1;
  if (i < 0) a[n++] = 30;
  i <<= 1;
  if (i < 0) a[n++] = 29;
  i <<= 1;

  ...

  if (i < 0) a[n++] = 0;
}

通过打开整数位来枚举的最快方法

8 个答案: