Skip to content
Related Articles

Related Articles

Find the winner of the game based on greater number of divisors

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 23 Jun, 2022

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

 

Time Complexity: O(n*log(n)+m*log(m)+n*log(m)+n*√a+m*√b) where n and m are size of array and a and b are maximum elements in both arrays respectively.
Auxiliary Space: O(1)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!