Fraction Addition and Subtraction - Practice Coding Problems

Fraction Addition and Subtraction - Problem

Given a string expression representing an expression of fraction addition and subtraction, return the calculation result in string format.

The final result should be an irreducible fraction. If your final result is an integer, change it to the format of a fraction that has a denominator 1. So in this case, 2 should be converted to 2/1.

Input & Output

Example 1 — Basic Mixed Operations

$ Input: expression = "-1/2+1/2+1/3"

› Output: "1/3"

💡 Note: First: -1/2 + 1/2 = 0, then 0 + 1/3 = 1/3. The result is already in irreducible form.

Example 2 — Multiple Fractions

$ Input: expression = "1/3-1/2"

› Output: "-1/6"

💡 Note: To subtract 1/3 - 1/2, we find common denominator: 2/6 - 3/6 = -1/6

Example 3 — Result is Integer

$ Input: expression = "1/2+1/2"

› Output: "1/1"

💡 Note: 1/2 + 1/2 = 1, which must be expressed as fraction 1/1

Constraints

The input string only contains '0' to '9', '/', '+' and '-'
Each fraction is in the form ±numerator/denominator
Each numerator and denominator is in the range [1, 10]
The final result should be an irreducible fraction

Visualization

Tap to expand

Understanding the Visualization

Input

Expression string with fractions and operators

Process

Parse and accumulate fractions using common denominators

Output

Irreducible fraction as string

Key Takeaway

🎯 Key Insight: Parse fractions sequentially and use GCD for reduction to get irreducible results

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to parse fractions sequentially and maintain a running sum using common denominator arithmetic. The single pass approach with character-by-character parsing is most efficient. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Parse and Calculate Step by Step	O(n)	O(1)	Parse fractions one by one and perform addition/subtraction sequentially
Single Pass with Running Sum	O(n)	O(1)	Parse and accumulate fractions in one pass with efficient GCD reduction

Parse and Calculate Step by Step — Algorithm Steps

Parse the expression to extract fractions and their signs
Process fractions sequentially from left to right
For each pair, find common denominator and calculate
Reduce the final result using GCD

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Expression

Extract fractions with their signs

Sequential Addition

Combine fractions one by one

Reduce Result

Apply GCD to get irreducible fraction

Code -

solution.c — C

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

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

int abs_val(int x) {
    return x < 0 ? -x : x;
}

char* solution(char* expression) {
    int num = 0, den = 1;
    int i = 0;
    int len = strlen(expression);
    
    while (i < len) {
        // Skip to next fraction
        while (i < len && expression[i] != '-' && expression[i] != '+' && !isdigit(expression[i])) {
            i++;
        }
        if (i >= len) break;
        
        // Parse sign and numerator
        int sign = 1;
        if (expression[i] == '-') {
            sign = -1;
            i++;
        } else if (expression[i] == '+') {
            i++;
        }
        
        int currNum = 0;
        while (i < len && isdigit(expression[i])) {
            currNum = currNum * 10 + (expression[i] - '0');
            i++;
        }
        currNum *= sign;
        
        // Skip '/'
        i++;
        
        // Parse denominator
        int currDen = 0;
        while (i < len && isdigit(expression[i])) {
            currDen = currDen * 10 + (expression[i] - '0');
            i++;
        }
        
        // Add fractions
        int newNum = num * currDen + den * currNum;
        int newDen = den * currDen;
        
        // Reduce fraction
        int g = gcd(abs_val(newNum), abs_val(newDen));
        num = newNum / g;
        den = newDen / g;
    }
    
    char* result = malloc(50);
    sprintf(result, "%d/%d", num, den);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to parse string plus GCD calculations which are O(log(min(a,b)))

✓ Linear Growth

Space Complexity

O(1)

Only storing current numerator and denominator values

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

956 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

Parse and Calculate Step by Step — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler