Reformat Phone Number

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

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

✓ Brute Force String Processing

⏱️ Time: O(n) Space: O(n)

Remove all spaces and dashes, then iterate through cleaned digits and build groups of 3, handling the final remaining digits with special logic.

Single Pass with Smart Logic

⏱️ Time: O(n) Space: O(n)

Clean the input string and build the result in a single pass, using lookahead to determine optimal grouping for the final 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