给定数组中唯一比率/分数对的最大计数

给定两个分别表示分子和分母的数组num []和den [] ，任务是查找唯一分数的计数。
例子：

Input: num[] = {1, 2, 3, 4, 5}, den[] = {2, 4, 6, 1, 11} 
Output: 3 
Explanation: 
Simplest forms of the fractions 
Frac[0] => $\frac{1}{2}$

Frac[1] =>$\frac{2}{4} = \frac{1}{2}$

Frac[2] =>$\frac{3}{6} = \frac{1}{2}$

Frac[3] =>$\frac{4}{1}$

Frac[4] =>$\frac{5}{11}$

Count of Unique Fractions => 3
Input: num[] = {10, 20, 30, 50}, den[] = {10, 10, 10, 10} 
Output: 4 
Explanation: 
Simplest forms of the fractions 
Frac[0] =>$\frac{10}{10}$

Frac[1] =>$\frac{20}{10}$

Frac[2] =>$\frac{30}{10}$

Frac[3] =>$\frac{50}{10}$

Count of Unique Fractions => 4

方法：想法是使用哈希映射来找到唯一的分数。为了存储分数，使副本不存在，我们将每个分数转换为其最低形式。

下面是上述方法的实现：

C++

// C++ implementation to find 
// fractions in its lowest form 
  
#include  
  
using namespace std; 
  
// Recursive function to 
// find gcd of a and b 
int gcd(int a, int b) 
{ 
    if (b == 0) 
        return a; 
    return gcd(b, a % b); 
} 
  
// Function to count the unique 
// fractios in the given array 
int countUniqueFractions(int num[], 
                int den[], int N){ 
      
    // Hash-map to store the fractions 
    // in its lowest form 
    map, int> mp; 
      
    // Loop to iterate over the 
    // fractions and store is lowest 
    // form in the hash-map 
    for (int i = 0; i < N; i++) { 
        int numer, denom; 
          
        // To find the Lowest form 
        numer = num[i] / gcd(num[i], den[i]); 
        denom = den[i] / gcd(num[i], den[i]); 
        mp[make_pair(numer, denom)] += 1; 
    } 
      
    return mp.size(); 
} 
  
// Driver code 
int main() 
{ 
    int N = 6; 
      
    // Numerator Array 
    int num[] = { 1, 40, 20, 5, 6, 7 }; 
      
    // Denominator Array 
    int den[] = { 10, 40, 2, 5, 12, 14 }; 
      
    cout << countUniqueFractions(num, den, N); 
      
    return 0; 
}

Java

// Java implementation to find  
// fractions in its lowest form 
import java.lang.*;
import java.util.*;
  
class GFG{
      
static class pair
{
    int x, y;
    pair(int x,int y)
    {
        this.x = x;
        this.y = y;
    }
  
    @Override
    public int hashCode() 
    { 
        return this.x; 
    } 
      
    @Override
    public boolean equals(Object obj) 
    { 
          
        // If both the object references are 
        // referring to the same object. 
        if(this == obj) 
        return true; 
          
        // It checks if the argument is of the 
        // type pair by comparing the classes 
        // of the passed argument and this object. 
        // if(!(obj instanceof pair)) return 
        // false; ---> avoid. 
        if(obj == null || 
           obj.getClass() != 
          this.getClass()) 
            return false; 
          
        // Type casting of the argument. 
        pair geek = (pair) obj; 
          
        // comparing the state of argument with 
        // the state of 'this' Object. 
        return (geek.x == this.x && 
                geek.y == this.y); 
    } 
}
  
// Recursive function to 
// find gcd of a and b
static int gcd(int a, int b)
{
    if (b == 0)
        return a;
          
    return gcd(b, a % b);
}
  
// Function to count the unique
// fractios in the given array
static int countUniqueFractions(int num[], 
                                int den[], int N)
{
      
    // Hash-map to store the fractions
    // in its lowest form
    Map mp = new HashMap<>();
      
    // Loop to iterate over the 
    // fractions and store is lowest
    // form in the hash-map
    for(int i = 0; i < N; i++)
    {
          
        // To find the Lowest form
        int numer = num[i] / gcd(num[i], den[i]);
        int denom = den[i] / gcd(num[i], den[i]);
        pair tmp = new pair(numer, denom);
        mp.put(tmp, 1);
    }
    return mp.size();
}
  
// Driver Code
public static void main (String[] args)
{
    int N = 6;
      
    // Numerator Array
    int num[] = { 1, 40, 20, 5, 6, 7 };
      
    // Denominator Array
    int den[] = { 10, 40, 2, 5, 12, 14 };
      
    System.out.print(countUniqueFractions(num, den, N));
}
}
  
// This code is contributed by offbeat

Python3

# Python3 implementation to find 
# fractions in its lowest form 
from collections import defaultdict 
  
# Recursive function to 
# find gcd of a and b 
def gcd(a, b): 
  
    if (b == 0): 
        return a 
    return gcd(b, a % b) 
  
# Function to count the unique 
# fractios in the given array 
def countUniqueFractions(num, den, N): 
      
    # Hash-map to store the fractions 
    # in its lowest form 
    mp = defaultdict(int) 
      
    # Loop to iterate over the 
    # fractions and store is lowest 
    # form in the hash-map 
    for i in range(N): 
          
        # To find the Lowest form 
        numer = num[i] // gcd(num[i], den[i]) 
        denom = den[i] // gcd(num[i], den[i]) 
        mp[(numer, denom)] += 1
      
    return len(mp) 
  
# Driver code 
if __name__ == "__main__": 
      
    N = 6
      
    # Numerator Array 
    num = [ 1, 40, 20, 5, 6, 7 ] 
      
    # Denominator Array 
    den = [ 10, 40, 2, 5, 12, 14 ] 
      
    print(countUniqueFractions(num, den, N)) 
  
# This code is contributed by chitranayal

输出：

4