Related Articles

Related Articles

Find the winner of the game based on greater number of divisors
  • Last Updated : 06 Nov, 2020

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

Below is the implementation of the above approach: 
 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

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


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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


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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :