Skip to content
Related Articles

Related Articles

Improve Article
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 <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;
}

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




<script>
 
// JavaScript implementation of the
// above approach
 
// Function to return the count
// of divisors of elem
function divisorcount(elem)
{
    let ans = 0;
  for (let 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
function findwinner(A,B,N,M)
{
    // Convert every element of A[]
  // to their divisor count
  for (let i = 0; i < N; i++)
  {
    A[i] = divisorcount(A[i]);
  }
  
  // Convert every element of B[]
  // to their divisor count
  for (let i = 0; i < M; i++)
  {
    B[i] = divisorcount(B[i]);
  }
  
  // Sort both the arrays
  A.sort(function(a,b){return a-b;});
  B.sort(function(a,b){return a-b;});
  
  let winA = 0;
  for (let i = 0; i < N; i++)
  {
    let val = A[i];
    let start = 0;
    let end = M - 1;
    let index = -1;
  
    // For every element of A
    // apply Binary Search to
    // find number of pairs
    // where A wins
    while (start <= end)
    {
      let mid = Math.floor((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
  let winB = N * M - winA;
  
  if (winA > winB)
  {
    return "A";
  }
  else if (winB > winA)
  {
    return "B";
  }
  
  return "Draw";
}
 
// Driver code
 
let A=[4, 12, 24];
let N = A.length;
 
let B=[25, 28, 13, 45];
let M = B.length;
document.write(findwinner(A, B, N, M));
 
 
// This code is contributed by rag2127
 
</script>
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
Recommended Articles
Page :