Codestin Search App

Valid Phone Numbers - Problem

Shell Easy

Phone Number Validator - Your task is to process a text file containing phone numbers and identify which ones follow valid formatting patterns.

You're given a file file.txt where each line contains a potential phone number. A valid phone number must match one of these exact formats:

• (xxx) xxx-xxxx - Area code in parentheses followed by space and seven digits with dash
• xxx-xxx-xxxx - Ten digits separated by dashes

Where x represents any digit from 0-9.

Goal: Write a one-liner bash command that prints only the valid phone numbers from the file.

Note: Each line is guaranteed to have no leading or trailing whitespace, so you only need to focus on pattern matching.

Input & Output

example_1.txt — Basic Valid Numbers

$ Input: 987-123-4567 123 456 7890 (555) 123-4567

› Output: 987-123-4567 (555) 123-4567

💡 Note: The first and third lines match valid formats (xxx-xxx-xxxx and (xxx) xxx-xxxx respectively). The second line has spaces instead of dashes, so it's invalid.

example_2.txt — Mixed Valid and Invalid

$ Input: (123) 456-7890 123-456-78901 123-456-7890 (123)456-7890

› Output: (123) 456-7890 123-456-7890

💡 Note: First line: valid parentheses format. Second line: too many digits (11 total). Third line: valid dash format. Fourth line: missing space after parentheses.

example_3.txt — Edge Cases

$ Input: 000-000-0000 (000) 000-0000 123-abc-4567 (123) 456-789a

› Output: 000-000-0000 (000) 000-0000

💡 Note: Leading zeros are allowed since they're still digits. However, letters (abc, a) make the numbers invalid even if the format structure is correct.

Constraints

Each line contains exactly one potential phone number
Lines have no leading or trailing whitespace
Valid formats are exactly (xxx) xxx-xxxx or xxx-xxx-xxxx
x must be a digit from 0-9
Solution must be a one-liner bash command

Visualization

Tap to expand

Understanding the Visualization

Pattern Template

Create regex pattern that matches both valid formats: (xxx) xxx-xxxx OR xxx-xxx-xxxx

Line-by-Line Matching

Apply pattern to each line in the file using grep

Instant Validation

Regex engine validates entire format in single operation

Output Results

Print only lines that match the pattern exactly

Key Takeaway

🎯 Key Insight: Regular expressions provide a powerful pattern matching template that can validate complex formats in a single operation, making them perfect for one-liner solutions like this phone number validator.

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses grep with extended regex to match both valid phone number formats in a single command: grep -E '^($\d{3}$ |\d{3}-)\d{3}-\d{4}$' file.txt. The regex pattern ($\d{3}$ |\d{3}-) matches either parentheses format or dash format for the area code, followed by \d{3}-\d{4} for the remaining digits.

Common Approaches

Approach	Time	Space	Notes
✓ Character-by-Character Validation	O(n*m)	O(1)	Manual validation by checking each character position and format requirement

Character-by-Character Validation — Algorithm Steps

Read each line from the file
Check line length (14 for parentheses format, 12 for dash format)
Validate each character position based on expected format
Count digits to ensure exactly 10 are present
Verify punctuation marks are in correct positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Length Check

First verify the total length: 14 chars for (xxx) xxx-xxxx or 12 chars for xxx-xxx-xxxx

Position Validation

Check specific positions for required punctuation: parentheses, spaces, and dashes

Digit Verification

Verify that all non-punctuation characters are digits

Final Decision

Accept the number only if all validation steps pass

Code -

solution.c — C

// C brute force validation
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>

bool allDigits(const char* str, int start, int end) {
    for (int i = start; i < end; i++) {
        if (!isdigit(str[i])) {
            return false;
        }
    }
    return true;
}

bool isValidPhone(const char* line) {
    int len = strlen(line);
    
    // Format 1: (xxx) xxx-xxxx
    if (len == 14 && line[0] == '(' && line[4] == ')' && 
        line[5] == ' ' && line[9] == '-') {
        return allDigits(line, 1, 4) && allDigits(line, 6, 9) && allDigits(line, 10, 14);
    }
    
    // Format 2: xxx-xxx-xxxx
    if (len == 12 && line[3] == '-' && line[7] == '-') {
        return allDigits(line, 0, 3) && allDigits(line, 4, 7) && allDigits(line, 8, 12);
    }
    
    return false;
}

int main() {
    FILE *file = fopen("file.txt", "r");
    if (!file) {
        perror("Error opening file");
        return 1;
    }
    
    char line[100];
    while (fgets(line, sizeof(line), file)) {
        // Remove newline
        line[strcspn(line, "\n")] = 0;
        
        if (isValidPhone(line)) {
            printf("%s\n", line);
        }
    }
    
    fclose(file);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

n lines in file, m characters per line (constant ~14), so effectively O(n)

✓ Linear Growth

Space Complexity

O(1)

Only using variables for current line processing

✓ Linear Space

28.5K Views

Medium Frequency

~8 min Avg. Time

832 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 Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler