Question

作为作业的另一个问题，我们被要求找到产生最长的连环标记序列的10个起始数字（n）。（其中0

我注意到了一些小优化，例如从最大到最小，因此添加到阵列的工作量更少，只计算在10,000,000,000 / 2 ^ 10（= 9765625）和10,000,000,000之间，因为必须有10个更长的序列长度，但我看不到我能做的任何事情。有人可以帮忙吗？

相关守则序列搜索算法

long[][] longest = new long[2][10]; //terms/starting number
long max = 10000000000l; //10 billion

for(long i = max; i >= 9765625; i--) {
    long n = i;
    long count = 1; //terms in the sequence

    while(n > 1) {
        if((n & 1) == 0) n /= 2; //checks if the last bit is a 0
        else {
            n = (3*n + 1)/2;
            count++;
        }
        count++;
    }
    if(count > longest[0][9]) {
        longest = addToArray(count, i, longest);
        currentBest(longest); //prints the currently stored top 10
    }
}

存储alg

public static long[][] addToArray(long count, long i, long[][] longest) {
    int pos = 0;
    while(count < longest[0][pos]) {
        pos++;
    }
    long TEMP = count; //terms
    long TEMPb = i; //starting number
    for(int a = pos; a < longest[0].length; a++) {
        long TEMP2 = longest[0][a];
        longest[0][a] = TEMP;
        TEMP = TEMP2;

        long TEMP2b = longest[1][a];
        longest[1][a] = TEMPb;
        TEMPb = TEMP2b;
    }
    return longest;
}

Answer 1

您可以执行类似

的操作

while (true) {
    int ntz = Long.numberOfTrailingZeros(n);
    count += ntz;
    n >>>= ntz; // Using unsigned shift allows to work with bigger numbers.
    if (n==1) break;
    n = 3*n + 1;
    count++;
}

它应该更快，因为它一次执行多个步骤并避免不可预测的分支。 numberOfTrailingZeros是JVM内在的，在现代桌面CPU上只需一个周期。但是，由于零的平均数仅为2，因此效率不高。

Wikipedia解释了如何一次执行多个步骤。这是基于这样的观察：知道k最低有效位足以确定未来的步骤，直到k - 减半发生。基于此（k=17）和filtering out some non-promising values的最佳结果是57秒，用于确定范围1 .. 1e10中的最大值。

collatz序列 - 优化代码

1 个答案:

collat​​z序列 - 优化代码

1 个答案:

collatz序列 - 优化代码