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

Understanding the Visualization

Parse Expression

Break down '3+5*2' into numbers and operators

Find Correct Answer

Apply taught rules: multiply first (5*2=10), then add (3+10=13)

Generate All Possibilities

Use DP to find alternative valid results: (3+5)*2=16

Grade Students

Award 5 points for correct (13), 2 points for valid alternative (16), 0 for impossible

Key Takeaway

🎯 Key Insight: Use interval dynamic programming to efficiently compute all mathematically valid results, then award partial credit for creative but correct approaches.

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

Approach	Time	Space	Notes
✓ Brute Force (Generate All Parenthesizations)	O(n * 4^n)	O(4^n)	Recursively try all possible ways to parenthesize the expression for each student answer
Dynamic Programming with Memoization (Optimal)	O(n^3 * m)	O(n^2 * m)	Use interval DP to efficiently compute all possible results, then lookup student answers

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

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

ResultSet memo[MAX_EXPR_LEN];
bool memo_initialized[MAX_EXPR_LEN] = {false};

int hash_expr(const char* expr) {
    int hash = 0;
    for (int i = 0; expr[i]; i++) {
        hash = hash * 31 + expr[i];
    }
    return abs(hash) % MAX_EXPR_LEN;
}

ResultSet evaluateAllWays(const char* expr) {
    int hash = hash_expr(expr);
    if (memo_initialized[hash]) {
        return memo[hash];
    }
    
    ResultSet results = {0};
    
    // Base case: single digit
    if (strlen(expr) == 1) {
        results.values[0] = expr[0] - '0';
        results.count = 1;
        memo[hash] = results;
        memo_initialized[hash] = true;
        return results;
    }
    
    // Try splitting at each operator
    int len = strlen(expr);
    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 && results.count < MAX_RESULTS) {
                    // Check for duplicates
                    bool found = false;
                    for (int k = 0; k < results.count; k++) {
                        if (results.values[k] == result) {
                            found = true;
                            break;
                        }
                    }
                    if (!found) {
                        results.values[results.count++] = result;
                    }
                }
            }
        }
    }
    
    memo[hash] = results;
    memo_initialized[hash] = true;
    return results;
}

int evaluateCorrect(const char* s) {
    char expr[MAX_EXPR_LEN];
    strcpy(expr, s);
    
    // First handle multiplications
    int len = strlen(expr);
    for (int i = 0; i < len; i++) {
        if (expr[i] == '*') {
            int left = expr[i-1] - '0';
            int right = expr[i+1] - '0';
            int result = left * right;
            
            // Replace the multiplication with result
            char temp[MAX_EXPR_LEN];
            strncpy(temp, expr, i-1);
            temp[i-1] = '0' + (result % 10);
            if (result >= 10) {
                temp[i] = '0' + (result / 10);
                strcpy(temp + i + 1, expr + i + 2);
            } else {
                strcpy(temp + i, expr + i + 2);
            }
            strcpy(expr, temp);
            len = strlen(expr);
            i = -1; // Restart
        }
    }
    
    // Then handle additions
    int total = 0;
    for (int i = 0; i < len; i++) {
        if (expr[i] >= '0' && expr[i] <= '9') {
            total += expr[i] - '0';
        }
    }
    
    return total;
}

int scoreOfStudents(char* s, int* answers, int answersSize) {
    // Reset memoization
    memset(memo_initialized, false, sizeof(memo_initialized));
    
    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;
}

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

✓ Linear Growth

Space Complexity

O(4^n)

Recursive call stack depth and storage for all possible results

⚡ Linearithmic 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