Fraction Addition and Subtraction - Practice Coding Problems

Fraction Addition and Subtraction - Problem

You're given a string expression that represents a series of fraction additions and subtractions. Your task is to evaluate this mathematical expression and return the result as a simplified fraction in string format.

The input string contains fractions in the format numerator/denominator, separated by + or - operators. For example: "-1/2+1/2" or "-1/2+1/2+1/3".

Key Requirements:

The final result must be an irreducible fraction (simplified to lowest terms)
If the result is a whole number, format it as "number/1" (e.g., "2/1")
Handle negative fractions correctly
The expression will always be valid

This problem tests your understanding of fraction arithmetic, greatest common divisor (GCD), and string parsing.

Input & Output

example_1.py — Basic Addition

$ Input: "-1/2+1/2"

› Output: "0/1"

💡 Note: The fractions -1/2 and 1/2 cancel each other out, resulting in 0. Since 0 is an integer, we format it as 0/1.

example_2.py — Mixed Operations

$ Input: "-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 simplest form.

example_3.py — Simplification Required

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

› Output: "-1/6"

💡 Note: Find common denominator: 1/3 - 1/2 = 2/6 - 3/6 = -1/6. The result is already simplified.

Constraints

The input string only contains '0' to '9', '/', '+' and '-'
The input starts and ends with a number
Each fraction is in the format ±numerator/denominator
Cross-multiplication will not cause overflow for valid inputs
All given inputs are valid fraction expressions

Visualization

Tap to expand

Understanding the Visualization

Parse Expression

Break down the string into individual fractions with their signs

Initialize Result

Start with 0/1 as our running total

Add Each Fraction

Use cross-multiplication: (a/b) + (c/d) = (a×d + b×c)/(b×d)

Simplify Immediately

Use GCD to reduce the fraction to lowest terms after each operation

Return Result

Format as string with numerator/denominator

Key Takeaway

🎯 Key Insight: By maintaining a running sum and simplifying immediately after each operation using GCD, we prevent integer overflow while keeping the algorithm simple and efficient. This approach mirrors how you'd manually solve fraction arithmetic step by step.

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 Apple 4

The optimal solution uses a running sum approach with immediate GCD simplification. Parse each fraction sequentially, maintain current result as numerator/denominator pair, and add each new fraction using the formula (a/b) + (c/d) = (a×d + b×c)/(b×d). Key insight: simplify after each operation using GCD to prevent integer overflow and keep numbers manageable.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal: Running Sum with GCD	O(n log(max_value))	O(1)	Maintain running numerator/denominator, simplify after each operation using GCD

Optimal: Running Sum with GCD — Algorithm Steps

Initialize result as 0/1 (numerator=0, denominator=1)
Parse each fraction from the expression one by one
For each fraction, find LCD with current result denominator
Add the fractions: (a/b) + (c/d) = (a*d + b*c)/(b*d)
Immediately simplify using GCD to keep numbers small
Continue until all fractions are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with result = 0/1

Add 1/3

0/1 + 1/3 = 1/3 (already simplified)

Add -1/2

1/3 + (-1/2) = -1/6 (simplified from -3/6)

Add 1/6

-1/6 + 1/6 = 0/1 (simplified)

Final Result

Return "0/1"

Code -

solution.c — C

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

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

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

char* fractionAddition(char* expression) {
    int numResult = 0, denomResult = 1;
    int index = 0;
    int len = strlen(expression);
    
    while (index < len) {
        // Parse sign
        int sign = 1;
        if (expression[index] == '-') {
            sign = -1;
            index++;
        } else if (expression[index] == '+') {
            index++;
        }
        
        // Parse numerator
        int num = 0;
        while (expression[index] != '/') {
            num = num * 10 + (expression[index] - '0');
            index++;
        }
        num *= sign;
        index++; // skip '/'
        
        // Parse denominator
        int denom = 0;
        while (index < len && expression[index] != '+' && expression[index] != '-') {
            denom = denom * 10 + (expression[index] - '0');
            index++;
        }
        
        // Add fractions: a/b + c/d = (a*d + b*c)/(b*d)
        int newNum = numResult * denom + denomResult * num;
        int newDenom = denomResult * denom;
        
        // Simplify using GCD
        int common = gcd(abs_val(newNum), newDenom);
        numResult = newNum / common;
        denomResult = newDenom / common;
    }
    
    char* result = malloc(50);
    sprintf(result, "%d/%d", numResult, denomResult);
    return result;
}

int main() {
    char expression[1000];
    fgets(expression, sizeof(expression), stdin);
    // Remove quotes and newline
    expression[strlen(expression) - 1] = '\0';
    if (expression[0] == '"') {
        memmove(expression, expression + 1, strlen(expression));
        expression[strlen(expression) - 1] = '\0';
    }
    printf("%s\n", fractionAddition(expression));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(max_value))

O(n) for parsing, O(log(max_value)) for each GCD calculation

⚡ Linearithmic

Space Complexity

O(1)

Only storing current numerator and denominator

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

782 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

Optimal: Running Sum with GCD — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler