Open In App
Related Articles

Minimum Index Sum for Common Elements of Two Lists

Improve Article
Improve
Save Article
Save
Like Article
Like

Ram and Shyam want to choose a website to learn programming and they both have a list of favorite websites represented by strings.
You need to help them find out their common interest with the least index sum. If there is a choice tie between answers, print all of them with no order requirement. Assume there always exists an answer.

Examples:

Input : ["GeeksforGeeks", "Udemy", "Coursera", "edX"]
        ["Codecademy", "Khan Academy", "GeeksforGeeks"]
Output : "GeeksforGeeks"
Explanation : GeeksforGeeks is the only common website 
              in two lists

Input : ["Udemy", "GeeksforGeeks", "Coursera", "edX"]
        ["GeeksforGeeks", "Udemy", "Khan Academy", "Udacity"]
Output : "GeeksforGeeks" "Udemy"
Explanation : There are two common websites and index sum
              of both is same.

Naive Method:

The idea is to try all index sums from 0 to sum of sizes. For every sum, check if there are pairs with given sum. Once we find one or more pairs, we print them and return.

C++




#include <bits/stdc++.h>
using namespace std;
 
// Function to print common strings with minimum index sum
void find(vector<string> list1, vector<string> list2)
{
    vector<string> res; // resultant list
    int max_possible_sum = list1.size() + list2.size() - 2;
 
    // iterating over sum in ascending order
    for (int sum = 0; sum <= max_possible_sum ; sum++)
    {
        // iterating over one list and check index
        // (Corresponding to given sum) in other list
        for (int i = 0; i <= sum; i++)
         
            // put common strings in resultant list 
            if (i < list1.size() &&
                (sum - i) < list2.size() &&
                list1[i] == list2[sum - i])
                res.push_back(list1[i]);        
 
        // if common string found then break as we are
        // considering index sums in increasing order.
        if (res.size() > 0)
            break;
    }
 
    // print the resultant list
    for (int i = 0; i < res.size(); i++)
        cout << res[i] << " ";
}
 
// Driver code
int main()
{
    // Creating list1
    vector<string> list1;
    list1.push_back("GeeksforGeeks");
    list1.push_back("Udemy");
    list1.push_back("Coursera");
    list1.push_back("edX");
 
    // Creating list2
    vector<string> list2;
    list2.push_back("Codecademy");
    list2.push_back("Khan Academy");
    list2.push_back("GeeksforGeeks");
 
    find(list1, list2);
    return 0;
}

Java



import java.util.*;
 
class GFG
{
 
// Function to print common Strings with minimum index sum
static void find(Vector<String> list1, Vector<String> list2)
{
    Vector<String> res = new Vector<>(); // resultant list
    int max_possible_sum = list1.size() + list2.size() - 2;
 
    // iterating over sum in ascending order
    for (int sum = 0; sum <= max_possible_sum ; sum++)
    {
        // iterating over one list and check index
        // (Corresponding to given sum) in other list
        for (int i = 0; i <= sum; i++)
         
            // put common Strings in resultant list
            if (i < list1.size() &&
                (sum - i) < list2.size() &&
                list1.get(i) == list2.get(sum - i))
                res.add(list1.get(i));        
 
        // if common String found then break as we are
        // considering index sums in increasing order.
        if (res.size() > 0)
            break;
    }
 
    // print the resultant list
    for (int i = 0; i < res.size(); i++)
        System.out.print(res.get(i)+" ");
}
 
// Driver code
public static void main(String[] args)
{
    // Creating list1
    Vector<String> list1 = new Vector<>();
    list1.add("GeeksforGeeks");
    list1.add("Udemy");
    list1.add("Coursera");
    list1.add("edX");
 
    // Creating list2
    Vector<String> list2= new Vector<>();
    list2.add("Codecademy");
    list2.add("Khan Academy");
    list2.add("GeeksforGeeks");
 
    find(list1, list2);
 
}
}
 
// This code contributed by Rajput-Ji
Python3



# Function to print common strings
# with minimum index sum
def find(list1, list2):
    res = [] # resultant list
    max_possible_sum = len(list1) + len(list2) - 2
 
    # iterating over sum in ascending order
    for sum in range(max_possible_sum + 1):
         
        # iterating over one list and check index
        # (Corresponding to given sum) in other list
        for i in range(sum + 1):
 
            # put common strings in resultant list
            if (i < len(list1) and
               (sum - i) < len(list2) and
                list1[i] == list2[sum - i]):
                res.append(list1[i])
 
        # if common string found then break as we are
        # considering index sums in increasing order.
        if (len(res) > 0):
            break
 
    # print the resultant list
    for i in range(len(res)):
        print(res[i], end = " ")
 
