Java 检测二进制序列的第n项

我有一个遵循特定逻辑的二进制序列 它以

0开始

和

第n项=第（n-1）项的顺序+

0

+逆（n-1）项）

例如：

这里，我需要找出第k个序列的第n项

我的看法：

我编写了一个递归函数来计算第k个序列中的项数

  public static long noOfElements(long elements){
     long answer;
     if(elements == 1)
        return 1;
     else
     answer = 1 + 2*noOfElements(elements-1);
     return answer;
}

经过分析，我发现序列遵循一定的模式，第k个序列可以被分解为一半，切换0和1的值可以跟踪结果

下面的函数递归地将给定序列分解为[0,0,1]

public static long letsBegin(long reqd, long length){
    long mid = (length + 1)/2;
    if(length <= 3){
        return reqd;
    }else{
        if(reqd > mid){
            reqd = reqd - 2*(reqd-mid);
            switcher();                 //Switcher stores if the value is switched
            return letsBegin(reqd, mid);
        }else{
            return letsBegin(reqd, mid);
        }
    }
}

公共静态长letsBegin（长需求，长长度）{
长中=（长度+1）/2；
if（长度中间）{
reqd=reqd-2*（reqd-mid）；
切换器（）；//切换器存储值是否已切换
返回letsBegin（需要，mid）；
}否则{
返回letsBegin（需要，mid）；
}
}
}

最后，我在[0,0,1]中有索引1、2或3，并相应地输出值。 这里的问题是

它在一些未知情况下失败（可能是我的逻辑错误）

序列的数量最多可达50个，使得元素的数量=1125899906842623，因此，输出值所需的时间太长（>2秒） 可能出了什么问题？我的逻辑不正确吗

您缺少一个case（当reqd==mid时）并使用不正确的长度（mid而不是mid-1）调用递归函数。在这些修复之后，函数如下所示：

public static long letsBegin(long reqd, long length){
    long mid = (length + 1)/2;
    if(length <= 3){
        return reqd;
    } else{
        if(reqd > mid){
            reqd = reqd - 2*(reqd-mid);
            switcher();     //Switcher stores if the value is switched
            return letsBegin(reqd, mid-1);
        } else if(reqd < mid) {
            return letsBegin(reqd, mid-1);
        } else {
            return 0;
        }
    }
}

公共静态长letsBegin（长需求，长长度）{
长中=（长度+1）/2；
if（长度中间）{
reqd=reqd-2*（reqd-mid）；
切换器（）；//切换器存储值是否已切换
返回letsBegin（需求，mid-1）；
}否则，如果（需求

而且，代码比需要的复杂得多。请尝试改用以下重复关系：

T(n, k) = T(n, k-1)            if n < 2^{k-1}
        = 0                    if n = 2^{k-1}
        = 1 - T(2^k-n, k-1)    otherwise

T（n，k）=T（n，k-1）如果n<2^{k-1}
=0如果n=2^{k-1}
=1-T（2^k-n，k-1），否则

通过递归，第k个序列中的元素数为

2^（k+1）-1

：

static int foo(long n, int k) { //n-th element (indexed from 0) in k-th sequence
    long length = (2L << k) - 1; // computes 2^(k+1)-1
    if(n >= length) return -1; // prevent invalid inputs
    if(n == length/2) return 0; // middle point
    if(n < length/2) return foo(n, k-1); //left half
    return 1 - foo(length - n - 1, k-1); //right half
}

第k个序列中的静态int foo（长n，int k）{//n个元素（从0开始索引） long length=（2L=length）返回-1；//防止无效输入 if（n==length/2）返回0；//中间点 if（n 在最后一个递归调用中，您将翻转数组和返回值

编辑：

---

请务必使用

（2L递归导致大输入的堆栈溢出：-/@Rockstar怎么回事？您说过最多有50个序列。请注意，在63个序列中，位置不再适合
long
，您需要使用
BigInteger
或其他东西来表示位置。此外，此方法在堆栈上分配的空间很少，您可以在一台普通计算机上至少需要数千次递归调用才能引起任何问题。是的，对于输入k=50，n=1125899906842622，如果（n

My fail，

（2）谢谢，它被修复了。但是现在它的故障超过了时间限制>2秒：-/
static int foo(long n, int k) { //n-th element (indexed from 0) in k-th sequence
    long length = (2L << k) - 1; // computes 2^(k+1)-1
    if(n >= length) return -1; // prevent invalid inputs
    if(n == length/2) return 0; // middle point
    if(n < length/2) return foo(n, k-1); //left half
    return 1 - foo(length - n - 1, k-1); //right half
}