0

现在，我正在开发一个需要顺序文本密钥生成的项目。我需要使用与某个键对应的整数为键生成器播种，构造函数将其转换为键。

我的键生成器重载了增量运算符，因此字符串直接递增，而不是我之前所做的，即递增索引值，然后将索引转换为我想要生成的每个键的键。

我的问题是我在生成密钥时要使用的字符集有限。我必须在键中找到要递增的字符，找出它在我的字符集中的位置，找到集合中的下一个字符，然后用集合中的下一个字符替换键中的字符。

这是我的代码：

// Not the full charset
std::string charset = "abcdefghijklmnopqrstuvwxyz0123456789"; 
std::string key;

key.push_back(charset[0]);

for(unsigned int place = 0; place < key.length(); place++)
{
    if(key[place] == charset[charset.length() - 1])
    {
        // Overflow, reset char at place
        key[place] = charset[0];

        if((key.length() - 1) < (place + 1))
        {
            // Carry, no space, insert char
            key.insert(key.begin(), charset[0]);
            break;
        }
        else
        {
            // Space available, increment next char
            continue;
        }
    }
    else
    {
        // Increment char at place
        key[place] = charset[charset.find(key[place]) + 1];
        break;
    }
}

在分析中，我发现搜索操作确实减慢了速度。有没有更快的方法来做到这一点？我想从字符集创建一个链接列表，但在我这样做之前，我想对此进行一些输入。

4

5 回答 5

3

与其进行查找，不如使用反向翻译数组？数组索引是字符，数组中的值是它的数值（或另一个数组的索引）。

key[place] = charset[reverse_charset[key[place]] + 1];
于 2010-01-14T20:50:32.540 回答
2

这是广义基数转换问题的另一个版本，n=36。

您想要做的是将您的密钥视为一个无符号整数，并将您分发的“字符串”视为该密钥的基数 36 (az + 0-9) 表示形式。

分发一个键然后将“下一个键”值转换为 base36 字符串，然后递增下一个键值。

要进行转换，请执行与将任何整数转换为十六进制表示相同的操作，但在模数数学中交换 36 而不是 16。我将把它作为练习留给读者。:)

于 2010-01-14T20:58:50.633 回答
1

您可以存储与键长度相同的向量，其中向量中的每个元素都是键中相应字符的字符集中的索引。

例如，如果key[0]是“c”，则为thisVector[0]2，因为“c”是字符集中的第三个字符。

然后将对该整数向量执行所有操作，从而消除对find字符串进行操作的必要性。

于 2010-01-14T20:53:06.260 回答
1

我不确定我是否完全理解您想要做什么，但这里有一个小控制台程序，它使用您的字符集作为数字打印出以 36 为基数的 36*36*36 3 位键序列。所以它从 aaa 开始，到 999 结束。

#include <stdio.h>
typedef int Number;
const size_t N = 3;
size_t B = 36;
Number key[N] = {0};
bool carry = false;
char A[] = "abcdefghifjlmnopqrstuvwxyz0123456789";

void incr(size_t i)
{
    if(!carry)
    {
        return;
    }
    ++key[i];
    if(key[i] == B)
    {
        key[i] = 0;
    }
    else
    {
        carry = false;
    }
}

void Incr()
{
    carry = true;
    size_t i = 0;
    while(carry)
    {
        incr(i++);
    }
}

void Print()
{
    for(int i = N - 1; i >= 0; --i)
    {
        printf("%c", A[key[i]]);
    }
    printf("\n");
}

int _tmain(int argc, _TCHAR* argv[])
{
    for(int i = 0; i < B * B * B; ++i)
    {
        Print();
        Incr();

    }
    return 0;
}
于 2010-01-15T11:35:43.527 回答
0

也许您最好将索引处理到字符集中，然后在需要时将它们转换为实际字符？

这将为您节省在字符集中搜索字符的开销。并且将字符集索引转换为字符将是一个恒定时间的操作，与相反的操作不同。

将密钥存储为整数 0 ~ N-1 的向量，其中 N 是字符集的长度。仅在需要时（即在增量之后）将这些整数转换为实际字符。

于 2010-01-14T20:54:07.883 回答