Phone Number Prefix - Practice Coding Problems

Phone Number Prefix - Problem

Phone Number Prefix Detection

Imagine you're building a phone directory system that needs to ensure data integrity. You've been given an array of numbers representing phone numbers as strings.

Your task is to determine if the phone directory is valid - meaning no phone number is a prefix of any other phone number. A string A is a prefix of string B if B starts with A.

Return true if no phone number is a prefix of another; otherwise, return false.

Examples:
• ["911", "91123", "456"] → false ("911" is a prefix of "91123")
• ["123", "456", "789"] → true (no prefixes found)
• ["12", "345", "1234"] → false ("12" is a prefix of "1234")

Input & Output

example_1.py — Python

$ Input: ["911", "91123", "456"]

› Output: false

💡 Note: The number "911" is a prefix of "91123", so the function returns false. When someone dials "911", the system cannot determine if they want to reach emergency services or continue dialing to "91123".

example_2.py — Python

$ Input: ["123", "456", "789"]

› Output: true

💡 Note: No phone number in this array is a prefix of any other number. Each number is completely independent, so the function returns true.

example_3.py — Python

$ Input: ["12", "345", "1234", "567"]

› Output: false

💡 Note: The number "12" is a prefix of "1234". Even though other numbers like "345" and "567" don't create conflicts, the existence of one prefix relationship is enough to return false.

Visualization

Tap to expand

Understanding the Visualization

Receive Phone List

Start with an unsorted list of phone numbers that need validation

Sort Numbers

Arrange numbers lexicographically so potential prefixes appear adjacent

Check Adjacents

Compare each number only with its immediate neighbor for prefix relationship

Detect Conflicts

If any number is a prefix of the next, return false immediately

Key Takeaway

🎯 Key Insight: Sorting transforms an O(n²) comparison problem into an O(n) adjacent-check problem, dramatically improving efficiency!

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n numbers, each with average length m for trie operations

✓ Linear Growth

Space Complexity

O(n × m)

Trie storage requires space proportional to total characters

⚡ Linearithmic Space

Constraints

1 ≤ numbers.length ≤ 10⁴
1 ≤ numbers[i].length ≤ 10
numbers[i] consists of digits only
All phone numbers are unique

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach is to sort the phone numbers and check only adjacent pairs for prefix relationships. After sorting, if number A is a prefix of number B, they must appear consecutively. This reduces comparisons from O(n²) to O(n) after an initial O(n log n) sort, making it much more efficient than brute force.

Common Approaches

Approach	Time	Space	Notes
✓ Trie Data Structure	O(n × m)	O(n × m)	Build a trie and detect if any complete word is a prefix of another
Brute Force (Nested Loops)	O(n² × m)	O(1)	Check every phone number against every other phone number
Sorting + Adjacent Check	O(n log n + n × m)	O(1)	Sort the array and check only adjacent elements for prefix relationships

Trie Data Structure — Algorithm Steps

Build a trie by inserting all phone numbers
Mark the end of each complete phone number
Traverse the trie to find nodes that are both end-of-word and have children
If such nodes exist, it means one number is a prefix of another
Return false if prefix relationships found, true otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Trie

Initialize empty trie with root node

Insert Numbers

Add each phone number as a path in the trie

Mark Endpoints

Mark nodes where complete numbers end

Detect Conflicts

Find nodes that are both endpoints and have children

Code -

solution.c — C

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

#define CHAR_SIZE 10

typedef struct TrieNode {
    struct TrieNode* children[CHAR_SIZE];
    bool isEnd;
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
    node->isEnd = false;
    for (int i = 0; i < CHAR_SIZE; i++) {
        node->children[i] = NULL;
    }
    return node;
}

bool hasPrefix(TrieNode* node) {
    if (node->isEnd) {
        for (int i = 0; i < CHAR_SIZE; i++) {
            if (node->children[i] != NULL) {
                return true;
            }
        }
    }
    for (int i = 0; i < CHAR_SIZE; i++) {
        if (node->children[i] != NULL && hasPrefix(node->children[i])) {
            return true;
        }
    }
    return false;
}

bool isPrefixFree(char** numbers, int n) {
    TrieNode* root = createNode();
    
    // Build trie
    for (int i = 0; i < n; i++) {
        TrieNode* node = root;
        for (int j = 0; numbers[i][j]; j++) {
            int index = numbers[i][j] - '0';
            if (!node->children[index]) {
                node->children[index] = createNode();
            }
            node = node->children[index];
        }
        node->isEnd = true;
    }
    
    return !hasPrefix(root);
}

int main() {
    char* numbers[] = {"911", "91123", "456"}; // Example input
    int n = 3;
    printf("%s\n", isPrefixFree(numbers, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n numbers, each with average length m for trie operations

✓ Linear Growth

Space Complexity

O(n × m)

Trie storage requires space proportional to total characters

⚡ Linearithmic Space

Constraints

1 ≤ numbers.length ≤ 10⁴
1 ≤ numbers[i].length ≤ 10
numbers[i] consists of digits only
All phone numbers are unique

42.6K Views

Medium Frequency

~15 min Avg. Time

1.4K 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

Trie Data Structure — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler