Skip to content
Related Articles

Related Articles

Count elements of same value placed at same indices of two given arrays
  • Last Updated : 21 Jan, 2021

Given two arrays A[] and B[] of N unique elements, the task is to find the maximum number of matched elements from the two given arrays. 

Elements from the two arrays are matched if they are of the same value and can be placed at the same index (0-based indexing).(By right shift or left shift of the two arrays).

 Examples:

Input: A[] = { 5, 3, 7, 9, 8 }, B[] = { 8, 7, 3, 5, 9 }
Output: 3
Explanation: Left shifting B[] by 1 index modifes B[] to { 7, 3, 5, 9, 8 }.
Therefore, elements at indices 1, 3 and 4 match. Therefore, the required count is 3.

Input: A[] = { 9, 5, 6, 2 }, B[] = { 6, 2, 9, 5 }
Output: 4



Naive Approach: The simplest approach to solve this problem is to observe that one right shift is the same as (N-1) left shifts, so perform only one type of shift, say right shift. Also performing the right shift on A is the same as performing left shift B, so perform the right shift on only one array, say on A[]. Apply right shift operations on A while keeping B as it is and compare all the values of A and B to find the total number of matches and keep track for the maximum of all. 

Time complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by using a Map to keep track of the difference between indices of equal elements present in arrays A[] and B[]. If the difference comes out to be negative, then change A[] by doing k( = N + difference) left shifts, which is equivalent to N – K right shifts.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count maximum matched
// elements from the arrays A[] and B[]
int maxMatch(int A[], int B[], int M, int N)
{
      
    // Stores position of elements of
    // array A[] in the array B[]
    map<int,int> Aindex;
    
    // Keep track of difference
    // between the indices
    map<int,int> diff;
    
    // Traverse the array A[]
    for(int i = 0; i < M; i++)
    {
        Aindex[A[i]] = i ;
    }
    
    // Traverse the array B[]
    for(int i = 0; i < N; i++)
    {
          
        // If difference is negative, add N to it
        if (i - Aindex[B[i]] < 0)
        {     
            diff[M + i - Aindex[B[i]]] += 1;
        }
       
        // Keep track of the number of shifts
        // required to place elements at same indices
        else
        {
            diff[i - Aindex[B[i]]] += 1;
        }
    }
      
    // Return the max matches
    int max = 0;
    for(auto ele = diff.begin(); ele != diff.end(); ele++)
    {
        if(ele->second > max)
        {
            max = ele->second;
        }
    }
    return max;
}
 
// Driver code
int main()
{
    int A[] = { 5, 3, 7, 9, 8 };
    int B[] = { 8, 7, 3, 5, 9 };  
    int M = sizeof(A) / sizeof(A[0]);
    int N = sizeof(B) / sizeof(B[0]);
     
    // Returns the count 
    // of matched elements
    cout << maxMatch(A, B, M, N);
    return 0;
}
 
// This code is contributed by divyeshrabadiya07

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.io.Console;
import java.util.HashMap;
import java.util.Map;
class GFG
{
 
  // Function to count maximum matched
  // elements from the arrays A[] and B[]
  static int maxMatch(int[] A, int[] B)
  {
 
    // Stores position of elements of
    // array A[] in the array B[]
    HashMap<Integer, Integer> Aindex = new HashMap<Integer, Integer>();
 
    // Keep track of difference
    // between the indices
    HashMap<Integer, Integer> diff = new HashMap<Integer, Integer>();
 
    // Traverse the array A[]
    for (int i = 0; i < A.length; i++)
    {
      Aindex.put(A[i], i);
    }
 
    // Traverse the array B[]
    for (int i = 0; i < B.length; i++)
    {
 
      // If difference is negative, add N to it
      if (i - Aindex.get(B[i]) < 0)
      {
        if (!diff.containsKey(A.length + i - Aindex.get(B[i])))
        {
          diff.put(A.length + i - Aindex.get(B[i]), 1);
        } else {
          diff.put(A.length + i - Aindex.get(B[i]), diff.get(A.length + i - Aindex.get(B[i])) + 1);
        }
      }
 
      // Keep track of the number of shifts
      // required to place elements at same indices
      else {
        if (!diff.containsKey(i - Aindex.get(B[i]))) {
          diff.put(i - Aindex.get(B[i]), 1);
        }
        else
        {
          diff.put(i - Aindex.get(B[i]),
                   diff.get(i - Aindex.get(B[i])) + 1);
        }
      }
    }
 
    // Return the max matches
    int max = 0;
    for (Map.Entry<Integer, Integer> ele : diff.entrySet())
    {
      if (ele.getValue() > max)
      {
        max = ele.getValue();
      }
    }
    return max;
  }
 
