Detect Phone Numbers Missing a Country Code: Heuristics and libphonenumber

Parse Phone Numbers Without a Country Code: Heuristic Detection

“Given a list of phone numbers in mixed formats, identify which are missing a country code.” This is a classic Apple / consumer-product engineering interview question that tests string parsing, regular expression skill, and the ability to reason about heuristics under ambiguous data. The base problem is simple — check whether a phone number has a country code prefix — but real-world phone-number data is messy enough that pure rule-based detection misses cases. This guide covers the standard approaches and the trade-offs between strict pattern matching and heuristic-based detection.

Problem Statement

Given a string representing a phone number in arbitrary format, determine whether it includes a country code. Country codes typically range from 1 to 3 digits and may be prefixed with “+” or “00”.

Examples:

• "+1 555-123-4567" → has country code (1 = US)
• "555-123-4567" → missing country code
• "+44 20 7123 4567" → has country code (44 = UK)
• "00 49 30 12345678" → has country code (49 = Germany, prefix 00)
• "(555) 123-4567" → missing country code

Approach 1: Strict Prefix Detection

Check for “+” or “00” at the start. Naive but works for clean data.

def has_country_code_strict(phone: str) -> bool:
    """Detect country code via prefix."""
    s = phone.strip()
    return s.startswith("+") or s.startswith("00")


# Tests
print(has_country_code_strict("+1 555-123-4567"))      # True
print(has_country_code_strict("555-123-4567"))          # False
print(has_country_code_strict("00 49 30 12345678"))     # True
print(has_country_code_strict("(555) 123-4567"))        # False

Acceptable for input with consistent formatting. Misses cases where the country code is implied without an explicit “+” — e.g., “1-800-…” in US format where “1” is the country code, or a leading “1” before a 10-digit number.

Approach 2: Length-Based Heuristic

Count the digits in the number. Most national formats have 7-10 digits; numbers with 11+ digits often imply an embedded country code.

import re

def count_digits(phone: str) -> int:
    return len(re.sub(r"D", "", phone))


def has_country_code_heuristic(phone: str) -> bool:
    """Heuristic combining prefix and length."""
    s = phone.strip()
    if s.startswith("+") or s.startswith("00"):
        return True
    digit_count = count_digits(s)
    # US format with leading 1 (11 digits): country code present
    if digit_count == 11 and re.sub(r"D", "", s).startswith("1"):
        return True
    # Strictly more than 10 digits: probably has country code
    if digit_count > 10:
        return True
    return False


# Tests
print(has_country_code_heuristic("+1 555-123-4567"))       # True
print(has_country_code_heuristic("1-555-123-4567"))         # True (11 digits, leading 1)
print(has_country_code_heuristic("555-123-4567"))           # False (10 digits, no prefix)
print(has_country_code_heuristic("(555) 123-4567"))         # False

The heuristic catches “1-555-…” style US numbers without explicit “+”. Trade-off: heuristics are imperfect; some valid 10-digit US numbers without country code may be ambiguous if they happen to start with a country-code-like digit.

Approach 3: Library-Based (Production)

For real-world phone-number parsing, use Google’s libphonenumber. It handles every country’s formats, normalizes input, and provides validation.

# pip install phonenumbers
import phonenumbers

def has_country_code_lib(phone: str, default_region: str = "US") -> bool:
    """Use libphonenumber for production-quality parsing."""
    try:
        # Parse with default_region as fallback
        parsed = phonenumbers.parse(phone, default_region)
        # If the parsed country code matches the default, no explicit country code was given
        explicit_country_code = phonenumbers.parse(phone, None)
        return explicit_country_code.country_code is not None
    except phonenumbers.phonenumberutil.NumberParseException:
        return False

For interview purposes, mention libphonenumber as the production answer; implement a manual heuristic to demonstrate skill.

Approach 4: Country Code Lookup

Maintain a list of valid country codes (1, 7, 20, 27, 30, 31, …, 998). Strip non-digits; check whether the leading digits match any valid country code.

COUNTRY_CODES = {
    "1", "7", "20", "27", "30", "31", "32", "33", "34", "36", "39", "40", "41",
    "43", "44", "45", "46", "47", "48", "49", "51", "52", "53", "54", "55",
    "56", "57", "58", "60", "61", "62", "63", "64", "65", "66", "81", "82",
    "84", "86", "90", "91", "92", "93", "94", "95", "98",
    # ... (full list ~250 codes)
}

def has_country_code_lookup(phone: str) -> bool:
    digits = re.sub(r"D", "", phone)
    # Try 1, 2, 3-digit prefixes
    for length in (1, 2, 3):
        if digits[:length] in COUNTRY_CODES:
            # Validate remaining length
            remaining = len(digits) - length
            if 7 <= remaining <= 12:  # plausible national number length
                return True
    return False

More accurate than length-based heuristic but requires maintaining the country-code list. libphonenumber is preferable for production.

Common Variations

Format / normalize phone numbers

Convert various formats to a canonical E.164 format (e.g., +14155551234). libphonenumber’s format_number handles this.

Detect emergency numbers

Numbers like 911 (US), 999 (UK), 112 (EU). Special-case these; they don’t follow standard country-code rules.

Detect short codes / SMS shortcodes

Marketing shortcodes (4-6 digits) aren’t traditional phone numbers. Different validation; libphonenumber distinguishes them.

Detect VoIP / mobile / landline

By number prefix within a country, you can sometimes infer line type. libphonenumber provides this; rule-based detection is fragile.

Common Mistakes

