Find the Length of the Longest Common Prefix

Find the Length of the Longest Common Prefix - Problem

You are given two arrays arr1 and arr2 containing positive integers. Your task is to find the longest common prefix between any pair of numbers from these arrays.

A prefix of a positive integer is formed by taking one or more of its digits starting from the leftmost digit. For example:

123 is a prefix of 12345 ✅
234 is not a prefix of 12345 ❌ (doesn't start from leftmost)

A common prefix exists between two numbers when they share the same starting digits. For example:

5655359 and 56554 have common prefixes: 5, 56, 565, 5655
1223 and 43456 have no common prefix

Goal: Find the length of the longest common prefix among all possible pairs (x, y) where x ∈ arr1 and y ∈ arr2.

Input & Output

example_1.py — Basic Case

$ Input: arr1 = [1, 10, 100], arr2 = [1000]

› Output: 3

💡 Note: The longest common prefix is between 100 and 1000. They share the prefix "100" which has length 3.

example_2.py — Multiple Matches

$ Input: arr1 = [1, 2, 3], arr2 = [4, 4, 4]

› Output: 0

💡 Note: There are no common prefixes between any pairs, so the answer is 0.

example_3.py — Complex Case

$ Input: arr1 = [12345, 6789], arr2 = [123, 12, 1234567]

› Output: 4

💡 Note: The longest common prefix is between 12345 and 1234567, sharing "1234" with length 4.

Constraints

1 ≤ arr1.length, arr2.length ≤ 5 × 10⁴
1 ≤ arr1[i], arr2[i] ≤ 10⁸
All numbers are positive integers

Visualization

Tap to expand

Understanding the Visualization

Create Directory Tree

Build a tree structure from the first contact list, where each level represents a digit position

Search for Matches

For each number in the second list, walk through the directory tree as far as you can go

Record Best Match

Keep track of the deepest level you reached - that's your longest common prefix!

Key Takeaway

🎯 Key Insight: By building a trie (directory tree) from one array, we can efficiently find the longest common prefix with any number from the second array in a single traversal, avoiding the need to compare every possible pair!

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 31

The optimal solution uses a Trie (prefix tree) data structure. Build a trie from all numbers in arr1, then for each number in arr2, traverse the trie as far as possible. The maximum depth reached during any traversal is the answer. This approach has O((n+m)*k) time complexity where k is the average number of digits, making it much more efficient than the brute force O(n*m*k) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Trie Approach	O((n+m)*k)	O(n*k)	Build a trie from arr1 prefixes, then traverse with arr2 numbers to find longest paths
Hash Set of Prefixes	O((n+m)*k)	O(n*k)	Store all prefixes of arr1 in a hash set, then check each prefix of arr2 numbers
Brute Force (Nested Loops)	O(nmk)	O(1)	Compare every pair of numbers digit by digit to find the longest common prefix

Optimized Trie Approach — Algorithm Steps

Build a trie by inserting all numbers from arr1 digit by digit
For each number in arr2, traverse the trie character by character
Track the maximum depth reached during traversal
Return the maximum depth found across all numbers in arr2

Visualization

Tap to expand

Step-by-Step Walkthrough

Build trie

Insert all numbers from arr1 into trie digit by digit

Traverse trie

For each number in arr2, walk down the trie as far as possible

Track depth

Record the maximum depth reached during any traversal

Code -

solution.c — C

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

#define MAX_CHILDREN 10

typedef struct TrieNode {
    struct TrieNode* children[MAX_CHILDREN];
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)calloc(1, sizeof(TrieNode));
    return node;
}

int longestCommonPrefix(int* arr1, int arr1Size, int* arr2, int arr2Size) {
    // Build trie from arr1
    TrieNode* root = createNode();
    
    for (int i = 0; i < arr1Size; i++) {
        TrieNode* node = root;
        char s[20];
        sprintf(s, "%d", arr1[i]);
        
        for (int j = 0; s[j]; j++) {
            int digit = s[j] - '0';
            if (!node->children[digit]) {
                node->children[digit] = createNode();
            }
            node = node->children[digit];
        }
    }
    
    // Search with arr2 numbers
    int maxLength = 0;
    for (int i = 0; i < arr2Size; i++) {
        TrieNode* node = root;
        char s[20];
        sprintf(s, "%d", arr2[i]);
        int currentLength = 0;
        
        for (int j = 0; s[j]; j++) {
            int digit = s[j] - '0';
            if (!node->children[digit]) {
                break;
            }
            node = node->children[digit];
            currentLength++;
        }
        
        if (currentLength > maxLength) {
            maxLength = currentLength;
        }
    }
    
    return maxLength;
}

Time & Space Complexity

Time Complexity

⏱️

O((n+m)*k)

Build trie takes O(n*k) and searching takes O(m*k) where k is average digits

✓ Linear Growth

Space Complexity

O(n*k)

Trie stores all unique prefixes from arr1, worst case n*k nodes

⚡ Linearithmic Space

23.8K Views

Medium-High Frequency

~18 min Avg. Time

847 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

Optimized Trie Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler