Given two arrays **arr1[]** and **arr2[]**, player **A** picks an element from **arr1[]** and player **B** picks an element from **arr2[]**, the player which has the element with more number of divisors wins the round. If both have elements with same number of divisors then player **A** wins that round. The task is to find whether player **A** has more probability of winning the game or the player **B**.

**Examples:**

Input:arr1[] = {4, 12, 24}, arr2[] = {25, 28, 13, 45}Output:A

Pairs where A wins are (3, 2), (3, 3), (6, 2), (6, 3), (6, 6), (6, 6), (8, 2), (8, 3), (8, 6) and (8, 6).

Total = 10.

B wins in 2 cases.

Hence, A has more probability of winning the game.

Input:arr1[] = {7, 3, 4}, arr2[] = {5, 4, 12, 10}Output:B

**Approach:**

- For both the arrays, in place of elements, store the number of divisors of elements.
- Sort both the arrays in increasing order.
- Find all the possible pair selection
**(X, Y)**in which**A**wins the game. - Suppose,
**A**chooses an element from**arr1[]**. Now binary search can be used to find the number of elements in**arr2[]**which has the divisor count less than the chosen element in**arr1[]**. This will be added to the count of pairs where**A**wins. Do this for every element of**arr1[]**. -
**N * M**is the total pairs possible. Number of pairs where**A**wins is say**X**and the number of pairs where**B**wins is say**Y**.- If
**X > Y**then**A**has more probability of winning the game. - If
**Y > X**then**B**has more probability of winning. - If
**X = Y**then the probability of draw is more.

- If

Below is the implementation of the above approach:

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; `
` ` `#define ll long long int ` ` ` `// Function to return the count ` `// of divisors of elem ` `int` `divisorcount(` `int` `elem) `
`{ ` ` ` `int` `ans = 0; `
` ` `for` `(` `int` `i = 1; i <= ` `sqrt` `(elem); i++) { `
` ` `if` `(elem % i == 0) { `
` ` `if` `(i * i == elem) `
` ` `ans++; `
` ` `else`
` ` `ans += 2; `
` ` `} `
` ` `} `
` ` ` ` `return` `ans; `
`} ` ` ` `// Function to return the winner of the game ` `string findwinner(` `int` `A[], ` `int` `B[], ` `int` `N, ` `int` `M) `
`{ ` ` ` `// Convert every element of A[] `
` ` `// to their divisor count `
` ` `for` `(` `int` `i = 0; i < N; i++) { `
` ` `A[i] = divisorcount(A[i]); `
` ` `} `
` ` ` ` `// Convert every element of B[] `
` ` `// to their divisor count `
` ` `for` `(` `int` `i = 0; i < M; i++) { `
` ` `B[i] = divisorcount(B[i]); `
` ` `} `
` ` ` ` `// Sort both the arrays `
` ` `sort(A, A + N); `
` ` `sort(B, B + M); `
` ` ` ` `int` `winA = 0; `
` ` `for` `(` `int` `i = 0; i < N; i++) { `
` ` `int` `val = A[i]; `
` ` `int` `start = 0; `
` ` `int` `end = M - 1; `
` ` `int` `index = -1; `
` ` ` ` `// For every element of A apply Binary Search `
` ` `// to find number of pairs where A wins `
` ` `while` `(start <= end) { `
` ` `int` `mid = (start + end) / 2; `
` ` `if` `(B[mid] <= val) { `
` ` `index = mid; `
` ` `start = mid + 1; `
` ` `} `
` ` `else` `{ `
` ` `end = mid - 1; `
` ` `} `
` ` `} `
` ` ` ` `winA += (index + 1); `
` ` `} `
` ` ` ` `// B wins if A doesnot win `
` ` `int` `winB = N * M - winA; `
` ` ` ` `if` `(winA > winB) { `
` ` `return` `"A"` `; `
` ` `} `
` ` `else` `if` `(winB > winA) { `
` ` `return` `"B"` `; `
` ` `} `
` ` ` ` `return` `"Draw"` `; `
`} ` ` ` `// Driver code ` `int` `main() `
`{ ` ` ` `int` `A[] = { 4, 12, 24 }; `
` ` `int` `N = ` `sizeof` `(A) / ` `sizeof` `(A[0]); `
` ` ` ` `int` `B[] = { 25, 28, 13, 45 }; `
` ` `int` `M = ` `sizeof` `(B) / ` `sizeof` `(B[0]); `
` ` ` ` `cout << findwinner(A, B, N, M); `
` ` ` ` `return` `0; `
`} ` |

*chevron_right*

*filter_none*

`# Python3 implementation of the approach ` `from` `math ` `import` `*`
` ` `# Function to return the count ` `# of divisors of elem ` `def` `divisorcount(elem): `
` ` ` ` `ans ` `=` `0`
` ` `for` `i ` `in` `range` `(` `1` `, ` `int` `(sqrt(elem)) ` `+` `1` `): `
` ` `if` `(elem ` `%` `i ` `=` `=` `0` `): `
` ` `if` `(i ` `*` `i ` `=` `=` `elem): `
` ` `ans ` `+` `=` `1`
` ` `else` `: `
` ` `ans ` `+` `=` `2`
` ` ` ` `return` `ans `
` ` `# Function to return the winner of the game ` `def` `findwinner(A, B, N, M): `
` ` ` ` `# Convert every element of A[] `
` ` `# to their divisor count `
` ` `for` `i ` `in` `range` `(N): `
` ` `A[i] ` `=` `divisorcount(A[i]) `
` ` ` ` `# Convert every element of B[] `
` ` `# to their divisor count `
` ` `for` `i ` `in` `range` `(M): `
` ` `B[i] ` `=` `divisorcount(B[i]) `
` ` ` ` `# Sort both the arrays `
` ` `A.sort() `
` ` `B.sort() `
` ` ` ` `winA ` `=` `0`
` ` `for` `i ` `in` `range` `(N): `
` ` `val ` `=` `A[i] `
` ` `start ` `=` `0`
` ` `end ` `=` `M ` `-` `1`
` ` `index ` `=` `-` `1`
` ` ` ` `# For every element of A[] apply `
` ` `# binary search to find number `
` ` `# of pairs where A wins `
` ` `while` `(start <` `=` `end): `
` ` `mid ` `=` `(start ` `+` `end) ` `/` `/` `2`
` ` ` ` `if` `(B[mid] <` `=` `val): `
` ` `index ` `=` `mid `
` ` `start ` `=` `mid ` `+` `1`
` ` ` ` `else` `: `
` ` `end ` `=` `mid ` `-` `1`
` ` ` ` `winA ` `+` `=` `(index ` `+` `1` `) `
` ` ` ` `# B wins if A doesnot win `
` ` `winB ` `=` `N ` `*` `M ` `-` `winA `
` ` ` ` `if` `(winA > winB): `
` ` `return` `"A"`
` ` `elif` `(winB > winA): `
` ` `return` `"B"`
` ` ` ` `return` `"Draw"`
` ` `# Driver code ` `if` `__name__ ` `=` `=` `'__main__'` `: `
` ` ` ` `A ` `=` `[ ` `4` `, ` `12` `, ` `24` `] `
` ` `N ` `=` `len` `(A) `
` ` ` ` `B ` `=` `[ ` `25` `, ` `28` `, ` `13` `, ` `45` `] `
` ` `M ` `=` `len` `(B) `
` ` ` ` `print` `(findwinner(A, B, N, M)) `
` ` `# This code is contributed by himanshu77 ` |

*chevron_right*

*filter_none*

**Output:**

A

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Game Theory (Normal form game) | Set 2 (Game with Pure Strategy)
- Game Theory (Normal-form game) | Set 3 (Game with Mixed Strategy)
- Game Theory (Normal-form Game) | Set 6 (Graphical Method [2 X N] Game)
- Game Theory (Normal-form Game) | Set 7 (Graphical Method [M X 2] Game)
- Find the winner of the Game
- Predict the winner of the game on the basis of absolute difference of sum by selecting numbers
- Determine winner of the Game by arranging balls in a row
- Determine the winner of a game of deleting Characters from a String
- Find sum of divisors of all the divisors of a natural number
- Find sum of inverse of the divisors when sum of divisors and the number is given
- Check if a number has an odd count of odd divisors and even count of even divisors
- Divisors of n-square that are not divisors of n
- Maximum possible prime divisors that can exist in numbers having exactly N divisors
- Check if count of even divisors of N is equal to count of odd divisors
- Combinatorial Game Theory | Set 2 (Game of Nim)
- Game Theory (Normal-form Game) | Set 4 (Dominance Property-Pure Strategy)
- Game Theory (Normal-form Game) | Set 5 (Dominance Property-Mixed Strategy)
- Find the winner by adding Pairwise difference of elements in the array until Possible
- Find the winner of the match | Multiple Queries
- Find the largest good number in the divisors of given number N

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.