# Driver code
 
# Creating list1
list1 = []
list1.append("GeeksforGeeks")
list1.append("Udemy")
list1.append("Coursera")
list1.append("edX")
 
# Creating list2
list2 = []
list2.append("Codecademy")
list2.append("Khan Academy")
list2.append("GeeksforGeeks")
 
find(list1, list2)
 
# This code is contributed by Mohit Kumar
C#



using System;
using System.Collections.Generic;
 
class GFG
{
 
// Function to print common Strings with minimum index sum
static void find(List<String> list1, List<String> list2)
{
    List<String> res = new List<String>(); // resultant list
    int max_possible_sum = list1.Count + list2.Count - 2;
 
    // iterating over sum in ascending order
    for (int sum = 0; sum <= max_possible_sum ; sum++)
    {
        // iterating over one list and check index
        // (Corresponding to given sum) in other list
        for (int i = 0; i <= sum; i++)
         
            // put common Strings in resultant list
            if (i < list1.Count &&
                (sum - i) < list2.Count &&
                list1[i] == list2[sum - i])
                res.Add(list1[i]);
 
        // if common String found then break as we are
        // considering index sums in increasing order.
        if (res.Count > 0)
            break;
    }
 
    // print the resultant list
    for (int i = 0; i < res.Count; i++)
        Console.Write(res[i]+" ");
}
 
// Driver code
public static void Main(String[] args)
{
    // Creating list1
    List<String> list1 = new List<String>();
    list1.Add("GeeksforGeeks");
    list1.Add("Udemy");
    list1.Add("Coursera");
    list1.Add("edX");
 
    // Creating list2
    List<String> list2= new List<String>();
    list2.Add("Codecademy");
    list2.Add("Khan Academy");
    list2.Add("GeeksforGeeks");
 
    find(list1, list2);
 
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
    // Function to print common Strings with minimum index sum
    function find(list1, list2)
    {
        let res = []; // resultant list
        let max_possible_sum = list1.length + list2.length - 2;
 
        // iterating over sum in ascending order
        for (let sum = 0; sum <= max_possible_sum ; sum++)
        {
            // iterating over one list and check index
            // (Corresponding to given sum) in other list
            for (let i = 0; i <= sum; i++)
 
                // put common Strings in resultant list
                if (i < list1.length &&
                    (sum - i) < list2.length &&
                    list1[i] == list2[sum - i])
                    res.push(list1[i]);
 
            // if common String found then break as we are
            // considering index sums in increasing order.
            if (res.length > 0)
                break;
        }
 
        // print the resultant list
        for (let i = 0; i < res.length; i++)
            document.write(res[i]+" ");
    }
     
    // Creating list1
    let list1 = [];
    list1.push("GeeksforGeeks");
    list1.push("Udemy");
    list1.push("Coursera");
    list1.push("edX");
  
    // Creating list2
    let list2= [];
    list2.push("Codecademy");
    list2.push("Khan Academy");
    list2.push("GeeksforGeeks");
  
    find(list1, list2);
 
// This code is contributed by mukesh07.
</script>
Output: 
GeeksforGeeks
Time Complexity : O((l1+l2)2 *x), where l1 and l2 are the lengths of list1 and list2 respectively and x refers to string length.
Auxiliary Space : O(l*x), where x refers to length of resultant list and l is length of maximum size word.
 
Using Hash:
  1. Traverse over the list1 and create an entry for index each element of list1 in a Hash Table.
  2. Traverse over list2 and for every element, check if the same element already exists as a key in the map. If so, it means that the element exists in both the lists.
  3. Find out the sum of indices corresponding to common element in the two lists. If this sum is lesser than the minimum sum obtained till now, update the resultant list.
  4. If the sum is equal to the minimum sum obtained till now, put an extra entry corresponding to the element in list2 in the resultant list.
C++



// Hashing based C++ program to find common elements
// with minimum index sum.
#include <bits/stdc++.h>
using namespace std;
 
// Function to print common strings with minimum index sum
void find(vector<string> list1, vector<string> list2)
{
    // mapping strings to their indices
    unordered_map<string, int> map;
    for (int i = 0; i < list1.size(); i++)
        map[list1[i]] = i;
 
    vector<string> res; // resultant list
 
    int minsum = INT_MAX;
    for (int j = 0; j < list2.size(); j++)
    {
        if (map.count(list2[j]))
        {
            // If current sum is smaller than minsum
            int sum = j + map[list2[j]];
            if (sum < minsum)
            {
                minsum = sum;
                res.clear();
                res.push_back(list2[j]);
            }
 
            // if index sum is same then put this
            // string in resultant list as well 
            else if (sum == minsum)
                res.push_back(list2[j]);
        }
    }
 
    // Print result
    for (int i = 0; i < res.size(); i++)
        cout << res[i] << " ";
}
 
// Driver code
int main()
{
    // Creating list1
    vector<string> list1;
    list1.push_back("GeeksforGeeks");
    list1.push_back("Udemy");
    list1.push_back("Coursera");
    list1.push_back("edX");
 
    // Creating list2
    vector<string> list2;
    list2.push_back("Codecademy");
    list2.push_back("Khan Academy");
    list2.push_back("GeeksforGeeks");
 
    find(list1, list2);
    return 0;
}
Java



// Hashing based Java program to find common elements
// with minimum index sum.
import java.util.*;
 
class GFG
{
 
    // Function to print common Strings with minimum index sum
    static void find(Vector<String> list1, Vector<String> list2)
    {
        // mapping Strings to their indices
        Map<String, Integer> map = new HashMap<>();
        for (int i = 0; i < list1.size(); i++)
            map.put(list1.get(i), i);
 
        Vector<String> res = new Vector<String>(); // resultant list
 
        int minsum = Integer.MAX_VALUE;
        for (int j = 0; j < list2.size(); j++)
        {
            if (map.containsKey(list2.get(j)))
            {
                // If current sum is smaller than minsum
                int sum = j + map.get(list2.get(j));
                if (sum < minsum)
                {
                    minsum = sum;
                    res.clear();
                    res.add(list2.get(j));
                }
 
                // if index sum is same then put this
                // String in resultant list as well
                else if (sum == minsum)
                    res.add(list2.get(j));
            }
        }
 
        // Print result
        for (int i = 0; i < res.size(); i++)
            System.out.print(res.get(i) + " ");
    }
 
    // Driver code
    public static void main(String[] args)
    {
        // Creating list1
        Vector<String> list1 = new Vector<String>();
        list1.add("GeeksforGeeks");
        list1.add("Udemy");
        list1.add("Coursera");
        list1.add("edX");
 
        // Creating list2
        Vector<String> list2 = new Vector<String>();
        list2.add("Codecademy");
        list2.add("Khan Academy");
        list2.add("GeeksforGeeks");
 
        find(list1, list2);
    }
}
 
// This code is contributed by PrinciRaj1992
Python3



# Hashing based Python3 program to find
# common elements with minimum index sum
import sys
 
# Function to print common strings
# with minimum index sum
def find(list1, list2):
     
    # Mapping strings to their indices
    Map = {}
    for i in range(len(list1)):
        Map[list1[i]] = i
         
    # Resultant list
    res = []
     
    minsum = sys.maxsize
     
    for j in range(len(list2)):
        if list2[j] in Map:
             
            # If current sum is smaller
            # than minsum
            Sum = j + Map[list2[j]]
             
            if (Sum < minsum):
                minsum = Sum
                res.clear()
                res.append(list2[j])
  
            # If index sum is same then put this 
            # string in resultant list as well  
            else if (Sum == minsum):
                res.append(list2[j])
  
    # Print result
    print(*res, sep = " ")
  
# Driver code
  
# Creating list1
list1 = []
list1.append("GeeksforGeeks")
list1.append("Udemy")
list1.append("Coursera")
list1.append("edX")
  
# Creating list2
list2 = []
list2.append("Codecademy")
list2.append("Khan Academy")
list2.append("GeeksforGeeks")
find(list1, list2)
  
# This code is contributed by avanitrachhadiya2155
C#



// Hashing based C# program to find common elements
// with minimum index sum.
using System;
using System.Collections.Generic;
 
class GFG
{
 
    // Function to print common Strings with minimum index sum
    static void find(List<String> list1, List<String> list2)
    {
        // mapping Strings to their indices
        Dictionary<String, int> map = new Dictionary<String, int>();
        for (int i = 0; i < list1.Count; i++)
            map.Add(list1[i], i);
 
        List<String> res = new List<String>(); // resultant list
 
        int minsum = int.MaxValue;
        for (int j = 0; j < list2.Count; j++)
        {
            if (map.ContainsKey(list2[j]))
            {
                // If current sum is smaller than minsum
                int sum = j + map[list2[j]];
                if (sum < minsum)
                {
                    minsum = sum;
                    res.Clear();
                    res.Add(list2[j]);
                }
 
                // if index sum is same then put this
                // String in resultant list as well
                else if (sum == minsum)
                    res.Add(list2[j]);
            }
        }
 
        // Print result
        for (int i = 0; i < res.Count; i++)
            Console.Write(res[i] + " ");
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        // Creating list1
        List<String> list1 = new List<String>();
        list1.Add("GeeksforGeeks");
        list1.Add("Udemy");
        list1.Add("Coursera");
        list1.Add("edX");
 
        // Creating list2
        List<String> list2 = new List<String>();
        list2.Add("Codecademy");
        list2.Add("Khan Academy");
        list2.Add("GeeksforGeeks");
 
        find(list1, list2);
    }
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// Hashing based Javascript program to
// find common elements with minimum
// index sum.
 
// Function to print common Strings
// with minimum index sum
function find(list1, list2)
{
     
    // Mapping Strings to their indices
    let map = new Map();
    for(let i = 0; i < list1.length; i++)
        map.set(list1[i], i);
         
    // Resultant list
    let res = [];
 
    let minsum = Number.MAX_VALUE;
    for(let j = 0; j < list2.length; j++)
    {
        if (map.has(list2[j]))
        {
             
            // If current sum is smaller than minsum
            let sum = j + map.get(list2[j]);
            if (sum < minsum)
            {
                minsum = sum;
                res = [];
                res.push(list2[j]);
            }
 
            // If index sum is same then put this
            // String in resultant list as well
            else if (sum == minsum)
                res.push(list2[j]);
        }
    }
 
    // Print result
    for(let i = 0; i < res.length; i++)
        document.write(res[i] + " ");
}
 
// Driver code
 
// Creating list1
let list1 = [];
list1.push("GeeksforGeeks");
list1.push("Udemy");
list1.push("Coursera");
list1.push("edX");
 
// Creating list2
let list2 = [];
list2.push("Codecademy");
list2.push("Khan Academy");
list2.push("GeeksforGeeks");
 
find(list1, list2);
 
// This code is contributed by rameshtravel07
 
</script>
Output: 
GeeksforGeeks
Time Complexity : O(l1+l2), where l1 and l2 are the lengths of list1 and list2 respectively.
Auxiliary Space : O(l1*x), where x refers to length of resultant list and l is length of maximum size word.
This article is contributed by Aakash Pal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

Last Updated :
14 Mar, 2022
Like Article

Save Article

Similar Reads
Similar read thumbnail
Minimum index i such that all the elements from index i to given index are equal
Similar read thumbnail
Construct a Maximum Sum Linked List out of two Sorted Linked Lists having some Common nodes
Similar read thumbnail
Number of triangles formed by joining vertices of n-sided polygon with two common sides and no common sides
Similar read thumbnail
First common element in two linked lists
Similar read thumbnail
Counting common prefix/suffix strings in two lists
Similar read thumbnail
Longest common suffix of two linked lists
Similar read thumbnail
Find count of common nodes in two Doubly Linked Lists
Similar read thumbnail
Remove the common nodes in two Singly Linked Lists
Similar read thumbnail
Minimum count of indices to be skipped for every index of Array to keep sum till that index at most T
Similar read thumbnail
Python program to find common elements in three lists using sets
Related Tutorials
Similar read thumbnail
Mathematical and Geometric Algorithms - Data Structure and Algorithm Tutorials
Similar read thumbnail
Learn Data Structures with Javascript | DSA Tutorial
Similar read thumbnail
Introduction to Max-Heap – Data Structure and Algorithm Tutorials
Similar read thumbnail
Introduction to Set – Data Structure and Algorithm Tutorials
Similar read thumbnail
Introduction to Map – Data Structure and Algorithm Tutorials
Previous
GE Interview Experience | Set 5 (On-Campus for GE Digital)
Next

Merging two unsorted arrays in sorted order
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue 
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox