The Score of Students Solving Math Expression

The Score of Students Solving Math Expression - Problem

Array Hash Table Math String Dynamic Programming Stack Memoization Hard

You're a teacher grading math homework! 📝 You've given your elementary school students a simple arithmetic expression containing only single digits (0-9), addition (+), and multiplication (*) symbols.

Here's the catch: you taught them a specific order of operations:

First: Compute all multiplications from left to right
Then: Compute all additions from left to right

For example, with expression "3+5*2":

Correct answer: 3 + (5*2) = 3 + 10 = 13
Wrong order: (3+5) * 2 = 8 * 2 = 16

Now you need to grade the students' answers based on these rules:

5 points: Correct answer using proper order of operations
2 points: Wrong answer BUT could be obtained by applying operations in some different (but mathematically valid) order
0 points: Completely wrong answer that can't be explained by any order of operations

Goal: Return the total points earned by all students.

Input & Output

example_1.py — Basic Expression

$ Input: s = "7+3*1*2", answers = [20, 13, 42]

› Output: 7

💡 Note: Correct answer: 7+(3*1*2) = 7+6 = 13. Student with answer 13 gets 5 points. Answer 20 could come from (7+3)*1*2 = 20, so 2 points. Answer 42 is impossible with any valid parenthesization, so 0 points. Total: 5+2+0 = 7

example_2.py — Simple Addition

$ Input: s = "3+5*2", answers = [13, 0, 10, 13, 13, 16, 16]

› Output: 19

💡 Note: Correct answer: 3+(5*2) = 13. Three students got 13 (5×3=15 points). Two students got 16 from (3+5)*2 (2×2=4 points). Answers 0 and 10 are impossible (0×2=0 points). Total: 15+4+0 = 19

example_3.py — Single Number

$ Input: s = "6+0*1", answers = [6, 1, 0]

› Output: 7

💡 Note: Correct answer: 6+(0*1) = 6+0 = 6. Student with answer 6 gets 5 points. Answer 0 could come from (6+0)*1 = 0, so 2 points. Answer 1 is impossible, so 0 points. Total: 5+2+0 = 7

Constraints

3 ≤ s.length ≤ 31
s consists of digits and operators '+' and '*' only
All the integer operands in the expression are in the range [0, 9]
1 ≤ answers.length ≤ 10⁴
0 ≤ answers[i] ≤ 1000
The expression is guaranteed to be valid (alternating numbers and operators)

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

This problem combines expression evaluation with dynamic programming. The optimal approach uses interval DP with memoization to efficiently compute all possible results from different operator precedences, similar to the "Different Ways to Add Parentheses" problem. We first calculate the correct answer using the given rules (multiply first, then add), then use DP to find all possible results from different parenthesizations, and finally grade each student's answer accordingly.

Common Approaches

✓ Brute Force (Generate All Parenthesizations)

⏱️ Time: O(n * 4^n) Space: O(4^n)

For each student answer, recursively generate all possible ways to evaluate the expression by trying different operator precedences. This involves splitting the expression at each operator and recursively evaluating the left and right parts.

Dynamic Programming with Memoization (Optimal)

⏱️ Time: O(n^3 * m) Space: O(n^2 * m)

This approach uses dynamic programming with memoization to efficiently compute all possible results from different ways of parenthesizing the expression. We solve subproblems once and reuse the results, similar to the matrix chain multiplication problem.

Brute Force (Generate All Parenthesizations) — Algorithm Steps

Parse the expression to extract numbers and operators
For each student answer, check if it equals the correct answer (5 points)
If not correct, recursively generate all possible evaluation results
At each recursive step, try splitting at every operator position
If student's answer matches any possible result, award 2 points
Otherwise, award 0 points

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Expression

Split expression '3+5*2' into numbers [3,5,2] and operators [+,*]

Generate Trees

Create all possible binary trees with different operator precedences

Evaluate Trees

Compute result for each tree: (3+5)*2=16, 3+(5*2)=13

Grade Answers

Compare student answers against correct (13) and possible (16) results

Code -

solution.c — C

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

#define MAX_RESULTS 1000
#define MAX_EXPR_LEN 100
#define MAX_MEMO 500

typedef struct {
    int values[MAX_RESULTS];
    int count;
} ResultSet;

typedef struct {
    char expr[MAX_EXPR_LEN];
    ResultSet results;
    bool valid;
} MemoEntry;

MemoEntry memo[MAX_MEMO];
int memo_count = 0;

