Java：检查arraylist是否是斐波那契序列的一部分

我在学校的任务是实现一种方法，检查给定的

ArrayList

是否是斐波那契序列的一部分

数组不能为空，并且必须大于3

我知道我必须检查数组中的一个数字和下一个数字是否是斐波那契序列的一部分，但是我有很多麻烦，因为你应该接受数组，如果它是序列的任何一部分，而不仅仅是从一开始

e、 g.：

011235

以及

23581321

将被接受

这是到目前为止我的代码。我知道这很有缺陷，但我真的不知道如何继续前进

public class ArrayCheck {
 /**
 * Tests if the given array is a part of the Fibonacci sequence.
 *
 * @param arr array to be tested
 * @return true if the elements are part of the fibonacci sequence
 */
public boolean isFibonacci(ArrayList<Integer> arr) {
    //check if array exists
    if(arr.size() == 0)
        return false;

    //check if array is bigger than 3
    if (arr.size() < 3)
        return false;

    //check for the startsequence of 0,1,1
    else if(arr.get(0) == 0 && arr.get(1) == 1 && arr.get(2) == 1)
        return true;

    //check every number in array
    for(int i = 0; i < arr.size(); i++) {
        //check if i >= 2 is fib
        if(i >= 2) {
            int fibn = i;
            int nextfib = i + 1;

            int fibnew = (fibn - 1) + (fibn - 2);
            int fibnext = (nextfib - 1) + (nextfib - 2);

            if (arr.get(i) != fibnew && arr.get(i + 1) != fibnext)
                return false;
        }
        //check if the order is right
        if(arr.get(i) > arr.get(i+1))
            return false;
    }
    return true;
}

公共类数组检查{
/**
*测试给定数组是否为斐波那契序列的一部分。
*
*@param-arr阵列待测试
*@如果元素是斐波那契序列的一部分，则返回true
*/
公共布尔值isFibonacci（ArrayList arr）{
//检查数组是否存在
如果（arr.size（）==0）
返回false；
//检查数组是否大于3
如果（arr.size（）<3）
返回false；
//检查起始序列是否为0,1,1
否则如果（arr.get（0）==0&&arr.get（1）==1&&arr.get（2）==1）
返回true；
//检查数组中的每个数字
对于（int i=0；i=2是否为fib
如果（i>=2）{
int fibn=i；
int nextfib=i+1；
int fibnew=（fibn-1）+（fibn-2）；
int fibnext=（nextfib-1）+（nextfib-2）；
if（arr.get（i）！=fibnew和&arr.get（i+1）！=fibnext）
返回false；
}
//检查订单是否正确
如果（arr.get（i）>arr.get（i+1））
返回false；
}
返回true；
}

非常感谢您的帮助！

private boolean isFib（最终列表li）{
private boolean isFib(final List<Integer> li) {
    //check if each int is the sum of the two prior ints
    for (int i = 2; i < li.size(); i++) {
        if (li.get(i) != li.get(i - 1) + li.get(i - 2)) {
            return false;
        }
    }

    //reverse the fibonacci sequence and check if we end up at the correct starting point (0, 1)
    int i1 = li.get(0);
    int i2 = li.get(1);

    while (i1 > 0) {
        final int tmp = i1;
        i1 = i2 - i1;
        i2 = tmp;
    }

    return i1 == 0 && i2 == 1;
}

//检查每个整数是否是前两个整数的总和
对于（int i=2；i0）{
最终int tmp=i1；
i1=i2-i1；
i2=tmp；
}
返回i1==0&&i2==1；
}

好吧，你的代码有一些问题。首先，如果你的数组至少有3个项目，你可以检查是否只有前三个是斐波那契序列的开始：

//check for the startsequence of 0,1,1
else if(arr.get(0)==0 && arr.get(1)==1 && arr.get(2)==1){
    return true;
}

这是不好的，因为这意味着不是序列一部分的

0 1 1 5

将返回true

您需要做的是将其分为两个任务：

• 查找序列中的第一个相关编号（即，如果数组以

  7

  开头，您知道这不是序列的一部分；或者，如果数组以

  8

  开头，您知道需要从

  8

  开始检查）
• 找到“开始”后，只需检查数组的其余部分是否遵循斐波那契规则。您需要手动验证前两项

---

public boolean isFibonacci（ArrayList arr）{
如果（arr.size（）<3）{
返回false；
}
/**查找第一个元素是否是序列的一部分：**/
int fib1=0；
int fib2=1；
而（fib1

我建议一种解决方案，在一个单独的

迭代器中提取斐波那契序列生成器，然后使用它检查提供的列表是否匹配序列的任何部分

迭代器非常简单明了：

public static class FiboIterator implements Iterator<Integer> {

    @Override
    public boolean hasNext() { return true; }

    int i = -1, j = -1;   // previous two items of Fibo sequence

    @Override
    public Integer next() {
        int k = (i < 0) ? (j < 0 ? 0 : 1) : (i + j);
        i = j;
        j = k;
        return k;
    }
}

不，因为例如
2,2,4,6
不是斐波那契序列的一部分。那么您接受的是[2 2 4 6 10]，它不是斐波那契序列的一部分。修复它，检查第一个数字。或者不是。点是从索引2开始的循环。这是有效的斐波那契吗？[0 5 5 10]如果实际上不需要检查负数，则由警卫负责。数组中的第一个负值（如果有）至少包含两个正数，这会违反求和约束（如果求和小于0，则没有这两个值大于0）.你说得对。我太谨慎了。谢谢：）你测试过这个实现吗？事实上，在我实现它之后，我运行了一些junit测试，对于实际的斐波那契序列，它不会返回真值，其他一切都起作用了。但是，在更改这一行
while（fib1），因为，正如我“暗示”的那样…它不起作用。特别是当第一个
完成时，
fib1！=arr.get（0）
始终为真，这将导致自动返回
false
。代码完全错误。
public static class FiboIterator implements Iterator<Integer> {

    @Override
    public boolean hasNext() { return true; }

    int i = -1, j = -1;   // previous two items of Fibo sequence

    @Override
    public Integer next() {
        int k = (i < 0) ? (j < 0 ? 0 : 1) : (i + j);
        i = j;
        j = k;
        return k;
    }
}

public static boolean isFibo(List<Integer> seq) {
    if (seq.size() < 3)
        return false;
    final Iterator<Integer> f = new FiboIterator();
    int start = seq.get(0), k;
    while ((k = f.next()) < start);         // roll Fibo to match the starting item in input
    if (start != k)                         // starting item doesn't match
        return false;
    if (start == 1 && seq.get(1) != 1)      // special case: [1, 2, ...]
        f.next(); 
    for (int i = 1; i < seq.size(); i++) {  // check if other items match
        if (seq.get(i) != f.next())
            return false;
    }
    return true;
}

@Test
public void testFibo() {
    assertTrue(isFibo(Arrays.asList(0, 1, 1, 2)));
    assertTrue(isFibo(Arrays.asList(1, 1, 2, 3, 5)));
    assertTrue(isFibo(Arrays.asList(1, 2, 3, 5, 8)));
    assertTrue(isFibo(Arrays.asList(5, 8, 13, 21, 34)));

    assertFalse(isFibo(Arrays.asList(1, 2, 0)));
    assertFalse(isFibo(Arrays.asList(1, 0, 1)));
    assertFalse(isFibo(Arrays.asList(5, 5, 10, 15)));
}