  // Driver Code
  public static void main(String[] args)
  {
 
    int[] A = { 5, 3, 7, 9, 8 };
    int[] B = { 8, 7, 3, 5, 9 };
 
    // Returns the count
    // of matched elements
    System.out.println(maxMatch(A, B));
  }
}
 
// This code is contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program for the above approach
 
 
# Function to count maximum matched
# elements from the arrays A[] and B[]
def maxMatch(A, B):
 
    # Stores position of elements of
    # array A[] in the array B[]
    Aindex = {}
 
    # Keep track of difference
    # between the indices
    diff = {}
 
    # Traverse the array A[]
    for i in range(len(A)):
        Aindex[A[i]] = i
 
    # Traverse the array B[]
    for i in range(len(B)):
 
        # If difference is negative, add N to it
        if i-Aindex[B[i]] < 0:
             
            if len(A)+i-Aindex[B[i]] not in diff:
                diff[len(A)+i-Aindex[B[i]]] = 1
                 
            else:
                diff[len(A)+i-Aindex[B[i]]] += 1
 
        # Keep track of the number of shifts
        # required to place elements at same indices
        else:
            if i-Aindex[B[i]] not in diff:
                diff[i-Aindex[B[i]]] = 1
            else:
                diff[i-Aindex[B[i]]] += 1
 
    # Return the max matches
    return max(diff.values())
 
 
# Driver Code
A = [5, 3, 7, 9, 8]
B = [8, 7, 3, 5, 9]
 
# Returns the count
# of matched elements
print(maxMatch(A, B))

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
     
// Function to count maximum matched
// elements from the arrays A[] and B[]
static int maxMatch(int[] A, int[] B)
{
     
    // Stores position of elements of
    // array A[] in the array B[]
    Dictionary<int,
               int> Aindex = new Dictionary<int,
                                            int>(); 
   
    // Keep track of difference
    // between the indices
    Dictionary<int,
               int> diff = new Dictionary<int,
                                          int>(); 
   
    // Traverse the array A[]
    for(int i = 0; i < A.Length; i++)
    {
        Aindex[A[i]] = i ;
    }
   
    // Traverse the array B[]
    for(int i = 0; i < B.Length; i++)
    {
         
        // If difference is negative, add N to it
        if (i - Aindex[B[i]] < 0)
        {     
            if (!diff.ContainsKey(A.Length + i -
                                  Aindex[B[i]]))
            {
                diff[A.Length + i - Aindex[B[i]]] = 1;
            }     
            else
            {
                diff[A.Length + i - Aindex[B[i]]] += 1;
            }
        }
         
        // Keep track of the number of shifts
        // required to place elements at same indices
        else
        {
            if (!diff.ContainsKey(i - Aindex[B[i]]))
            {
                diff[i - Aindex[B[i]]] = 1;
            }
            else
            {
                diff[i - Aindex[B[i]]] += 1;
            }
        }
    }
     
    // Return the max matches
    int max = 0;
    foreach(KeyValuePair<int, int> ele in diff)
    {
        if (ele.Value > max)
        {
            max = ele.Value;
        }
    }
    return max;
}
 
// Driver Code   
static void Main()
{
    int[] A = { 5, 3, 7, 9, 8 };
    int[] B = { 8, 7, 3, 5, 9 };
       
    // Returns the count 
    // of matched elements
    Console.WriteLine(maxMatch(A, B));
}
}
 
// This code is contributed by divyesh072019

chevron_right


Output:

3

Time Complexity: O(N)
Auxiliary Space: O(N)

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 :