How to rate to difficulty of simple algebra operations

Question

I'm writing a simple app to help my daughter practice basic Algebra (first grade). I would like to assign a score to each response depending on the difficulty of the operation, where 2+2 is worth less than 12-7, for example. Do you know of any existing algorithm I can look up and adapt to my needs?

EDIT

• if you want to see the app https://algebro.herokuapp.com
• if you want to see the code https://gitlab.com/etozzato/algebro

**EDIT ← **

trying to make the question more specific ;)

given two integers and a basic algebraic operation

algorithm input: int a,b and string operation

algorithm output: float difficulty

→ What are the factors that can help inferring a difficult coefficient?

• I would surely look at the input numbers, where their distance can be significant in determining the complexity of the operation. 10 + 1 is clearly easier than 7 + 5 because (when not memorized and instantly responded) it takes longer counting time;
• As an amendment to the previous statement, common/simple arguments should decrease the complexity of the operation: 0 or 10 are a good example;

Answer 1

I don't know of any algorithm to find the "difficulty" of an equation but if I had more time, I might try to play around with something like this... Even though it is for reading, the concept might be adaptable to arithmetic.

Anyway here is a super silly post-midnight crack at something that might work with some tweaking for extremely basic arithmetic. You can tweak the factors/weights but this might get you started. Good luck!

function get_difficulty (eq) {
    var difficulty = 0;
    var settings = {
        terms_factor : 3, //Multiply by the number of terms in an equation
        digits_factor : 2, //Multiply by the number of digits in each term
        negative_weight : 2, //Add this if subtracting two numbers in the equation yields a negative number

        operations : {
            "+" : 1,
            "-" : 2,
            "*" : 4,
            "/" : 6,

            "=" : 0
        }
    };

    eq += "=";

    var ptr = 0;
    var terms = 0;
    var prev_term = null;
    var len = eq.length;
    var stack = [ ];

    var is_numeric = function (n) {
        return /\d+/.test (n); //Not a brilliant way but works for basic arithmetic
    };

    while (ptr < len) {
        var tok = eq [ptr];

        if (tok !== " " && tok !== "(" && tok !== ")") {
            if (is_numeric (tok)) {
                stack.push (tok);   
            } else if (tok in settings.operations) {
                var curr_term = parseInt (stack.join (""));
                if (prev_term !== null && curr_term > prev_term && ["-", "="].indexOf (tok) !== -1) {
                    difficulty += settings.negative_weight;
                }

                difficulty += stack.length * settings.digits_factor;
                prev_term = curr_term;
                stack = [ ];
                terms++;

                difficulty += settings.operations [tok];
            } else {
                console.log ("Unknown token: " + tok);   
            }
        }

        ptr++;
    }

    difficulty += terms * settings.terms_factor;

    return difficulty;
}


console.log (get_difficulty (" 2 + 2 ")); //11
console.log (get_difficulty (" 12 - 7 ")); //14
console.log (get_difficulty (" 7 - 12 ")); //16
console.log (get_difficulty (" 5 - 5 ")); //12 
console.log (get_difficulty (" 5 - 1205 ")); //20
console.log (get_difficulty (" 5 - 1205 * 35 ")); //29
console.log (get_difficulty (" 5 * 40 ")); //18
console.log (get_difficulty (" 102 - 5 / 13 + 32 ")); //39
console.log (get_difficulty (" 100 - 100 ")); //20
console.log (get_difficulty (" 32 - 12 ")); //16
console.log (get_difficulty (" 12 - 32 ")); //18