Solve the Equation - Practice Coding Problems

Solve the Equation - Problem

Solve a given equation and return the value of 'x' in the form of a string "x=#value".

The equation contains only '+' and '-' operations, the variable 'x' and its coefficient.

Return cases:

"No solution" if there is no solution for the equation
"Infinite solutions" if there are infinite solutions for the equation
"x=#value" if there is exactly one solution (where #value is an integer)

Input & Output

Example 1 — Basic Case

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

› Output: "x=2"

💡 Note: Left side: x + x + 5 - 3 = 2x + 2. Right side: 6 + x - 2 = x + 4. Moving terms: 2x - x = 4 - 2, so x = 2.

Example 2 — No Solution

$ Input: equation = "x=x"

› Output: "Infinite solutions"

💡 Note: Both sides are identical (x = x), so any value of x satisfies the equation.

Example 3 — Contradictory

$ Input: equation = "2x=x"

› Output: "x=0"

💡 Note: Moving terms: 2x - x = 0, so x = 0.

Constraints

The equation contains only '+', '-' operation, the variable 'x' and its coefficient
There is exactly one '=' in the equation
The equation is valid and follows the format described

Visualization

Tap to expand

Understanding the Visualization

Input

Linear equation like x+5-3+x=6+x-2

Parse

Extract coefficients and constants from both sides

Output

x=value, No solution, or Infinite solutions

Key Takeaway

🎯 Key Insight: Transform the equation into ax = b form by collecting like terms, then analyze the coefficients to determine if there's one solution, no solution, or infinite solutions.

Asked in

G Google 15 a Amazon 12

The key insight is to parse both sides of the equation and collect coefficients of x and constants separately. Move all x terms to the left side and constants to the right side to form ax = b, then solve based on the value of coefficient a. Best approach uses string parsing with O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ String Parsing with Sign Tracking	O(n)	O(1)	Parse equation by splitting on operators and tracking signs efficiently
Character-by-Character Parsing	O(n)	O(1)	Parse each character individually to extract coefficients and constants

String Parsing with Sign Tracking — Algorithm Steps

Split equation at '=' sign
Parse each side by handling +/- signs
Accumulate x coefficients and constants
Solve linear equation ax = b

Visualization

Tap to expand

Step-by-Step Walkthrough

Split & Tokenize

Extract terms: [+x, +5, -3, +x] and [+6, +x, -2]

Classify Terms

Separate x coefficients from constants

Solve

ax = b → 1x = 2 → x = 2

Code -

solution.c — C

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

void evaluate(char* expr, int sign, int* xCoeff, int* constant) {
    *xCoeff = 0;
    *constant = 0;
    
    int len = strlen(expr);
    int i = 0;
    int currentSign = 1;
    
    // Handle first character if no sign
    if (expr[0] != '+' && expr[0] != '-') {
        currentSign = 1;
    } else {
        currentSign = expr[0] == '+' ? 1 : -1;
        i = 1;
    }
    
    while (i < len) {
        if (expr[i] == '+' || expr[i] == '-') {
            currentSign = expr[i] == '+' ? 1 : -1;
            i++;
            continue;
        }
        
        int num = 0;
        int hasDigits = 0;
        
        // Parse number
        while (i < len && expr[i] >= '0' && expr[i] <= '9') {
            num = num * 10 + (expr[i] - '0');
            hasDigits = 1;
            i++;
        }
        
        if (i < len && expr[i] == 'x') {
            // This is x coefficient
            int coeff = hasDigits ? num : 1;
            *xCoeff += sign * currentSign * coeff;
            i++;
        } else {
            // This is constant
            *constant += sign * currentSign * num;
        }
        
        // Skip to next term
        while (i < len && expr[i] != '+' && expr[i] != '-') {
            i++;
        }
    }
}

char* solution(char* equation) {
    static char result[100];
    char* equalPos = strchr(equation, '=');
    *equalPos = '\0';
    
    char* leftExpr = equation;
    char* rightExpr = equalPos + 1;
    
    int leftX, leftConst, rightX, rightConst;
    evaluate(leftExpr, 1, &leftX, &leftConst);
    evaluate(rightExpr, -1, &rightX, &rightConst);
    
    // Combine: ax = b
    int a = leftX + rightX;
    int b = -(leftConst + rightConst);
    
    if (a == 0) {
        if (b == 0) {
            strcpy(result, "Infinite solutions");
        } else {
            strcpy(result, "No solution");
        }
    } else {
        sprintf(result, "x=%d", b / a);
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through equation string processing each character once

✓ Linear Growth

Space Complexity

O(1)

Only storing integer coefficients and constants

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

856 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 Sign Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler