Basic Calculator IV

Basic Calculator IV - Problem

Given an expression such as expression = "e + 8 - a + 5" and an evaluation map such as {"e": 1} (given in terms of evalvars = ["e"] and evalints = [1]), return a list of tokens representing the simplified expression, such as ["-1*a","14"].

An expression alternates chunks and symbols, with a space separating each chunk and symbol. A chunk is either an expression in parentheses, a variable, or a non-negative integer. A variable is a string of lowercase letters (not including digits).

Expressions are evaluated in the usual order: brackets first, then multiplication, then addition and subtraction.

The format of the output is as follows:

For each term of free variables with a non-zero coefficient, we write the free variables within a term in sorted order lexicographically
Terms have degrees equal to the number of free variables being multiplied, counting multiplicity
We write the largest degree terms of our answer first, breaking ties by lexicographic order ignoring the leading coefficient
The leading coefficient is placed directly to the left with an asterisk separating it from the variables
A leading coefficient of 1 is still printed
Terms with coefficient 0 are not included

Input & Output

Example 1 — Basic Expression with Substitution

$ Input: expression = "e + 8 - a + 5", evalvars = ["e"], evalints = [1]

› Output: ["-1*a","14"]

💡 Note: Substitute e=1: 1 + 8 - a + 5 = 14 - a. Terms sorted by degree (variables first), then lexicographically.

Example 2 — Multiplication

$ Input: expression = "e - 8 + temperature - pressure", evalvars = ["e", "temperature"], evalints = [1, 12]

› Output: ["-1*pressure","5"]

💡 Note: Substitute e=1, temperature=12: 1 - 8 + 12 - pressure = 5 - pressure

Example 3 — Complex Expression

$ Input: expression = "(e + 8) * (e - 8)", evalvars = [], evalints = []

› Output: ["-64","1*e*e"]

💡 Note: Expand (e+8)(e-8) = e² - 64. Sort by degree: e² has degree 2, constant -64 has degree 0.

Constraints

