diff --git a/src/script.js b/src/script.js
index cdd100b..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,10 +49,24 @@ 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);
+
+	// 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";
 }
 			
 // Cuts expression into a terms:coeffs dictionary	
@@ -56,9 +74,106 @@ function evaluateInputExpression(answer) {
 // 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;
+
+	// 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++)
+	{
+	    if (isNaN(str[j]) && 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;
+		}
+	    }
+  	}
+	// Compose coeff
+	let coefficient = str.slice(i, startTerm);
+	if (coefficient == '')
+	{
+		coefficient = '1';
+	}
+	if (isNegative)
+	{
+		coefficient = '-' + coefficient;
+	}
+        return {
+	    coeff : coefficient,
+	    term: str.slice(startTerm, endTerm),
+	    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;
 }