From ffd03befc98a50b651fb5c117ca96201142536a7 Mon Sep 17 00:00:00 2001
From: JoshdRod <joshrod1089@gmail.com>
Date: Mon, 24 Nov 2025 20:06:40 +0000
Subject: [PATCH 1/4] <feat> Added positive expression evaluator

Cannot handle negative coefficients for expressions.
---
 src/script.js | 68 ++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 59 insertions(+), 9 deletions(-)

diff --git a/src/script.js b/src/script.js
index cdd100b..4dcbd88 100644
--- a/src/script.js
+++ b/src/script.js
@@ -45,20 +45,70 @@ function checkValidInputExpression() {
 // RETURNS: (enum?) colour (red, yellow, green)
 function evaluateInputExpression(answer) {
 
-    let expressionDict = expressionToDict(answer)
-    let colour = determineColourFromDict(expressionDict);
-    
-    return colour;
+	let expressionDict = expressionToDict(answer)
+	let colour = determineColourFromDict(expressionDict);
+
+	return colour;
 }
 			
+//TODO: Make correctly handle negative terms
 // Cuts expression into a terms:coeffs dictionary	
 // INPUT: str some valid maths expression
 // RETURNS: (dict) of terms:coeff values
 // e.g: x ^ 2 + 3 sin(4x) - 2 sin(x)cos(x) - x
 // -> {x^2 : 1, sin(4x) : 3, sin(x)cos(x) : -2, x : -1}
-function expressionToDict(expresssion) {
-    rawExpresssion = expression.replaceAll(" ", "");
-    
-    // Strip all terms from raw expression and add to dict
-    return "";
+function expressionToDict(expression) {
+	let rawExp = expression.replaceAll(" ", "");
+	let i = 0;
+	let decomposedExpression = {};
+	while (i < rawExp.length)
+	{
+	    nextTerm = termToDict(rawExp, i);
+	    decomposedExpression[nextTerm.term] = nextTerm.coeff;
+	    i = nextTerm.i;
+	}
+	return decomposedExpression;
+}
+
+// "3x^2" -> [x^2, 3]
+function termToDict(str, i) {
+	let startTerm = -1;
+	let endTerm = str.length;
+	// j = start of term
+	for (let j = i; j < str.length; j++)
+	{
+	    if (isNaN(str[j]))
+	    {
+		startTerm = j;
+		break;
+	    }
+	}
+
+	let bracketCount = 0;
+
+	// k = end of term
+	for (let k = startTerm; k < str.length; k++)
+	{
+	    if (str[k] == '(')
+	    {
+		bracketCount++;
+	    }
+	    else if (str[k] == ')')
+	    {
+		bracketCount--; // FIXME: Won't work for brackted terms - e.g (10x + 2x^2)^1/2'            
+	    }
+	    if (str[k] == '+' || str[k] == '-')
+	    {
+		if (bracketCount == 0)
+		{
+		    endTerm = k;
+		    break;
+		}
+	    }
+  	}
+        return {
+	    coeff : str.slice(i, startTerm),
+	    term: str.slice(startTerm, endTerm),
+	    i: endTerm + 1
+	   };
 }

From 7bd92f15a213447d71880a4440e4d16e7ef57d50 Mon Sep 17 00:00:00 2001
From: JoshdRod <joshrod1089@gmail.com>
Date: Mon, 24 Nov 2025 20:33:44 +0000
Subject: [PATCH 2/4] <fix> Added support for converting negative and solo (1)
 terms to dict

---
 src/script.js | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/src/script.js b/src/script.js
index 4dcbd88..fa4b270 100644
--- a/src/script.js
+++ b/src/script.js
@@ -74,6 +74,19 @@ function expressionToDict(expression) {
 function termToDict(str, i) {
 	let startTerm = -1;
 	let endTerm = str.length;
+
+	// Deal with first part of expression. If +, skip it. If -, take note and move on one.
+	let isNegative = false;
+	if (str[i] == '+')
+	{
+		i++;
+	}
+	else if (str[i] == '-')
+	{
+		i++;
+		isNegative = true;
+	}
+
 	// j = start of term
 	for (let j = i; j < str.length; j++)
 	{
@@ -106,9 +119,19 @@ function termToDict(str, i) {
 		}
 	    }
   	}
+	// Compose coeff
+	let coefficient = str.slice(i, startTerm);
+	if (coefficient == '')
+	{
+		coefficient = '1';
+	}
+	if (isNegative)
+	{
+		coefficient = '-' + coefficient;
+	}
         return {
-	    coeff : str.slice(i, startTerm),
+	    coeff : coefficient,
 	    term: str.slice(startTerm, endTerm),
-	    i: endTerm + 1
+	    i: endTerm
 	   };
 }

From c087cb7c4de1c9a471d9fb7de87a87ca0b32f71c Mon Sep 17 00:00:00 2001
From: JoshdRod <joshrod1089@gmail.com>
Date: Mon, 24 Nov 2025 20:39:51 +0000
Subject: [PATCH 3/4] <style> Beautifed script.js

---
 src/script.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/script.js b/src/script.js
index fa4b270..13065c0 100644
--- a/src/script.js
+++ b/src/script.js
@@ -133,5 +133,5 @@ function termToDict(str, i) {
 	    coeff : coefficient,
 	    term: str.slice(startTerm, endTerm),
 	    i: endTerm
-	   };
+	};
 }

From 74e4a8bc48d52a6825a7f9bbef76e1ef5910803d Mon Sep 17 00:00:00 2001
From: JoshdRod <joshrod1089@gmail.com>
Date: Mon, 24 Nov 2025 21:34:08 +0000
Subject: [PATCH 4/4] <feat> Added background colour change when score input

Red = Incorrect terms
Yellow = Correct terms listed, but incorrect coefficients
Green = Correct answer
---
 src/script.js | 60 +++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 51 insertions(+), 9 deletions(-)

diff --git a/src/script.js b/src/script.js
index 13065c0..ae539d1 100644
--- a/src/script.js
+++ b/src/script.js
@@ -1,3 +1,6 @@
+// TODO: Eventually, put this in a separate file
+let SOLUTION = expressionToDict("1/3 x^3 + 3/2 x^2 - 2x");
+
 let answerBox = document.getElementById("answerBox");
 			
 let response1 = document.getElementById("response1");
@@ -12,23 +15,24 @@ let responseCount = 0;
 function handleAnswerInputChange() {
 	if (event.key == "Enter")
 	{
-		/* TODO
-		   checkValidInputExpression();
-		   evaluateInputExpression(answerBox.value);
-		*/
+		let color = evaluateInputExpression(answerBox.value);
 		switch (responseCount)
 		{
 		       case 0:
 			   response1.innerText = answerBox.value;
+			   response1.style.backgroundColor = color;
 			   break;
 		       case 1:
 			   response2.innerText = answerBox.value;
+			   response2.style.backgroundColor = color;
 			   break;
 		       case 2:
 			   response3.innerText = answerBox.value;
+			   response3.style.backgroundColor = color;
 			   break;
 		       case 3:
 			   response4.innerText = answerBox.value;
+			   response4.style.backgroundColor = color;
 			   break;
 		}
 		responseCount++;
@@ -45,13 +49,26 @@ function checkValidInputExpression() {
 // RETURNS: (enum?) colour (red, yellow, green)
 function evaluateInputExpression(answer) {
 
-	let expressionDict = expressionToDict(answer)
-	let colour = determineColourFromDict(expressionDict);
+	let expressionDict = expressionToDict(answer);
 
-	return colour;
+	// Incorrect terms = red
+	if (!isEqual(Object.keys(expressionDict), Object.keys(SOLUTION)))
+	{
+		return "red";
+	}
+
+	// Correct terms, but incorrect coeffs = yellow
+	let terms = Object.keys(expressionDict);
+	for (const term of terms)
+	{
+		if (expressionDict[term] != SOLUTION[term])
+		{
+			return "yellow";
+		}
+	}
+	return "green";
 }
 			
-//TODO: Make correctly handle negative terms
 // Cuts expression into a terms:coeffs dictionary	
 // INPUT: str some valid maths expression
 // RETURNS: (dict) of terms:coeff values
@@ -90,7 +107,7 @@ function termToDict(str, i) {
 	// j = start of term
 	for (let j = i; j < str.length; j++)
 	{
-	    if (isNaN(str[j]))
+	    if (isNaN(str[j]) && str[j] != '/')
 	    {
 		startTerm = j;
 		break;
@@ -135,3 +152,28 @@ function termToDict(str, i) {
 	    i: endTerm
 	};
 }
+
+// Checks if 2 arrays are equal
+function isEqual(a, b)
+{
+	// Sort both arrays
+	a = a.sort();
+	b = b.sort();
+
+	// 1. Check same length
+	if (a.length != b.length)
+	{
+		return false;
+	}
+
+	// 2. Check same content
+	for (let i = 0; i < a.length; i++)
+	{
+		if (a[i] != b[i])
+		{
+			return false;
+		}
+	}
+
+	return true;
+}