1 ≤ expression.length ≤ 250
expression consists of lowercase English letters, digits, '+', '-', '*', '(', ')', and ' '
1 ≤ evalvars.length ≤ 100
1 ≤ evalvars[i].length ≤ 20
evalvars[i] consists of lowercase English letters
-100 ≤ evalints[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 10

The key insight is to represent polynomials as maps where keys are variable combinations and values are coefficients. This enables efficient term combination and proper sorting. The optimal approach uses recursive descent parsing to handle operator precedence correctly, then formats output according to degree and lexicographic rules. Time: O(n + m log m), Space: O(m)

Common Approaches

✓ Recursive Descent Parser with Polynomial Representation

⏱️ Time: O(n + m log m) Space: O(m)

Implement a recursive descent parser that correctly handles operator precedence and parentheses. Represent polynomials as maps where keys are variable combinations and values are coefficients, enabling efficient term combination and manipulation.

String Manipulation Approach

⏱️ Time: O(n³) Space: O(n²)

Split the expression into tokens, evaluate parentheses manually, and combine terms using string operations. This approach treats the expression as a sequence of string operations without proper mathematical parsing.

Recursive Descent Parser with Polynomial Representation — Algorithm Steps

Build recursive descent parser for proper precedence
Represent polynomials as coefficient maps
Implement polynomial arithmetic operations
Format output according to sorting rules

Visualization

Tap to expand

Step-by-Step Walkthrough

Tokenize

Split expression into proper tokens with precedence rules

Parse

Use recursive descent to build polynomial representation

Format

Sort terms by degree and format output

Code -

solution.c — C

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

#define MAX_TERMS 1000
#define MAX_VARS 100
#define MAX_VAR_LEN 50

typedef struct {
    char vars[MAX_VAR_LEN];
    int coeff;
} Term;

char** tokenize(char* expr, int* tokenCount) {
    char** tokens = (char**)malloc(1000 * sizeof(char*));
    *tokenCount = 0;
    
    int i = 0, len = strlen(expr);
    while (i < len) {
        if (expr[i] == ' ') {
            i++;
        } else if (strchr("()+-*", expr[i])) {
            tokens[*tokenCount] = (char*)malloc(2 * sizeof(char));
            tokens[*tokenCount][0] = expr[i];
            tokens[*tokenCount][1] = '\0';
            (*tokenCount)++;
            i++;
        } else if (isdigit(expr[i])) {
            int start = i;
            while (i < len && isdigit(expr[i])) i++;
            tokens[*tokenCount] = (char*)malloc((i - start + 1) * sizeof(char));
            strncpy(tokens[*tokenCount], expr + start, i - start);
            tokens[*tokenCount][i - start] = '\0';
            (*tokenCount)++;
        } else if (isalpha(expr[i])) {
            int start = i;
            while (i < len && isalpha(expr[i])) i++;
            tokens[*tokenCount] = (char*)malloc((i - start + 1) * sizeof(char));
            strncpy(tokens[*tokenCount], expr + start, i - start);
            tokens[*tokenCount][i - start] = '\0';
            (*tokenCount)++;
        } else {
            i++;
        }
    }
    
    return tokens;
}

int parseArrays(char* evalvarsLine, char* evalintsLine, char** evalvars, int* evalints) {
    int size = 0;
    
    // Parse evalvars
    if (strlen(evalvarsLine) > 2) { // Not just "[]"
        char* ptr = evalvarsLine + 1; // Skip '['
        while (*ptr && *ptr != ']') {
            if (*ptr == '"') {
                ptr++; // Skip opening quote
                char* start = ptr;
                while (*ptr && *ptr != '"') ptr++;
                int len = ptr - start;
                evalvars[size] = (char*)malloc((len + 1) * sizeof(char));
                strncpy(evalvars[size], start, len);
                evalvars[size][len] = '\0';
                size++;
                if (*ptr == '"') ptr++; // Skip closing quote
            } else {
                ptr++;
            }
        }
    }
    
    // Parse evalints
    int intIdx = 0;
    if (strlen(evalintsLine) > 2) { // Not just "[]"
        char* ptr = evalintsLine + 1; // Skip '['
        while (*ptr && *ptr != ']') {
            if (isdigit(*ptr) || *ptr == '-') {
                evalints[intIdx++] = atoi(ptr);
                while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
            } else {
                ptr++;
            }
        }
    }
    
    return size;
}

char** solution(char* expression, char** evalvars, int evalvarsSize, int* evalints, int evalintsSize, int* returnSize) {
    Term terms[MAX_TERMS];
    int termCount = 0;
    
    int tokenCount;
    char** tokens = tokenize(expression, &tokenCount);
    
    int currentSign = 1;
    for (int i = 0; i < tokenCount; i++) {
        if (strcmp(tokens[i], "+") == 0) {
            currentSign = 1;
        } else if (strcmp(tokens[i], "-") == 0) {
            currentSign = -1;
        } else if (strcmp(tokens[i], "(") != 0 && strcmp(tokens[i], ")") != 0 && strcmp(tokens[i], "*") != 0) {
            if (isdigit(tokens[i][0])) {
                // Handle constant term
                int found = -1;
                for (int j = 0; j < termCount; j++) {
                    if (strlen(terms[j].vars) == 0) {
                        found = j;
                        break;
                    }
                }
                if (found == -1) {
                    strcpy(terms[termCount].vars, "");
                    terms[termCount].coeff = 0;
                    found = termCount++;
                }
                terms[found].coeff += currentSign * atoi(tokens[i]);
            } else {
                // Handle variable
                int evaluated = 0;
                for (int j = 0; j < evalvarsSize; j++) {
                    if (strcmp(tokens[i], evalvars[j]) == 0) {
                        // Variable should be evaluated to a constant
                        int found = -1;
                        for (int k = 0; k < termCount; k++) {
                            if (strlen(terms[k].vars) == 0) {
                                found = k;
                                break;
                            }
                        }
                        if (found == -1) {
                            strcpy(terms[termCount].vars, "");
                            terms[termCount].coeff = 0;
                            found = termCount++;
                        }
                        terms[found].coeff += currentSign * evalints[j];
                        evaluated = 1;
                        break;
                    }
                }
                
                if (!evaluated) {
                    // Keep as variable
                    int found = -1;
                    for (int j = 0; j < termCount; j++) {
                        if (strcmp(terms[j].vars, tokens[i]) == 0) {
                            found = j;
                            break;
                        }
                    }
                    if (found == -1) {
                        strcpy(terms[termCount].vars, tokens[i]);
                        terms[termCount].coeff = 0;
                        found = termCount++;
                    }
                    terms[found].coeff += currentSign;
                }
            }
        }
    }
    
    // Remove zero terms
    int finalCount = 0;
    for (int i = 0; i < termCount; i++) {
        if (terms[i].coeff != 0) {
            terms[finalCount++] = terms[i];
        }
    }
    
    // Sort: variables first (by lexicographic order), then constants
    for (int i = 0; i < finalCount - 1; i++) {
        for (int j = i + 1; j < finalCount; j++) {
            int isConstI = (strlen(terms[i].vars) == 0);
            int isConstJ = (strlen(terms[j].vars) == 0);
            
            if (isConstI && !isConstJ) {
                // Swap: constants should come after variables
                Term temp = terms[i];
                terms[i] = terms[j];
                terms[j] = temp;
            } else if (!isConstI && !isConstJ && strcmp(terms[i].vars, terms[j].vars) > 0) {
                // Both variables: sort lexicographically
                Term temp = terms[i];
                terms[i] = terms[j];
                terms[j] = temp;
            }
        }
    }
    
    char** result = (char**)malloc(finalCount * sizeof(char*));
    for (int i = 0; i < finalCount; i++) {
        result[i] = (char*)malloc(200 * sizeof(char));
        if (strlen(terms[i].vars) == 0) {
            sprintf(result[i], "%d", terms[i].coeff);
        } else {
            sprintf(result[i], "%d*%s", terms[i].coeff, terms[i].vars);
        }
    }
    
    // Free tokens
    for (int i = 0; i < tokenCount; i++) {
        free(tokens[i]);
    }
    free(tokens);
    
    *returnSize = finalCount;
    return result;
}

int main() {
    char expression[1000];
    fgets(expression, sizeof(expression), stdin);
    expression[strcspn(expression, "\n")] = 0;
    
    char evalvarsLine[1000];
    fgets(evalvarsLine, sizeof(evalvarsLine), stdin);
    evalvarsLine[strcspn(evalvarsLine, "\n")] = 0;
    
    char evalintsLine[1000];
    fgets(evalintsLine, sizeof(evalintsLine), stdin);
    evalintsLine[strcspn(evalintsLine, "\n")] = 0;
    
    char* evalvars[100];
    int evalints[100];
    int evalvarsSize = parseArrays(evalvarsLine, evalintsLine, evalvars, evalints);
    
    int returnSize;
    char** result = solution(expression, evalvars, evalvarsSize, evalints, evalvarsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("\"%s\"", result[i]);
        free(result[i]);
    }
    printf("]\n");
    free(result);
    
    // Free evalvars
    for (int i = 0; i < evalvarsSize; i++) {
        free(evalvars[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m log m)

O(n) to parse expression, O(m log m) to sort terms where m is number of unique terms

⚠ Quadratic Growth

Space Complexity

O(m)

Store polynomial terms in map where m is number of unique variable combinations

⚠ Quadratic Space

28.0K Views

Medium Frequency

~45 min Avg. Time

582 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

Recursive Descent Parser with Polynomial Representation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler