Solve the Equation - Practice Coding Problems

Solve the Equation - Problem

You're given a linear equation as a string containing only +, - operations, the variable x, and integer coefficients. Your task is to solve for x and return the result in a specific format.

Goal: Parse and solve the equation to find the value of x.

Return Format:

"x=#value" - if there's exactly one solution (where #value is an integer)
"No solution" - if the equation has no solution (e.g., 0 = 5)
"Infinite solutions" - if any value of x satisfies the equation (e.g., 0 = 0)

Examples:

"x+5-3+x=6+x-2" → "x=2"
"x=x" → "Infinite solutions"
"2x=x" → "x=0"

Input & Output

example_1.py — Standard Linear Equation

$ Input: equation = "x+5-3+x=6+x-2"

› Output: "x=2"

💡 Note: Simplifying left side: x + 5 - 3 + x = 2x + 2. Simplifying right side: 6 + x - 2 = x + 4. So we have 2x + 2 = x + 4, which gives us x = 2.

example_2.py — Infinite Solutions

$ Input: equation = "x=x"

› Output: "Infinite solutions"

💡 Note: After simplification, we get 0x = 0, which means 0 = 0. This is always true regardless of the value of x, so there are infinite solutions.

example_3.py — No Solution

$ Input: equation = "2x=x"

› Output: "x=0"

💡 Note: Simplifying: 2x - x = 0, so x = 0. This has exactly one solution.

Constraints

3 ≤ equation.length ≤ 1000
equation has exactly one '='
equation consists of integers with an absolute value in the range [0, 100] without any leading zeros, and the variable 'x'
The coefficients and constants will always result in integer solutions when exactly one solution exists

Visualization

Tap to expand

Understanding the Visualization

Set Up Scale

Place all terms on their respective sides of the balance scale

Group Similar Items

Collect all x terms together and all number terms together on each side

Move Terms

Move all x terms to one side and all constants to the other side

Find Balance

Calculate the value of x that makes both sides equal

Key Takeaway

🎯 Key Insight: Transform the equation parsing problem into coefficient collection - group like terms and solve the resulting simple linear equation ax = b.

Asked in

⊞ Microsoft 35 a Amazon 28 G Google 22 f Meta 15

The optimal approach uses a single-pass parser to process the equation string character by character, maintaining separate counters for x coefficients and constants on each side. By treating this as a state machine, we can parse and solve the equation in O(n) time and O(1) space, making it highly efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ String Parsing with Multiple Passes	O(n²)	O(n)	Parse the equation character by character with multiple passes to extract terms
Single Pass Linear Parser (Optimal)	O(n)	O(1)	Parse and solve the equation in a single pass through the string

String Parsing with Multiple Passes — Algorithm Steps

Split equation by '=' to get left and right sides
For each side, iterate through characters to identify terms
Parse each term to extract coefficient and check if it contains 'x'
Sum up all x coefficients and constants separately
Solve the final equation ax = b

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Equation

First pass: Split by '=' to get left and right sides

Parse Terms

Second pass: Identify individual terms on each side

Extract Coefficients

Third pass: Parse each term to get coefficients and constants

Solve

Final calculation: Solve the equation ax = b

Code -

solution.c — C

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

typedef struct {
    int xCoeff;
    int constant;
} ParseResult;

ParseResult parseSide(char* side) {
    ParseResult result = {0, 0};
    int sign = 1;
    char num[100] = "";
    int numLen = 0;
    
    for (int i = 0; i < strlen(side); i++) {
        char c = side[i];
        if (c == '+' || c == '-') {
            if (numLen > 0) {
                num[numLen] = '\0';
                if (strchr(num, 'x') != NULL) {
                    char* xPos = strchr(num, 'x');
                    *xPos = '\0';
                    if (strlen(num) == 0) {
                        result.xCoeff += sign * 1;
                    } else {
                        result.xCoeff += sign * atoi(num);
                    }
                } else {
                    result.constant += sign * atoi(num);
                }
                numLen = 0;
            }
            sign = (c == '+') ? 1 : -1;
        } else {
            num[numLen++] = c;
        }
    }
    
    if (numLen > 0) {
        num[numLen] = '\0';
        if (strchr(num, 'x') != NULL) {
            char* xPos = strchr(num, 'x');
            *xPos = '\0';
            if (strlen(num) == 0) {
                result.xCoeff += sign * 1;
            } else {
                result.xCoeff += sign * atoi(num);
            }
        } else {
            result.constant += sign * atoi(num);
        }
    }
    
    return result;
}

char* solveEquation(char* equation) {
    char* equalPos = strchr(equation, '=');
    *equalPos = '\0';
    char* left = equation;
    char* right = equalPos + 1;
    
    ParseResult leftResult = parseSide(left);
    ParseResult rightResult = parseSide(right);
    
    int finalXCoeff = leftResult.xCoeff - rightResult.xCoeff;
    int finalConst = rightResult.constant - leftResult.constant;
    
    static char result[50];
    if (finalXCoeff == 0) {
        if (finalConst == 0) {
            strcpy(result, "Infinite solutions");
        } else {
            strcpy(result, "No solution");
        }
    } else {
        sprintf(result, "x=%d", finalConst / finalXCoeff);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple passes through the string of length n, with string operations in each pass

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for intermediate lists and parsed terms

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

987 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

String Parsing with Multiple Passes — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler