{x}
blog image

Reformat Phone Number

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

You would like to reformat the phone number in a certain manner. Firstly, remove all spaces and dashes. Then, group the digits from left to right into blocks of length 3 until there are 4 or fewer digits. The final digits are then grouped as follows:

  • 2 digits: A single block of length 2.
  • 3 digits: A single block of length 3.
  • 4 digits: Two blocks of length 2 each.

The blocks are then joined by dashes. Notice that the reformatting process should never produce any blocks of length 1 and produce at most two blocks of length 2.

Return the phone number after formatting.

 

Example 1:

Input: number = "1-23-45 6"
Output: "123-456"
Explanation: The digits are "123456".
Step 1: There are more than 4 digits, so group the next 3 digits. The 1st block is "123".
Step 2: There are 3 digits remaining, so put them in a single block of length 3. The 2nd block is "456".
Joining the blocks gives "123-456".

Example 2:

Input: number = "123 4-567"
Output: "123-45-67"
Explanation: The digits are "1234567".
Step 1: There are more than 4 digits, so group the next 3 digits. The 1st block is "123".
Step 2: There are 4 digits left, so split them into two blocks of length 2. The blocks are "45" and "67".
Joining the blocks gives "123-45-67".

Example 3:

Input: number = "123 4-5678"
Output: "123-456-78"
Explanation: The digits are "12345678".
Step 1: The 1st block is "123".
Step 2: The 2nd block is "456".
Step 3: There are 2 digits left, so put them in a single block of length 2. The 3rd block is "78".
Joining the blocks gives "123-456-78".

 

Constraints:

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

Solution Explanation: Reformat Phone Number

This problem involves reformatting a phone number string into a standardized format. The steps are:

  1. Clean the input: Remove all spaces and hyphens from the input string.
  2. Group the digits: Group the digits into blocks of three, from left to right.
  3. Handle remaining digits: If fewer than three digits remain, group them as follows:
    • Two digits: A single block of length 2.
    • Three digits: A single block of length 3.
    • Four digits: Two blocks of length 2 each.
  4. Join the blocks: Join the blocks with hyphens.

Approach:

The most straightforward approach is to perform these steps sequentially. The code iteratively groups digits into blocks of three. A final check handles the remaining digits based on their count (1, 2, or 3).

Time and Space Complexity Analysis:

  • Time Complexity: O(n), where n is the length of the input string. This is because we iterate through the string once to remove non-digit characters, and then iterate again to group the digits. The grouping and joining operations take linear time as well.
  • Space Complexity: O(n) in the worst case. This is because we might need to store the entire cleaned phone number in a new string.

Code Implementation (Python):

def reformat_number(number):
    """Reformats a phone number string.
 
    Args:
        number: The input phone number string.
 
    Returns:
        The reformatted phone number string.
    """
 
    cleaned_number = "".join(c for c in number if c.isdigit())
    n = len(cleaned_number)
    result = []
 
    for i in range(0, n, 3):
        if i + 3 <= n:
            result.append(cleaned_number[i:i+3])
        elif i + 2 <= n:
            result.append(cleaned_number[i:i+2])
        else:
            result.append(cleaned_number[i])
 
    return "-".join(result)

Code Implementation (Java):

class Solution {
    public String reformatNumber(String number) {
        StringBuilder sb = new StringBuilder();
        for (char c : number.toCharArray()) {
            if (Character.isDigit(c)) {
                sb.append(c);
            }
        }
 
        int n = sb.length();
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < n; i += 3) {
            if (i + 3 <= n) {
                result.append(sb.substring(i, i + 3));
            } else if (i + 2 <= n) {
                result.append(sb.substring(i, i + 2));
            } else {
                result.append(sb.substring(i));
            }
            if (i + 3 < n) {
                result.append("-");
            }
        }
        return result.toString();
    }
}

The code in other languages (C++, Java, Go, Typescript, Rust) will follow a similar structure, adapting the string manipulation functions appropriate to each language. The core algorithm remains consistent across all implementations.