当玩家每回合从数组中移除多个 A 或 B 时，找到获胜者

给定一个大小为N的数组arr ，并且假设Alice和Bob正在玩游戏，Alice 有一个数字A而 Bob 有一个数字B 。他们都从Alice开始交替轮流。在每一轮中，当前玩家必须从数组中移除一个非零数量的元素，并且每个移除的元素应该是给该玩家的数量的倍数。如果无法移除任何元素，则当前玩家输掉游戏。找出哪个玩家赢得了比赛。

例子：

Input: N = 5, A = 3, B = 2, arr[] = {-1, 2, 3, 4, 5}
Output: Bob
Explanation: Alice first removes 3 then the sequence becomes [1, 2, 4, 5].
Bob removes 4 then the sequence becomes [1, 2, 5].
Now Alice cannot remove any number because sequence does not have any multiple of A.

Input: N = 6, A = 2, B = 3, arr[] = {2, 4, 6, 3, 9, 12}
Output: Alice
Explanation: Alice first removes 6 and 12 then array becomes [2, 4, 3, 9].
Now Bob removes 3. Then ALice removes 2. arr[] becomes [4, 9].
Again Bob removes 9 and Alice removes 4.
Then there is no element left. So Alice wins.

编程需要懂一点英语

天真的方法：开始搜索数组中的元素，该元素是玩家（Alice，Bob）给定数字的倍数。如果找到元素，则从给定数组中删除这些元素。如果找不到该号码，则该玩家将输。

时间复杂度： O(N ² )
辅助空间： O(1)

高效的方法：可以基于以下思路解决问题：

Count the number of multiples of only A and only B present in array arr[] also the elements divisible by both A and B.
The elements having both A and B as their factor can be removed in one turn by Alice. So consider those as a single unit to be removed in one turn by Alice.
Now if the total number of elements present for Alice is greater then she wins, else Bob is the winner.

编程需要懂一点英语

请按照以下步骤操作：

将给定数字的倍数计算给数组arr 中的玩家。比如， onlyA代表Alice ， onlyB代表Bob ， bothAB代表 A 和 B 的倍数。
遍历数组arr
- 检查arr[i]是否是 A 和 B 的倍数。
  - 如果为真，则增加bothAB的计数。
- 检查 arr[i] 是否仅是A的倍数。
  - 如果为真，则增加onlyA的计数。
- 检查 arr[i] 是否仅是B的倍数。
  - 如果为真，则增加onlyB的计数。
如果bothAB大于0 ，则将其包含为 Alice 可以删除的单个单元。
因此，最终检查爱丽丝是否可以移除比鲍勃更多的东西，那么爱丽丝赢了，否则鲍勃。

下面是上述方法的实现。

Java

// java code to implement the approach
  
class GFG {
  
    // Function to find the winner
    public static String winner(int[] arr,
                                int a, int b)
    {
        int onlyA = 0, onlyB = 0, bothAB = 0;
        int n = arr.length;
  
        // Loop to find the count of multiples
        for (int i = 0; i < n; i++) {
            if (arr[i] % a == 0
                && arr[i] % b == 0) {
                bothAB++;
            }
            else if (arr[i] % a == 0) {
                onlyA++;
            }
            else if (arr[i] % b == 0) {
                onlyB++;
            }
        }
  
        if (onlyA + (bothAB > 0 ? 1 : 0)
            > onlyB) {
            return "Alice";
        }
        else {
            return "Bob";
        }
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int N = 6;
        int arr[] = { 2, 4, 6, 3, 9, 12 };
        int A = 2, B = 3;
  
        // Function call
        System.out.println(winner(arr, A, B));
    }
}

输出

Bob

时间复杂度： 在）
辅助空间： O(1