Input Validator - Problem

Create a program that continuously prompts the user for an integer input until a valid integer is provided. The program should:

Keep asking for input in a loop
Handle invalid input gracefully with error messages
Return the first valid integer entered
Use proper exception handling to catch conversion errors

Note: Your function will receive a list of input strings that simulate user input attempts. Process them in order until you find a valid integer.

Input & Output

Example 1 — Mixed Invalid and Valid Inputs

$ Input: inputs = ["abc", "12x", "42"]

› Output: 42

💡 Note: Skip "abc" (not a number), skip "12x" (contains letter), return 42 (first valid integer)

Example 2 — Negative Numbers

$ Input: inputs = ["-5.5", "-10", "hello"]

› Output: -10

💡 Note: Skip "-5.5" (decimal), return -10 (first valid integer), never reach "hello"

Example 3 — First Input Valid

$ Input: inputs = ["123", "invalid", "456"]

› Output: 123

💡 Note: Return 123 immediately as it's the first valid integer in the list

Constraints

1 ≤ inputs.length ≤ 100
Each input string length ≤ 50 characters
At least one valid integer will be present in the inputs

Visualization

Tap to expand

Asked in

M Microsoft 15 A Amazon 12 G Google 8 🍎 Apple 6

The key insight is to use exception handling to gracefully handle invalid input instead of manually validating each character. The try-catch approach leverages built-in parsing functions that are optimized and handle edge cases automatically. Best approach: Try-Catch Exception Handling. Time: O(n×m), Space: O(1)

Common Approaches

✓ Character-by-Character Validation

⏱️ Time: O(n×m) Space: O(1)

Loop through each input string and manually validate every character to ensure it's a digit (with optional leading minus sign). This approach requires implementing integer validation from scratch.

Try-Catch Exception Handling

⏱️ Time: O(n×m) Space: O(1)

Leverage the programming language's built-in integer conversion function with try-catch blocks to handle invalid inputs gracefully. This approach is cleaner and more efficient than manual validation.

Character-by-Character Validation — Algorithm Steps

Iterate through each input string
Check each character manually for digits
Handle negative numbers by checking first character
Return first valid integer found

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Each Character

Manually examine every character

Validate Digits

Ensure all characters are valid

Convert Result

Build integer from valid digits

Code -

solution.c — C

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

int solution(char inputs[][100], int count) {
    for (int idx = 0; idx < count; idx++) {
        char* inp = inputs[idx];
        
        // Trim whitespace
        while (*inp == ' ' || *inp == '\t') inp++;
        int len = strlen(inp);
        while (len > 0 && (inp[len-1] == ' ' || inp[len-1] == '\t')) {
            inp[--len] = '\0';
        }
        
        if (len == 0) continue;
        
        int valid = 1;
        int start = 0;
        
        // Handle negative sign
        if (inp[0] == '-') {
            if (len == 1) {
                valid = 0;
            } else {
                start = 1;
            }
        } else if (inp[0] == '+') {
            if (len == 1) {
                valid = 0;
            } else {
                start = 1;
            }
        }
        
        // Check remaining characters are digits
        if (valid) {
            for (int i = start; i < len; i++) {
                if (!isdigit(inp[i])) {
                    valid = 0;
                    break;
                }
            }
        }
        
        if (valid) {
            // Convert manually
            int result = 0;
            int negative = inp[0] == '-';
            for (int i = start; i < len; i++) {
                result = result * 10 + (inp[i] - '0');
            }
            return negative ? -result : result;
        }
    }
    return 0;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse JSON array manually
    char inputs[10][100];
    int count = 0;
    char* ptr = strchr(line, '"');
    
    while (ptr && count < 10) {
        ptr++; // Skip opening quote
        char* end = strchr(ptr, '"');
        if (end) {
            *end = '\0';
            strcpy(inputs[count], ptr);
            count++;
            ptr = strchr(end + 1, '"');
        } else {
            break;
        }
    }
    
    printf("%d\n", solution(inputs, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

n inputs × m average characters per input to validate

✓ Linear Growth

Space Complexity

O(1)

Only using variables, no extra data structures

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

890 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 Validator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Character-by-Character Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler