Java-Pisano周期计算错误

我试图制作一个程序，输出用户在斐波那契序列中输入的某个数字的Pisano周期。这个节目在我10岁之前都很好。程序循环无限。当我有一个120个余数的数组时，我检查数组（Pisano周期10是60，所以要检查数组是否重复，我需要至少60*2=120个余数）。但是数组不一样。以下是阵列（剩余的数字1到60和61到120）

这是我的密码：

主要代码： `导入java.util.Scanner

公共类皮萨诺期{

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    boolean quit = false;
    while (!quit) {
        System.out.print("Enter a number: ");
        int divisor = scan.nextInt();
        FibonacciSequence f = new FibonacciSequence();
        System.out.println("Computing...");
        System.out.println("The Pisano Period for "+divisor+" is: "+f.getPisanoPeriod(divisor));            
        printDivisor(20);
        System.out.print("Do you want to do another one? (y/n): ");
        String reply = scan.next();
        if (reply.equals("n") || reply.equals("no")) {
            printDivisor(20);
            System.out.println("Bye!");
            quit = true;
        }
    }

}

private static void printDivisor(int n) {
    System.out.print("\n");
    for (int i=1; i<=n; i++) {
        System.out.print("*");
        if (i==n) {
            System.out.print("\n\n");
        }
    }
}
}

publicstaticvoidmain（字符串[]args）{
扫描仪扫描=新扫描仪（System.in）；
布尔退出=假；
而（！退出）{
System.out.print（“输入一个数字：”）；
整数除数=scan.nextInt（）；
FibonacciSequence f=新的FibonacciSequence（）；
System.out.println（“计算…”）；
System.out.println（““+除数+”的Pisano周期为：”+f.getPisanoPeriod（除数））；
打印除数（20）；
System.out.print（“您想再做一次吗？（y/n）：”；
字符串reply=scan.next（）；
if（reply.equals（“n”）| reply.equals（“no”））{
打印除数（20）；
System.out.println（“再见！”）；
退出=真；
}
}
}
专用静态无效打印除数（int n）{
系统输出打印（“\n”）；
对于（int i=1；i而言，问题显然在于第
行余数数组[index\u counter]=（int）（序列[index\u counter]%n）；

强制转换将整数从双精度向下舍入，因此两个数组中的余数不同。我无法使用很长时间，因为它没有那么多内存容量。因此，我将BigInteger类用于序列数组，从而解决了问题

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    boolean quit = false;
    while (!quit) {
        System.out.print("Enter a number: ");
        int divisor = scan.nextInt();
        FibonacciSequence f = new FibonacciSequence();
        System.out.println("Computing...");
        System.out.println("The Pisano Period for "+divisor+" is: "+f.getPisanoPeriod(divisor));            
        printDivisor(20);
        System.out.print("Do you want to do another one? (y/n): ");
        String reply = scan.next();
        if (reply.equals("n") || reply.equals("no")) {
            printDivisor(20);
            System.out.println("Bye!");
            quit = true;
        }
    }

}

private static void printDivisor(int n) {
    System.out.print("\n");
    for (int i=1; i<=n; i++) {
        System.out.print("*");
        if (i==n) {
            System.out.print("\n\n");
        }
    }
}
}

private double[] Sequence = new double[2];
private BadNumberException badnumexception = new BadNumberException("Number of fibonnacci numbers is too small.");
private TooLittleNumbersException tlnexception = new TooLittleNumbersException();

public FibonacciSequence() {
    try {
      generate(10);
    }
    catch(BadNumberException e) {System.out.println(e.getMessage());}
}

private int getSequenceLength() {
    return Sequence.length;
}

private boolean checkForPattern(int[] array) {
    int half_point = array.length/2;
    boolean return_boolean = true;
    for (int i=0; i<half_point; i++){
        if (array[i]!=array[i+half_point]){
            return_boolean = false;

            break;
        }
        else {
            if (i==half_point-1) {
                System.out.println(Arrays.toString(Arrays.copyOfRange(array, 0, half_point)));
                System.out.println(Arrays.toString(Arrays.copyOfRange(array, half_point, array.length)));
            }
        }
    }
    if (array.length==120){
        System.out.println(Arrays.toString(Arrays.copyOfRange(array, 0, half_point)));
        System.out.println(Arrays.toString(Arrays.copyOfRange(array, half_point, array.length)));
    }
    return return_boolean;
}

public int getPisanoPeriod(int n) {
    int return_value = -1;
    int max_index_counter=0;
    boolean error = true;
    while (error) {
        try {
          boolean pattern_reached = false;
          int[] remainder_array = new int[0];
          int index_counter = 0;
          while (!pattern_reached) {
              if (index_counter>=max_index_counter) {
                  max_index_counter = index_counter;
                  System.out.println(max_index_counter);
              }
              int[] temp_array = new int[remainder_array.length+1];
              for (int i=0; i<remainder_array.length; i++) {
                  temp_array[i] = remainder_array[i];
              }
              remainder_array = temp_array;
              remainder_array[index_counter] = (int) (Sequence[index_counter]%n);
              //System.out.println(Arrays.toString(Sequence));
              if (remainder_array.length%2==0 && index_counter>n)
                  pattern_reached = checkForPattern(remainder_array);
              index_counter++;
          }
          return_value = remainder_array.length/2;
          error = false;
        }
        catch (IndexOutOfBoundsException e) {
            try {
                throw tlnexception;
            } catch (TooLittleNumbersException a) {
                try {
                    //if (getSequenceLength()<50)
                    generate(getSequenceLength()+1);
                    /*else
                        error=false;*/
                    //System.out.println(getSequenceLength()+10);
                } catch (BadNumberException b) {}
            }
        }
    }
    return return_value;
}

public void generate(int n) throws BadNumberException {

    if (n<=2) throw badnumexception;
    double[] generated_array = new double[n];
    generated_array[0] = 1;
    generated_array[1] = 1;
    for (int i=2; i<n; i++) {
        generated_array[i] = generated_array[i-1]+generated_array[i-2];
        //System.out.println(generated_array[i]);
    }
    Sequence = generated_array;
}
}