Minimum Index Sum of Two Lists - Practice Coding Problems

Minimum Index Sum of Two Lists - Problem

Imagine you're a restaurant enthusiast who maintains two favorite restaurant lists, and you want to find the best compromise when dining with a friend! 🍽️

Given two arrays of strings list1 and list2, find the common restaurants that have the minimum index sum. A common restaurant appears in both lists, and we want to minimize the total "effort" (sum of positions) to find it in both lists.

Goal: Return all common strings where the sum of their indices i + j is minimized across both arrays.

Example: If "Pizza Hut" appears at index 1 in list1 and index 2 in list2, its index sum is 3. We want all restaurants with the smallest possible index sum!

Input & Output

example_1.py — Basic Case

$ Input: list1 = ["Shogun", "Tapioca Express", "Burger King", "KFC"] list2 = ["Piatti", "The Grill at Torrey Pines", "Hungry Hunter Steakhouse", "Shogun"]

› Output: ["Shogun"]

💡 Note: "Shogun" is the only common restaurant. It appears at index 0 in list1 and index 3 in list2, giving an index sum of 0 + 3 = 3. This is the minimum (and only) sum.

example_2.py — Multiple Matches

$ Input: list1 = ["Shogun", "Tapioca Express", "Burger King", "KFC"] list2 = ["KFC", "Shogun", "Burger King"]

› Output: ["Shogun"]

💡 Note: Common restaurants: "Shogun" (0+1=1), "Burger King" (2+2=4), "KFC" (3+0=3). "Shogun" has the minimum index sum of 1.

example_3.py — Tie Case

$ Input: list1 = ["happy", "sad", "good"] list2 = ["sad", "happy", "good"]

› Output: ["sad", "happy"]

💡 Note: Common restaurants: "happy" (0+1=1), "sad" (1+0=1), "good" (2+2=4). Both "sad" and "happy" have the minimum index sum of 1.

Constraints

1 ≤ list1.length, list2.length ≤ 1000
1 ≤ list1[i].length, list2[i].length ≤ 30
list1[i] and list2[i] consist of spaces and English letters
All strings in list1 are unique
All strings in list2 are unique

Visualization

Tap to expand

Understanding the Visualization

Create Lookup

Build a quick-reference map of your restaurant preferences with their priority rankings

Check Friend's List

Go through your friend's list and check if each restaurant is also in your preferences

Calculate Compromise

For each mutual restaurant, calculate the 'compromise score' (sum of both rankings)

Find Best Options

Collect all restaurants with the lowest compromise score - these are your best dining options!

Key Takeaway

🎯 Key Insight: Use a hash table to instantly check if restaurants appear in both lists, then track the minimum index sum to find the best compromise options!

Asked in

A Amazon 15 G Google 8 ⊞ Microsoft 6 Apple 4

The optimal solution uses a hash table to store restaurants from the first list with their indices, then iterates through the second list to find common restaurants. This achieves O(n + m) time complexity with O(n) space complexity. The key insight is to track the minimum index sum as we go, collecting all restaurants that achieve this minimum rather than storing all possibilities.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n + m)	O(n)	Build hash map while searching - optimal single pass solution
Brute Force (Nested Loops)	O(n × m × k)	O(1)	Compare every string in list1 with every string in list2
Two-Pass Hash Table	O(n + m)	O(n)	Build hash map of list1, then iterate through list2 to find matches

One-Pass Hash Table (Optimal) — Algorithm Steps

Create hash map to store restaurants from list1 with their indices
Iterate through list1 to populate the hash map
Iterate through list2 and check for matches immediately
Track minimum index sum and collect results in single pass
Early termination possible when sum exceeds current minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Map

Create lookup table from list1 with indices

Process list2

For each element, immediately check hash map and update results

Track Minimum

Maintain minimum sum and collect all restaurants achieving it

Early Exit

Stop when no better solution is possible

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#define HASH_SIZE 1000

typedef struct HashNode {
    char* key;
    int value;
    struct HashNode* next;
} HashNode;

int hash(const char* str) {
    unsigned long h = 5381;
    int c;
    while ((c = *str++)) {
        h = ((h << 5) + h) + c;
    }
    return h % HASH_SIZE;
}

void put(HashNode* table[], char* key, int value) {
    int idx = hash(key);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    node->key = key;
    node->value = value;
    node->next = table[idx];
    table[idx] = node;
}

int get(HashNode* table[], char* key) {
    int idx = hash(key);
    HashNode* node = table[idx];
    while (node) {
        if (strcmp(node->key, key) == 0) return node->value;
        node = node->next;
    }
    return -1;
}

char** findRestaurant(char** list1, int list1Size, char** list2, int list2Size, int* returnSize) {
    // Build hash table from list1
    HashNode* table[HASH_SIZE] = {NULL};
    for (int i = 0; i < list1Size; i++) {
        put(table, list1[i], i);
    }
    
    char** result = (char**)malloc(1000 * sizeof(char*));
    int minSum = INT_MAX;
    *returnSize = 0;
    
    // Single pass through list2
    for (int j = 0; j < list2Size; j++) {
        int i = get(table, list2[j]);
        if (i != -1) {
            int indexSum = i + j;
            if (indexSum < minSum) {
                minSum = indexSum;
                *returnSize = 1;
                result[0] = list2[j];
            } else if (indexSum == minSum) {
                result[*returnSize] = list2[j];
                (*returnSize)++;
            }
        }
        // Early termination optimization
        if (j > minSum) break;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Visit each element in both arrays exactly once

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n elements from list1

⚡ Linearithmic Space

42.5K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler