如何快速评估零集？

Question

最近的code golfing post 询问了以下在 C 中快速实现的可能性（假设n 是一个无符号整数）：

if (n==6 || n==8 || n==10 || n==12 || n==14 || n==16 || n==18 || n==20)

一种可能的简化方法是观察数字a[]={6,8,10,12,14,16,18,20} 形成一个arithmetic progression，因此移动范围，然后使用一些bitwise tricks

if (((n - 6) & 14) + 6 == n)

导致实现更短（并且可能确实更有效），如 John Bollinger 的answered。

现在我要问的是什么是类似优雅（并且希望同样有效）的实现

if (n==3 || n==5 || n==11 || n==29 || n==83 || n==245 || n==731 || n==2189)

提示：这一次数字a[k] 形成一个几何级数：a[k]=2+3^k。

我想在一般情况下，最好的办法是对数字 a[k] 进行排序，然后进行对数搜索以测试 n 是否是排序数组的成员。

Answer 1

这和recognizing a power of three非常相似，你可以适应例如this solution：

bool test(unsigned x) {
    x -= 2;
    if (x > 2187)
        return 0;
    if (x > 243)
        x *= 0xd2b3183b;
    return x <= 243 && ((x * 0x71c5) & 0x5145) == 0x5145;
}

在给定的范围内，这可以进一步简化（通过蛮力找到）：

bool test2(unsigned x) {
  x -= 2;
  return x <= 2187 && (((x * 0x4be55) & 0xd2514105) == 5);
}

Answer 2

提示：这次数字a[k] 形成几何级数：a[k]=2+3^k。

n = 2 + 3^k
n - 2 = 3^k

(n - 2) / 3^k = 1
(n - 2) % 3^k = 0

k = 0 ~ n-2 = 3^0 = 1, n = 3
k = 1 ~ n-2 = 3^1 = 3, n = 5
k = 2 ~ n-2 = 3^3 = 9, n = 11

if (n > 2 && isPow(n-2, 3))

带有函数isPow(x,y)的定义

bool isPow(unsigned long x, unsigned int y)
{
    while (x % y == 0)
    {
        x /= y;
    }

    return x == 1;
}

n = n  ~ n-2 = 3^k/3 = 3^(k-1)/3 = .. = 3^1/3 = 1%3 != 0
n = 11 ~ n-2 = 9/3 = 3/3 = 1%3 != 0
n = 5  ~ n-2 = 3/3 = 1%3 != 0
n = 3  ~ n-2 = 1%3 != 0

同样我们可以扣除k..

int k = findK(n-2, 3);

int findK(unsigned long x, unsigned int y)
{
    unsigned int k = 0;

    while (x % y == 0)
    {
        x /= y;
        k++;
    }

    if (x == 1) return k;
    else return (-1);
}

n - 2 = 3 * 3^(k-1)       for k > 0
(n - 2) / 3 = 3^(k-1)
(n - 2) / 3 / 3 = 3^(k-2)
(n - 2) / 3 / 3 / 3 = 3^(k-3)
(n - 2) / 3 / 3 / 3 / 3 = 3^(k-4)
..
(n - 2) / 3 / 3 / ..i times = 3^(k-i)
..
(n - 2) / 3 / 3 / ..k times = 3^0 = 1

Answer 3

一种非常有效的方法是使用集合，尤其是unordered_set。作为哈希表，搜索是平均常数，最差的线性。它也比一系列条件优雅得多，并且可以很好地扩展。

只需插入要比较的值，然后 count 插入集合中的值。如果找到，它就是您的测试值之一。

std::unordered_set< int > values;
values.insert( 3 );
values.insert( 5 );
values.insert( 11 );
values.insert( 29 );
values.insert( 83 );
values.insert( 245 );
values.insert( 731 );
values.insert( 2189 );

...

if( values.count( input ) )
    std::cout << "Value is in set.\n";
else
    std::cout << "Value is NOT in set.\n";

Answer 4

if ((n > 2) && (2187 % (n - 2) == 0))

检查(n - 2) 是否是3 的幂并且小于或等于2187（3 的 7 的幂）

概括地说，要检查任何无符号整数n 是否是素数k 的幂，您可以检查n 是否除以可以存储在无符号整数中的k 的最大幂。

Answer 5

这是我想出的：

bool b;
if (n >= 3 && n <= 2189)
{
    double d = std::log(n - 2)/std::log(3); // log₃(n - 2)
    b = std::trunc(d) == d; // Checks to see if this is an integer
    // If ‘b’ then ‘n == a[log₃(n - 2)]’
}
else b = false;

if (b)
{
    // your code
}

由于数字n 是一个小整数，因此浮点不准确应该不是问题。

当然，它不会像整数运算那样快，它也不适合表达式，它可能比某种数组搜索更快，特别是如果你在哪里增加最大 n 值。

EDIT 我测试了我的代码（未启用优化），平均而言（对于所有小于或等于 2189 的 n）我的版本耗时 185.849 ns，而 || 版本耗时 116.546 ns，（多次运行我的程序会产生类似的结果）所以这不是更快。 同样出于某种奇怪的原因，当n == 245 时，它将b 设置为false，（应该是真的）。​​

Answer 6

在相关帖子中发现了类似的问题： 你可以使用std::find

bool found = (std::find(my_var.begin(), my_var.end(), my_variable) != my_var.end());
// my_var is a list of elements.

（确保包含 ）。

对于这类东西，在 99% 的情况下，有一个库可以为您完成这项工作。