Longest Common Prefix - Practice Coding Problems

Longest Common Prefix - Problem

Find the longest common prefix among an array of strings. You need to determine the longest string that appears at the beginning of every string in the given array.

The Goal: Given an array of strings, find the longest prefix that is common to all strings. If no common prefix exists, return an empty string.

Input: An array of strings strs
Output: A string representing the longest common prefix

Example: For ["flower", "flow", "flight"], the answer is "fl" because all three strings start with "fl".

Input & Output

example_1.py — Python

$ Input: ["flower","flow","flight"]

› Output: "fl"

💡 Note: The longest common prefix among all strings is "fl". All three strings start with these two characters.

example_2.py — Python

$ Input: ["dog","racecar","car"]

› Output: ""

💡 Note: There is no common prefix among the input strings. The first characters are already different: 'd', 'r', 'c'.

example_3.py — Python

$ Input: ["interspecies","interstellar","interstate"]

› Output: "inters"

💡 Note: All three strings share the common prefix "inters" before they start to differ.

Visualization

Tap to expand

Understanding the Visualization

Line up all strings

Arrange strings vertically to compare position by position

Check position 0

All strings have 'f' - this character is part of common prefix

Check position 1

All strings have 'l' - extend common prefix to 'fl'

Check position 2

Mismatch found: 'o', 'o', 'i' - stop and return 'fl'

Key Takeaway

🎯 Key Insight: Compare characters position by position across all strings simultaneously. Stop at the first mismatch to get the longest common prefix efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(S)

Where S is the sum of all characters in all strings. In worst case, we examine every character once.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current position and build result.

✓ Linear Space

Constraints

1 ≤ strs.length ≤ 200
0 ≤ strs[i].length ≤ 200
strs[i] consists of only lowercase English letters

Asked in

G Google 85 a Amazon 72 ⊞ Microsoft 68 f Meta 45

The optimal approach is character-by-character comparison with O(S) time complexity, where S is the sum of all characters. Start from the first position and compare characters across all strings simultaneously, stopping at the first mismatch. This is more efficient than binary search for typical inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Character-by-Character Comparison	O(S)	O(1)	Compare each character position across all strings simultaneously
Binary Search on Prefix Length	O(S * log(m))	O(m)	Use binary search to find the maximum valid prefix length

Character-by-Character Comparison — Algorithm Steps

Start from the first character position (index 0)
Compare the character at current position across all strings
If all characters match, move to the next position
If any character doesn't match or we reach the end of any string, stop
Return the substring from start to the current position

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start at position 0, compare first character across all strings

Match Found

All strings have 'f' at position 0, move to position 1

Match Found

All strings have 'l' at position 1, move to position 2

Mismatch

Position 2 has different characters: 'o', 'o', 'i' - stop here

Code -

solution.c — C

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

char* longestCommonPrefix(char** strs, int strsSize) {
    if (strsSize == 0) {
        char* result = (char*)malloc(1);
        result[0] = '\0';
        return result;
    }
    
    // Find minimum length
    int minLen = strlen(strs[0]);
    for (int k = 1; k < strsSize; k++) {
        int len = strlen(strs[k]);
        if (len < minLen) minLen = len;
    }
    
    for (int i = 0; i < minLen; i++) {
        char c = strs[0][i];
        // Check if all strings have same character at position i
        for (int j = 1; j < strsSize; j++) {
            if (strs[j][i] != c) {
                char* result = (char*)malloc(i + 1);
                strncpy(result, strs[0], i);
                result[i] = '\0';
                return result;
            }
        }
    }
    
    char* result = (char*)malloc(minLen + 1);
    strncpy(result, strs[0], minLen);
    result[minLen] = '\0';
    return result;
}

int main() {
    char* strs[] = {"flower", "flow", "flight"};
    char* result = longestCommonPrefix(strs, 3);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(S)

Where S is the sum of all characters in all strings. In worst case, we examine every character once.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current position and build result.

✓ Linear Space

Constraints

1 ≤ strs.length ≤ 200
0 ≤ strs[i].length ≤ 200
strs[i] consists of only lowercase English letters

68.5K Views

High Frequency

~15 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Character-by-Character Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler