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 the 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 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. The 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++

`// 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*

## Java

`// Java implementation of the ` `// above approach` `import` `java.util.*;` `class` `GFG{` `// Function to return the count` `// of divisors of elem` `static` `int` `divisorcount(` `int` `elem)` `{` ` ` `int` `ans = ` `0` `;` ` ` `for` `(` `int` `i = ` `1` `; ` ` ` `i <= Math.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` `static` `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` ` ` `Arrays.sort(A);` ` ` `Arrays.sort(B);` ` ` `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` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `A[] = {` `4` `, ` `12` `, ` `24` `};` ` ` `int` `N = A.length;` ` ` `int` `B[] = {` `25` `, ` `28` `, ` `13` `, ` `45` `};` ` ` `int` `M = B.length;` ` ` `System.out.print(findwinner(A, B, N, M));` `}` `}` `// This code is contributed by Chitranayal` |

*chevron_right*

*filter_none*

## Python3

`# 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.