顺便说一句，最后发布的输入并不完全是 FizzBu​​zz 的反向输入... \'

在这种情况下，您可以做的是获取两个 Fizz/Buzz 之间的偏移/距离，这就是您的 Fizz/Buzz 编号。如果只有一个 Fizz/Buzz，那么 Fizz/Buzz 编号就是它所在的位置，您可以通过获取列表中的第一个数字，然后将其偏移 Fizz/Buzz 索引的位置来计算。

下面是它的伪代码（ 代码假设输入只有一个有效的 Fizz 和 Buzz 值，并且输入中至少有一个数字 ）：

fizzBuzzOutput = { "Fizz", "Buzz", "52", "53", "54", "Fizz", "56", ... }

// same as you did, just dont add +1 to i
fizzPositions = { 0, 5, ... }
buzzPositions = { 1 }

// get the index of the first parsable int
// you could do this with a for loop and try and parse
firstNumberIndex = 2

if (fizzPositions.length > 1) {
    fizz = fizzPositions[1] - fizzPositions[0] // that would 5
} else {
    fizz = fizzBuzzOutput[firstNumberIndex] + (fizzPositions[0] - firstNumberIndex)
}

if (buzzPositions.length > 1) {
    buzz = buzzPositions[1] - buzzPositions[0]
} else {
    // 52 + (1 - 2)
    buzz = fizzBuzzOutput[firstNumberIndex] + (buzzPositions[0] - firstNumberIndex)
}

// you don't need the gcd methods

实际情况比这更复杂。如果输入以 56 结尾，那么 buzz 可能是 51 或 17。但您的算法只会说它是 51。对于给定的输入，我们知道它不可能是 17，因为输入中有 \'68\' 代替 \'buzz\'。

是的，fizz 和 buzz 可能有更多的可能性，但在我的回答中，我假设输入只有一个有效的 fizz 和 buzz 值

您的代码不适用于替代数据集，因为您假设列表中的第一个数字始终为 1，因此您只需获取列表中的索引并加 1 即可获得数字。但在本例中，它不是 1，而是 50，其中 1. 表示索引不等于数字 -1，而 2. 表示第一个数字会立即触发嘶嘶声。

最简单的解决方案可能是使你使用的相对于索引的偏移量动态化。我不会告诉你如何做到这一点，因为这将为你解决面试问题。

我将从两个假设开始，第一个假设，我想我们都认为理所当然的是“1”不是一个有效答案，第二个假设是应该返回找到的值中的最高值（如果有多个），这个假设基于这样一个事实，即最后一个例子承认“5，3”也是“5，17”和“5，51”是有效答案，那么，鉴于面试官认为“5，51”是正确答案，我认为这是一个很好的假设。

import java.util.ArrayList;
import java.util.List;

public class FizzBuzzMultiplierFinder {

   public static void main( String[] args ) {
      FizzBuzzMultiplierFinder fbmf = new FizzBuzzMultiplierFinder();
      String fizzBuzzOutput[] = { "1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz" };
      fbmf.findFizzBuzzMultipliers( fizzBuzzOutput );
   }

   public void findFizzBuzzMultipliers( String[] fizzBuzzOutput ) {
      int ini = 0;

        // in this step, we identify the numerical value of the first item in the list
      for( int i = 0; i < fizzBuzzOutput.length; i ++ ) {
         if( fizzBuzzOutput[ i ].matches( "[0-9]" ) ) {
            ini = Integer.parseInt( fizzBuzzOutput[ i ] ) - i;
            break;
         }
      }
      System.out.println( getResult( fizzBuzzOutput, ini, "Fizz" ) + " " + getResult( fizzBuzzOutput, ini, "Buzz" ) );
   }

     // this method invokes "subMultiples" which creates a list of lists of submultiples, 
     // and returns the value returned by "getNumber", to which it passes as argument, 
     // the obtained list.
   int getResult( String input5[], int ini, String type ) {
      List<List<Integer>> lis = new ArrayList<>();
      for( int i = 0, k = ini; i < input5.length; i ++, k ++ ) {
         if( input5[ i ].equals( type )
                 || input5[ i ].equals( "FizzBuzz" ) ) {
            lis.add( subMultiples( k ) );
         }
      }
      return getNumber( lis );
   }

     // return a list of submultiples
   List<Integer> subMultiples( int number ) {
      List<Integer> out = new ArrayList<>();
      for( int i = number; i > 1; i -- ) {
         if( number % i == 0 ) {
            out.add( i );
         }
      }
      return out;
   }

     // this method generates the candidates and verifies by calling “isInList”
     // if it is valid, if so, it returns it. 
   int getNumber( List<List<Integer>> lis ) {
      int number;
      for( int i = 0; i < lis.size(); i ++ ) {
         List<Integer> l = lis.get( i );
         for( int k = 0; k < l.size(); k ++ ) {
            number = l.get( k );
            if( isInList( lis, number ) ) {
               return number;
            }
         }
      }
      return -1;
   }

     // return "true" if the number is contained in all lists
   boolean isInList( List<List<Integer>> lis, int number ) {
      for( int i = 0; i < lis.size(); i ++ ) {
         int amount = lis.get( i ).size();
         for( int k = 0; k < lis.get( i ).size(); k ++ ) {
            if( lis.get( i ).get( k ) == number ) {
               break;
            }
            if( k == amount - 1 ) {
               return false;
            }
         }
      }
      return true;
   }    
}