Question

我目前正在编写一个效率非常重要的程序。

在这个程序中，我有时会得到最多4个不同来源的值。我想检查一下我最终得到的任何值是否相同，如果它们相同，我也想知道哪些来源给了我相同的数字。

我可以自己做得很好，所以有人为我这样做并不是我想要的，我只是想知道这样做的有效方法是什么。这是我考虑过的两件事，但我希望有一些更有效，更简单的方法来做到这一点...

想法1：

struct box
{
    char source; // because it won't be above 4
    char value; // because it will be between 2 and 20
};

struct box boxes[4];
int box_count = 0, i;
for(i=0; i<4; i++)
{
    if(hasValue(i))
    {
        boxes[box_count].source = i;
        boxes[box_count++].value = getValue(i);
    }
}

// idk what to do at this point, but here's how to access them...
for(i=0; i<box_count; i++)
{
    printf("source, id : %d, %d\n", boxes[i].source, boxes[i].value);
}

想法2：

struct sources
{
    char sources[4]; // because max 4 sources
    char sources_count;
};

struct sources sources[19] = { 0 }; // because only values between 2 and 20
int i, j, v;
for(i=0; i<4; i++)
{
    if(hasValue(i))
    {
        v = getValue(i)-2; // only between 2 and 20, and array of size 19
        sources[v].sources[sources[v].sources_count++] = i;
    }
}

for(i=0; i<19; i++)
{
    if(sources[i].sources_count>0)
    {
        printf("Duplicate sources: %d", sources[i].sources[0]);
        for(j=1; j<sources[i].sources_count; j++)
        {
            printf(", %d", sources[i].sources[j]);
        }
        printf("\n");
    }
}

那么有更有效的方法吗？

Answer 1

你需要6个比较，比如数字是a，b，c，d，然后你需要检查a == b，a == c，a == d，b == c，b == d ，c == d。

如果您需要将其转换为某种状态，请尝试以下操作：

    s  = (a == b) ?  1 : 0;
    s |= (a == c) ?  2 : 0;
    s |= (a == d) ?  4 : 0;
    s |= (b == c) ?  8 : 0;
    s |= (b == d) ? 16 : 0;
    s |= (c == d) ? 32 : 0;

或者

    s  = (a ^ b) ? 0 :  1;  
    s |= (a ^ c) ? 0 :  2;  
    s |= (a ^ d) ? 0 :  4;  
    s |= (b ^ c) ? 0 :  8;  
    s |= (b ^ d) ? 0 : 16;  
    s |= (c ^ d) ? 0 : 32;

在X86上的Microsoft编译器上，任一序列都是在没有任何分支的情况下实现的。然后使用64个案例，0到63的交换机。请注意，64个状态中只有15个是有效的，其余状态无效，但将所有这些无效情况设置为默认故障情况将允许交换机案例使用单个64条目分支目标表。

在一组4个数字中查找重复项的有效方法

1 个答案: