Skip to content
Related Articles
Find the winner of the game based on greater number of divisors
• Last Updated : 01 Jun, 2021

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:
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:

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 said X and the number of pairs where B wins is said 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.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``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);` `    ``int` `B[] = { 25, 28, 13, 45 };``    ``int` `M = ``sizeof``(B) / ``sizeof``(B);` `    ``cout << findwinner(A, B, N, M);` `    ``return` `0;``}`

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

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

## C#

 `// C# implementation of the approach``using` `System;` `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``    ``Array.Sort(A);``    ``Array.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()``{``    ``int``[] A = { 4, 12, 24 };``    ``int` `N = A.Length;` `    ``int``[] B = { 25, 28, 13, 45 };``    ``int` `M = B.Length;` `    ``Console.Write(findwinner(A, B, N, M));``}``}` `// This code is contributed by rishavmahato348`

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up