• Assuming all phone numbers are 10 digits. US/Canada are 10; UK is 10–11; Germany is 10–13; Sweden is 7–10. National lengths vary widely.
• Not normalizing whitespace and separators. Strip all non-digits before pattern matching, except the leading “+” which is meaningful.
• Confusing “+” with “00” prefixes. Both indicate international format. “+” is more common; “00” is older but still seen in Europe.
• Assuming “1” is always a US country code prefix. “1” is also the start of valid 10-digit US numbers (just rare). Length disambiguates: 11 digits starting with 1 → has country code; 10 digits → no country code.
• Hand-rolling regex when libphonenumber exists. For production, use libphonenumber. Hand-rolled regex misses edge cases (extensions, special services, regional formats). For interview purposes, hand-rolling demonstrates skill, but mention the production answer.

Frequently Asked Questions

See also: Remove a Character from a String • Print String Permutations • Boolean String Value Parsing

function findMissingCode(codes, n) {
    // XOR all numbers from 1 to n
    let xorAll = 0;
    for (let i = 1; i <= n; i++) {
        xorAll ^= i;
    }

    // XOR all codes in array
    let xorArray = 0;
    for (const code of codes) {
        xorArray ^= code;
    }

    // Missing number is xorAll XOR xorArray
    return xorAll ^ xorArray;
}

// Test
console.log(findMissingCode([1, 2, 4, 5, 6], 6));  // 3
console.log(findMissingCode([1, 2, 3, 5], 5));     // 4

function findMissingCodeSum(codes, n) {
    // Expected sum: 1 + 2 + ... + n = n(n+1)/2
    const expectedSum = (n * (n + 1)) / 2;

    // Actual sum
    const actualSum = codes.reduce((sum, code) => sum + code, 0);

    return expectedSum - actualSum;
}

console.log(findMissingCodeSum([1, 2, 4, 5, 6], 6));  // 3

function findMissingCodeSet(codes, n) {
    const set = new Set(codes);

    for (let i = 1; i <= n; i++) {
        if (!set.has(i)) {
            return i;
        }
    }

    return -1;  // Not found (shouldn't happen if input valid)
}

console.log(findMissingCodeSet([1, 2, 4, 5, 6], 6));  // 3

function findTwoMissing(codes, n) {
    // XOR gives us xor of two missing numbers
    let xorAll = 0;
    for (let i = 1; i <= n; i++) xorAll ^= i;
    for (const code of codes) xorAll ^= code;

    // xorAll = a ^ b (where a, b are missing)
    // Find rightmost set bit
    const rightBit = xorAll & -xorAll;

    // Partition numbers by this bit
    let xor1 = 0, xor2 = 0;

    for (let i = 1; i <= n; i++) {
        if (i & rightBit) {
            xor1 ^= i;
        } else {
            xor2 ^= i;
        }
    }

    for (const code of codes) {
        if (code & rightBit) {
            xor1 ^= code;
        } else {
            xor2 ^= code;
        }
    }

    return [xor1, xor2];
}

console.log(findTwoMissing([1, 2, 5, 6], 6));  // [3, 4] or [4, 3]

function findDuplicate(codes) {
    // Array has n+1 elements with values 1 to n
    // One value appears twice
    // Floyd's cycle detection

    let slow = codes[0];
    let fast = codes[0];

    // Find intersection point
    do {
        slow = codes[slow];
        fast = codes[codes[fast]];
    } while (slow !== fast);

    // Find entrance to cycle (the duplicate)
    slow = codes[0];
    while (slow !== fast) {
        slow = codes[slow];
        fast = codes[fast];
    }

    return slow;
}

console.log(findDuplicate([1, 3, 4, 2, 2]));  // 2
console.log(findDuplicate([3, 1, 3, 4, 2]));  // 3

function findMissingAndDuplicate(codes, n) {
    // One number appears twice, one is missing

    // Using XOR
    let xor = 0;
    for (let i = 1; i <= n; i++) xor ^= i;
    for (const code of codes) xor ^= code;

    // xor = missing ^ duplicate
    const rightBit = xor & -xor;

    let xor1 = 0, xor2 = 0;
    for (let i = 1; i <= n; i++) {
        if (i & rightBit) xor1 ^= i;
        else xor2 ^= i;
    }

    for (const code of codes) {
        if (code & rightBit) xor1 ^= code;
        else xor2 ^= code;
    }

    // Determine which is missing and which is duplicate
    for (const code of codes) {
        if (code === xor1) {
            return {duplicate: xor1, missing: xor2};
        }
        if (code === xor2) {
            return {duplicate: xor2, missing: xor1};
        }
    }
}

console.log(findMissingAndDuplicate([1, 2, 2, 4, 5], 5));
// {duplicate: 2, missing: 3}

xorAll = 1 ⊕ 2 ⊕ 3 ⊕ 4 ⊕ 5 ⊕ 6
xorArray = 1 ⊕ 2 ⊕ 4 ⊕ 5 ⊕ 6

xorAll ⊕ xorArray = (1 ⊕ 2 ⊕ 3 ⊕ 4 ⊕ 5 ⊕ 6) ⊕ (1 ⊕ 2 ⊕ 4 ⊕ 5 ⊕ 6)
                  = 3 ⊕ (1 ⊕ 1) ⊕ (2 ⊕ 2) ⊕ (4 ⊕ 4) ⊕ (5 ⊕ 5) ⊕ (6 ⊕ 6)
                  = 3 ⊕ 0 ⊕ 0 ⊕ 0 ⊕ 0 ⊕ 0
                  = 3 ✓