ResultSet* findMemo(const char* expr) {
    for (int i = 0; i < memo_count; i++) {
        if (memo[i].valid && strcmp(memo[i].expr, expr) == 0) {
            return &memo[i].results;
        }
    }
    return NULL;
}

void addToSet(ResultSet* set, int value) {
    for (int i = 0; i < set->count; i++) {
        if (set->values[i] == value) return;
    }
    if (set->count < MAX_RESULTS) {
        set->values[set->count++] = value;
    }
}

ResultSet evaluateAllWays(const char* expr) {
    ResultSet* cached = findMemo(expr);
    if (cached) return *cached;
    
    ResultSet results = {0};
    int len = strlen(expr);
    
    // Base case: single digit
    if (len == 1 && expr[0] >= '0' && expr[0] <= '9') {
        results.values[0] = expr[0] - '0';
        results.count = 1;
        
        if (memo_count < MAX_MEMO) {
            strcpy(memo[memo_count].expr, expr);
            memo[memo_count].results = results;
            memo[memo_count].valid = true;
            memo_count++;
        }
        return results;
    }
    
    // Try splitting at each operator
    for (int i = 1; i < len; i += 2) {
        char operator = expr[i];
        
        char leftExpr[MAX_EXPR_LEN], rightExpr[MAX_EXPR_LEN];
        strncpy(leftExpr, expr, i);
        leftExpr[i] = '\0';
        strcpy(rightExpr, expr + i + 1);
        
        ResultSet leftResults = evaluateAllWays(leftExpr);
        ResultSet rightResults = evaluateAllWays(rightExpr);
        
        for (int l = 0; l < leftResults.count; l++) {
            for (int r = 0; r < rightResults.count; r++) {
                int result;
                if (operator == '+') {
                    result = leftResults.values[l] + rightResults.values[r];
                } else {
                    result = leftResults.values[l] * rightResults.values[r];
                }
                
                if (result <= 1000) {
                    addToSet(&results, result);
                }
            }
        }
    }
    
    if (memo_count < MAX_MEMO) {
        strcpy(memo[memo_count].expr, expr);
        memo[memo_count].results = results;
        memo[memo_count].valid = true;
        memo_count++;
    }
    
    return results;
}

int evaluateCorrect(const char* s) {
    char expr[MAX_EXPR_LEN];
    strcpy(expr, s);
    
    // Parse and handle multiplications first
    int nums[50];
    int nums_count = 0;
    int current_product = expr[0] - '0';
    
    for (int i = 1; i < strlen(expr); i += 2) {
        if (expr[i] == '*') {
            current_product *= (expr[i+1] - '0');
        } else { // '+'
            nums[nums_count++] = current_product;
            current_product = expr[i+1] - '0';
        }
    }
    nums[nums_count++] = current_product;
    
    int total = 0;
    for (int i = 0; i < nums_count; i++) {
        total += nums[i];
    }
    return total;
}

int scoreOfStudents(char* s, int* answers, int answersSize) {
    memo_count = 0; // Reset memoization
    
    int correctAnswer = evaluateCorrect(s);
    ResultSet allPossible = evaluateAllWays(s);
    
    int totalScore = 0;
    for (int i = 0; i < answersSize; i++) {
        if (answers[i] == correctAnswer) {
            totalScore += 5;
        } else {
            bool found = false;
            for (int j = 0; j < allPossible.count; j++) {
                if (allPossible.values[j] == answers[i]) {
                    found = true;
                    break;
                }
            }
            if (found) {
                totalScore += 2;
            }
        }
    }
    
    return totalScore;
}

int main() {
    char s[100];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char answersLine[1000];
    fgets(answersLine, sizeof(answersLine), stdin);
    answersLine[strcspn(answersLine, "\n")] = 0;
    
    int answers[10000];
    int answersSize = 0;
    
    if (strlen(answersLine) > 0) {
        char* token = strtok(answersLine, ",");
        while (token != NULL) {
            answers[answersSize++] = atoi(token);
            token = strtok(NULL, ",");
        }
    }
    
    printf("%d\n", scoreOfStudents(s, answers, answersSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 4^n)

For each of n students, we generate all possible parenthesizations which is the nth Catalan number, approximately 4^n

⚠ Quadratic Growth

Space Complexity

O(4^n)

Recursive call stack depth and storage for all possible results

⚠ Quadratic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force (Generate All Parenthesizations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler