Safe Division - Problem

Implement a safe division function that gracefully handles various error conditions without crashing the program.

Your function should:

Handle division by zero - return "Error: Division by zero"
Handle non-numeric inputs - return "Error: Invalid input"
Perform normal division for valid numeric inputs
Return results as strings for consistency

The function takes two parameters that could be numbers, strings, or other data types, and must validate them before attempting division.

Input & Output

Example 1 — Valid Division

$ Input: dividend = "10", divisor = "2"

› Output: "5"

💡 Note: Both inputs are valid numbers. 10 ÷ 2 = 5, returned as string "5"

Example 2 — Division by Zero

$ Input: dividend = "10", divisor = "0"

› Output: "Error: Division by zero"

💡 Note: Divisor is zero, which would cause a division by zero error, so return error message

Example 3 — Invalid Input

$ Input: dividend = "abc", divisor = "2"

› Output: "Error: Invalid input"

💡 Note: First parameter "abc" cannot be converted to a number, so return invalid input error

Constraints

Input parameters can be strings, numbers, or other data types
Must handle all non-numeric inputs gracefully
Must prevent division by zero errors
Return all results as strings for consistency

Visualization

Tap to expand

Asked in

M Microsoft 25 a Amazon 20 G Google 15

The key insight is to validate inputs before attempting division and handle errors gracefully. The try-catch approach provides cleaner error handling by letting the system catch conversion errors automatically. Time: O(1), Space: O(1)

Common Approaches

✓ Manual Type Checking

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

Check if inputs are numbers using string conversion and parsing, then separately check for division by zero, then perform division. Uses basic conditional logic without exception handling.

Try-Catch Exception Handling

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

Wrap the number conversion and division operations in try-catch blocks. Let the system handle type conversion errors naturally, then catch and return appropriate error messages.

Manual Type Checking — Algorithm Steps

Step 1: Convert inputs to strings and check if they represent numbers
Step 2: Parse to numbers if valid, return error if not
Step 3: Check if divisor is zero
Step 4: Perform division and return result as string

Visualization

Tap to expand

Step-by-Step Walkthrough

Type Check

Examine each input to determine if it's a valid number

Zero Check

Verify divisor is not zero

Division

Perform safe division and return result

Code -

solution.c — C

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

int isValidNumber(const char* str) {
    int len = strlen(str);
    if (len == 0) return 0;
    
    int i = 0;
    if (str[i] == '-' || str[i] == '+') i++;
    
    int hasDigit = 0;
    int hasDot = 0;
    
    for (; i < len; i++) {
        if (isdigit(str[i])) {
            hasDigit = 1;
        } else if (str[i] == '.' && !hasDot) {
            hasDot = 1;
        } else {
            return 0;
        }
    }
    
    return hasDigit;
}

char* solution(const char* dividend, const char* divisor) {
    static char result[100];
    
    // Validate inputs
    if (!isValidNumber(dividend) || !isValidNumber(divisor)) {
        strcpy(result, "Error: Invalid input");
        return result;
    }
    
    double numDividend = atof(dividend);
    double numDivisor = atof(divisor);
    
    // Check for division by zero
    if (numDivisor == 0) {
        strcpy(result, "Error: Division by zero");
        return result;
    }
    
    // Perform division
    double divResult = numDividend / numDivisor;
    sprintf(result, "%g", divResult);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed number of checks regardless of input size

✓ Linear Growth

Space Complexity

O(1)

Only stores a few variables for validation

✓ Linear Space

25.4K Views

Medium Frequency

~10 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

Safe Division - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Manual Type Checking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler