Two problem generators similar in structure: "Find Coefficient of Term" and "Evaluate Probability of Choice" Generators

dynamic/generators/comp2804/coefficient_of_term/main.py

@@ -0,0 +1,138 @@
+""" What is the coefficient of x^a * y^b for the expansion of (cx^s+dy^t)^n ? """
+""" This generator creates a randomized problem of figure out the coefficient
+of a specific form x^{a}y^{b} for a given (cx^s+dy^t)^n """
+
+import random
+
+
+def generate_question():
+
+    s = random.randint(1, 5)
+    t = random.randint(1, 5)
+
+    multiply_s = random.randint(5, 15)
+    multiply_t = random.randint(5, 15)
+
+    a = s * multiply_s
+    b = t * multiply_t
+
+    c = random.randint(2, 7)
+    d = random.randint(2, 7)
+
+    n = multiply_s + multiply_t
+
+    question_body = (
+        "What is the coefficient of the term $x^{"
+        + str(a)
+        + "}y^{"
+        + str(b)
+        + "}$, in the expansion of "
+        + "$("
+        + str(c)
+        + " \\cdot x^{"
+        + str(s)
+        + "} + "
+        + str(d)
+        + " \\cdot y^{"
+        + str(t)
+        + "})"
+        + "^{"
+        + str(n)
+        + "}$"
+    )
+
+    answer = (
+        "$\\binom{"
+        + str(n)
+        + "}{"
+        + str(multiply_s)
+        + "} \\cdot "
+        + str(c)
+        + "^{"
+        + str(multiply_s)
+        + "} \\cdot "
+        + str(d)
+        + "^{"
+        + str(multiply_t)
+        + "}$"
+    )
+    varied_answer_1 = (
+        "$\\binom{"
+        + str(n)
+        + "}{"
+        + str(multiply_s)
+        + "} \\cdot "
+        + str(c)
+        + "^{"
+        + str(a)
+        + "} \\cdot "
+        + str(d)
+        + "^{"
+        + str(b)
+        + "}$"
+    )
+    varied_answer_2 = (
+        "$\\binom{"
+        + str(n)
+        + "}{"
+        + str(s)
+        + "} \\cdot "
+        + str(c)
+        + "^{"
+        + str(s)
+        + "} \\cdot "
+        + str(d)
+        + "^{"
+        + str(t)
+        + "}$"
+    )
+    varied_answer_3 = (
+        "$\\binom{"
+        + str(n)
+        + "}{"
+        + str(s)
+        + "} \\cdot "
+        + str(c)
+        + "^{"
+        + str(multiply_s)
+        + "} \\cdot "
+        + str(d)
+        + "^{"
+        + str(multiply_t)
+        + "}$"
+    )
+
+    # we will not randomize the order of these choices because that is handled in ruby side.
+    # random.shuffle(answerchoices)
+    return {
+        "title": "coefficient_of_term",
+        "body": question_body,
+        "bodyFormat": "mathjax",
+        "pseudocode": "",
+        "multipleChoiceAnswers": [
+            {
+                "body": answer,
+                "bodyFormat": "mathjax",
+                "correct": "true",
+            },
+            {
+                "body": varied_answer_1,
+                "bodyFormat": "mathjax",
+                "correct": "false",
+            },
+            {
+                "body": varied_answer_2,
+                "bodyFormat": "mathjax",
+                "correct": "false",
+            },
+            {
+                "body": varied_answer_3,
+                "bodyFormat": "mathjax",
+                "correct": "false",
+            },
+        ],
+    }
+
+
+def call():
+    return generate_question()

dynamic/generators/comp2804/coefficient_of_term/test_main.py

@@ -0,0 +1,11 @@
+from .test_out import test_output
+
+# import test_out
+import sys
+
+# import main as main
+from .main import call
+
+
+def test():
+    assert test_output(call())

dynamic/generators/comp2804/coefficient_of_term/test_out.py

@@ -0,0 +1,110 @@
+""" This file contains tools for test_main.py to use. """
+
+
+def check_mathjax_compatible(output_string):
+    # for now, checks that the answers start and end with the "$" to be conventionally compatible with mathjax
+    # could change the conditions to accommodate more types of mathjax compatible examples ...
+    return output_string[0] == "$" and output_string[len(output_string) - 1] == "$"
+
+
+# returns True if the output dictionary is a valid output for the "ruby side" interpretation
+def test_output(cache):
+
+    bodyFormat_options = ["text", "mathjax"]  # can add more options in the future
+
+    if type(cache) != type({}):
+        return False
+    else:
+
+        answer_type = {
+            "title": "",
+            "body": "",
+            "bodyFormat": "mathjax",  # or "text"
+            "pseudocode": "",
+            "multipleChoiceAnswers": [
+                {
+                    "body": "",
+                    "bodyFormat": "mathjax",
+                    "correct": "true",
+                },
+                {
+                    "body": "",
+                    "bodyFormat": "mathjax",
+                    "correct": "false",
+                },
+                {
+                    "body": "",
+                    "bodyFormat": "mathjax",
+                    "correct": "false",
+                },
+                {
+                    "body": "",
+                    "bodyFormat": "mathjax",
+                    "correct": "false",
+                },
+            ],
+        }
+
+        keys_list = list(
+            answer_type.keys()
+        )  # the list of keys from the template answer_type dictionary
+        out_list = list(
+            cache.keys()
+        )  # the list of keys from the output dictionary that we are testing
+
+        # checks if the output dictionary that is being tested has the correct type of keys as in the answer_type
+        for i in range(len(out_list)):
+            if not out_list[i] in keys_list:
+                return False
+
+        # if there is "title" key in the ouput dictionary, check that the item of "title" is string type
+        if "title" in out_list:
+            if not type(cache["title"]) == type(""):
+                return False
+
+        # check that the item of the key, "body", is string type
+        if not type(cache["body"]) == type(""):
+            return False
+
+        # checks "bodyFormat" key has the correct item types available as in the bodyFormat_options
+        if not (cache["bodyFormat"] in bodyFormat_options):
+            return False
+
+        # if there is "pseudocode" key in the output dictionary, check that the item of "pseudocode" is a string type
+        if "pseudocode" in out_list:
+            if not type(cache["pseudocode"]) == type(""):
+                return False
+
+        # tests the item of "multipleChoiceAnswers" key
+        mult_choice_answers = cache[keys_list[4]]
+        if len(mult_choice_answers) != 4:
+            return False
+        else:
+
+            for i in range(0, 4):
+
+                if type(mult_choice_answers[i]) != type({}):
+                    return False
+                elif len(mult_choice_answers[i]) != 3:
+                    return False
+
+                for j in range(len(list(mult_choice_answers[i].keys()))):
+                    if not (
+                        list(mult_choice_answers[i].keys())[j]
+                        in ["body", "bodyFormat", "correct"]
+                    ):
+                        return False
+
+                if not check_mathjax_compatible(mult_choice_answers[i]["body"]):
+                    return False
+
+                if not (mult_choice_answers[i]["bodyFormat"] in bodyFormat_options):
+                    return False
+
+                if not (
+                    mult_choice_answers[i]["correct"] == "true"
+                    or mult_choice_answers[i]["correct"] == "false"
+                ):
+                    return False
+
+        return True