Reformat Phone Number - Practice Coding Problems

Reformat Phone Number - Problem

String Easy

You are given a phone number as a string number. The string consists of digits, spaces ' ', and/or dashes '-'.

You need to reformat the phone number in a specific manner:

Remove all spaces and dashes from the input string
Group digits from left to right into blocks of length 3 until there are 4 or fewer digits remaining
Handle the final digits based on how many remain:
- 2 digits: Create a single block of length 2
- 3 digits: Create a single block of length 3
- 4 digits: Create two blocks of length 2 each
Join all blocks with dashes to form the final result

The reformatting process ensures no blocks of length 1 are created and at most two blocks of length 2 appear.

Input & Output

Example 1 — Basic Reformatting

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

› Output: "123-456"

💡 Note: Remove dashes and spaces: "123456". Group as 123-456 since we have 6 digits (group first 3, remaining 3 form one block).

Example 2 — Four Digits Special Case

$ Input: number = "123 4-567"

› Output: "123-45-67"

💡 Note: Clean to "1234567". Group first 3: "123", leaving 4 digits "4567". Split final 4 into two blocks of 2: "45-67".

Example 3 — Longer Number

$ Input: number = "123 4-5678-90"

› Output: "123-456-78-90"

💡 Note: Clean to "1234567890". Group by 3: "123-456-789" leaves 1 digit. Since final 4 digits "7890" should become "78-90".

Constraints

1 ≤ number.length ≤ 100
number consists of digits, spaces ' ', and/or dashes '-'

Visualization

Tap to expand

Understanding the Visualization

Input

Phone number with spaces and dashes

Clean

Extract only digit characters

Group

Apply 3-digit grouping with special final rules

Output

Formatted number with dash separators

Key Takeaway

🎯 Key Insight: The secret is recognizing that 4 remaining digits must become 2+2 blocks to avoid forbidden single-digit blocks

Asked in

f Facebook 15 G Google 12 M Microsoft 8

The key insight is to avoid single-digit blocks by handling the final 4 digits specially - split them into two blocks of 2 each. Clean the input by removing spaces and dashes, then group digits by 3 until 4 or fewer remain. Best approach is single pass with lookahead. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force String Processing	O(n)	O(n)	Clean digits first, then build groups character by character
Single Pass with Smart Logic	O(n)	O(n)	Process and format in one pass with lookahead for remaining digits

Brute Force String Processing — Algorithm Steps

Step 1: Remove all spaces and dashes from input
Step 2: Group digits into blocks of 3 from left to right
Step 3: Handle remaining digits (2→one block, 3→one block, 4→two blocks of 2)

Visualization

Tap to expand

Step-by-Step Walkthrough

Clean Input

Remove all non-digit characters

Group by 3

Create blocks of 3 digits from left to right

Handle Remaining

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

Code -

solution.c — C

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

char* solution(char* number) {
    // Remove all spaces and dashes
    char digits[1000];
    int digitCount = 0;
    for (int i = 0; number[i]; i++) {
        if (isdigit(number[i])) {
            digits[digitCount++] = number[i];
        }
    }
    digits[digitCount] = '\0';
    
    char* result = malloc(1000);
    result[0] = '\0';
    
    int i = 0;
    int first = 1;
    
    // Group into blocks of 3 while more than 4 digits remain
    while (digitCount - i > 4) {
        if (!first) strcat(result, "-");
        strncat(result, digits + i, 3);
        i += 3;
        first = 0;
    }
    
    // Handle remaining digits
    int remaining = digitCount - i;
    if (remaining == 2) {
        if (!first) strcat(result, "-");
        strncat(result, digits + i, 2);
    } else if (remaining == 3) {
        if (!first) strcat(result, "-");
        strncat(result, digits + i, 3);
    } else if (remaining == 4) {
        if (!first) strcat(result, "-");
        strncat(result, digits + i, 2);
        strcat(result, "-");
        strncat(result, digits + i + 2, 2);
    }
    
    return result;
}

int main() {
    char number[1000];
    fgets(number, sizeof(number), stdin);
    number[strcspn(number, "\n")] = 0;
    
    char* result = solution(number);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to clean string + single pass to group digits

✓ Linear Growth

Space Complexity

O(n)

Store cleaned digits and result blocks

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~12 min Avg. Time

684 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

Brute Force String Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler