据我所知，这个问题没有具体的算法，但下面是代码示例：
递归：

public boolean validSequenceFromIndex(int[] sequence, int index) {
  if (index >= sequence.length - 1) return true; // If it is the last index or
  // greater, then it works.

  if (sequence[index + 1] != sequence[index] * sequence[index]) return false; // The
  // pattern does not hold.

  return validSequenceFromIndex(sequence, index + 1); // The sequence is valid at this
  // index, check the rest of the sequence.
}

注意这里的参数是 int[] sequence 和一个 int index 而这个问题只会给你一个 int[] sequence . 只需编写如下函数：

public boolean validSequence(int[] sequence) {
  return validSequenceFromIndex(sequence, 0); // Checks if the sequence is valid starting
  // from the beginning (essentially the whole sequence.
}

它应该只将序列作为参数转换为使用序列和索引。
非递归：

public boolean validSequence(int[] sequence) {
  for (int i = 0; i < sequence.length - 1; i++) { // Loop through entirety of the
  // except for the last index.
    if (sequence[i + 1] != sequence[i] * sequence[i]) return false;
  }
  // All indices checked, the sequence works:
  return true;
}

希望这对你有意义！

这里有一种使用 BigInteger . 但即便如此，我还是限制了 8 因为它们变大了。
迭代调用。

BigInteger[] terms = iterative(8);
for (BigInteger b : terms) {
    System.out.println(b);
}
System.out.println("Sequence array for iteration is " + 
(validate(terms) ? "valid" : "invalid"));

印刷品

2
4
16
256
65536
4294967296
18446744073709551616
340282366920938463463374607431768211456
Sequence array for iterative is valid

重复呼叫

terms = recursive(8);
for (BigInteger b : terms) {
    System.out.println(b);
}
System.out.println("Sequence array for recursion is " + 
(validate(terms) ? "valid" : "invalid"));

印刷品

2
4
16
256
65536
4294967296
18446744073709551616
340282366920938463463374607431768211456
Sequence array for recursion is valid

验证方法

public static boolean validate(BigInteger[] terms) {
    for (int i = 1; i < terms.length; i++) {
        if (!terms[i].equals(terms[i-1].pow(2))) {
            return false;
        }
    }
    return true;
}

迭代法。
只需将第一个术语初始化为 Biginteger.TWO .
然后遍历列表，将前面的每一项提升到 2 .

public static BigInteger[] iterative(int n) {
   if (n < 1) {
        throw new IllegalArgumentException("n must be > 0");
    }
    BigInteger[] terms = new BigInteger[n];
    terms[0] = BigInteger.TWO; // 2^2^0 = 2;
    for (int i = 1; i < n; i++) {
        terms[i] = terms[i-1].pow(2);
    }
    return terms;
}

递归方法。
虽然它可以在没有助手的情况下完成，但是使用助手方法更简单、更有效。
根据分配阵列 n 初始化 0th 元素到 2 .
如有需要，请立即返回 n == 1 否则，调用helper方法。

public static BigInteger[] recursive(int n) {
    if (n < 1) {
         throw new IllegalArgumentException("n must be > 0");
    }
    BigInteger[] terms = new BigInteger[n];
    terms[0] = BigInteger.TWO;
    if (n == 1) {
        return terms;
    }
    return recursiveHelper(terms, n);
}

递归调用方法直到 n == 2 然后简单地分配 n-1 元素中的值 n-2 提升到2的幂
然后退回条款。

private static BigInteger[] recursiveHelper(BigInteger[] terms, int n) {
     if (n > 2) {
        recursiveHelper(terms,n-1);
     }
     terms[n-1] = terms[n-2].pow(2);
     return terms;
}