Reformat Phone Number - Practice Coding Problems

Reformat Phone Number - Problem

String Easy

You're building a contact management system and need to standardize phone numbers for consistent display. Given a phone number as a string that contains digits, spaces, and/or dashes, your task is to reformat it according to specific grouping rules.

The Process:

Remove all spaces and dashes from the input
Group digits from left to right into blocks of length 3
When 4 or fewer digits remain, apply special rules:

2 digits: Keep as one block of length 2
3 digits: Keep as one block of length 3
4 digits: Split into two blocks of length 2 each

Finally, join all blocks with dashes. The key constraint is that no block should ever have length 1, and at most two blocks can have length 2.

Example: "1-23-45 6" becomes "123-456" (clean → group into 3s → format remaining)

Input & Output

example_1.py — Standard Case

$ Input: number = "1-23-45 6"

› Output: "123-456"

💡 Note: After removing spaces and dashes: '123456'. We can form one group of 3 ('123') and have 3 remaining digits ('456'), so we keep them as one block of 3.

example_2.py — Four Remaining Digits

$ Input: number = "123 4-567"

› Output: "123-45-67"

💡 Note: After cleaning: '1234567'. We form one group of 3 ('123') and have 4 remaining digits ('4567'). Since we can't have blocks of length 1, we split the 4 remaining digits into two blocks of 2: '45' and '67'.

example_3.py — Short Number

$ Input: number = "12"

› Output: "12"

💡 Note: After cleaning: '12'. Since we have only 2 digits total, we keep them as one block of length 2.

Constraints

2 ≤ number.length ≤ 100
number consists of digits and the characters '-' and ' '
There are at least two digits in number

Visualization

Tap to expand

Understanding the Visualization

Input Cleaning

Remove all non-digit characters (spaces and dashes) from the input string

Main Grouping

Create groups of 3 digits from left to right until 4 or fewer digits remain

Remainder Handling

Apply special rules: 2→[2], 3→[3], 4→[2,2] to avoid single-digit groups

Final Assembly

Join all groups with dash separators to create the formatted phone number

Key Takeaway

🎯 Key Insight: The critical rule is avoiding single-digit blocks. When we have 4 remaining digits, we must split them as 2+2 rather than 3+1, ensuring all blocks have length 2 or 3 for optimal readability.

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 15 Apple 12

The optimal approach involves cleaning the input by removing non-digit characters, then systematically grouping digits into blocks of 3 from left to right. The key insight is handling the remainder: when 4 digits remain, split them into two blocks of 2 to avoid creating any single-digit blocks, which maintains the formatting rules while ensuring readability.

Common Approaches

Approach	Time	Space	Notes
✓ Character-by-Character Processing	O(n)	O(n)	Process each character individually, building groups one digit at a time

Character-by-Character Processing — Algorithm Steps

Iterate through each character in the input string
Skip spaces and dashes, collect only digits
For every group of 3 digits, add to result with dash separator
Handle remaining digits according to special rules
Build final string by concatenating all groups

Visualization

Tap to expand

Step-by-Step Walkthrough

Clean Input

Remove spaces and dashes, keep only digits

Group Formation

Create groups of 3 digits from left to right

Handle Remainder

Apply special rules for remaining 2, 3, or 4 digits

Join with Dashes

Connect all groups with dash separators

Code -

solution.c — C

char* reformatNumber(char* number) {
    // Remove spaces and dashes
    char digits[1000];
    int digitCount = 0;
    
    for (int k = 0; number[k]; k++) {
        if (isdigit(number[k])) {
            digits[digitCount++] = number[k];
        }
    }
    digits[digitCount] = '\0';
    
    char* result = (char*)malloc(2000 * sizeof(char));
    result[0] = '\0';
    
    int i = 0;
    bool first = true;
    
    // Process digits in groups
    while (i < digitCount) {
        int remaining = digitCount - i;
        
        if (!first) strcat(result, "-");
        first = false;
        
        if (remaining > 4) {
            // Take group of 3
            strncat(result, digits + i, 3);
            i += 3;
        } else if (remaining == 4) {
            // Split into two groups of 2
            strncat(result, digits + i, 2);
            strcat(result, "-");
            strncat(result, digits + i + 2, 2);
            i += 4;
        } else if (remaining == 3) {
            // One group of 3
            strncat(result, digits + i, 3);
            i += 3;
        } else if (remaining == 2) {
            // One group of 2
            strncat(result, digits + i, 2);
            i += 2;
        } else {
            // Single digit
            strncat(result, digits + i, 1);
            i += 1;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through input string, where n is the length of input

✓ Linear Growth

Space Complexity

O(n)

Space for storing the cleaned digits and building result string

⚡ Linearithmic Space

26.9K Views

Medium Frequency

~15 min Avg. Time

892 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

Character-by-Character Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler