From b3207987f52f4573b98187fa4f51fd1487004825 Mon Sep 17 00:00:00 2001
From: Morten Hannemose <morten@hannemose.dk>
Date: Wed, 20 Sep 2023 15:06:19 +0200
Subject: [PATCH] Added Week04
---
.gitignore | 4 +-
cp/ex03/bisect.py | 13 +-
cp/ex04/__init__.py | 1 +
cp/ex04/bug.py | 37 ++++
cp/ex04/hangman.py | 70 ++++++
cp/ex04/mathematics.py | 22 ++
cp/ex04/palindrome.py | 14 ++
cp/ex04/parenthesis.py | 72 ++++++
cp/ex04/prefix.py | 28 +++
cp/project2/__init__.py | 1 +
cp/project2/project2_grade.py | 4 +
cp/project2/project2_tests.py | 206 ++++++++++++++++++
cp/project2/unitgrade_data/Hangman.pkl | Bin 0 -> 8146 bytes
.../HangmanAvailableLetters.pkl | Bin 0 -> 767 bytes
.../unitgrade_data/HangmanGuessedWord.pkl | Bin 0 -> 955 bytes
.../unitgrade_data/HangmanIsGuessed.pkl | Bin 0 -> 671 bytes
cp/project2/unitgrade_data/TestBisect.pkl | Bin 0 -> 3222 bytes
.../unitgrade_data/TestIsThereARoot.pkl | Bin 0 -> 1971 bytes
.../TestTheFunctionToBisect.pkl | Bin 0 -> 795 bytes
cp/tests/tests_week03.py | 4 +-
cp/tests/tests_week04.py | 138 ++++++++++++
cp/tests/unitgrade_data/Week04Bug.pkl | Bin 0 -> 159 bytes
cp/tests/unitgrade_data/Week04Dialogue.pkl | Bin 0 -> 192 bytes
cp/tests/unitgrade_data/Week04Math.pkl | Bin 0 -> 156 bytes
cp/tests/unitgrade_data/Week04Palindrome.pkl | Bin 0 -> 125 bytes
cp/tests/unitgrade_data/Week04Parenthesis.pkl | Bin 0 -> 226 bytes
cp/tests/unitgrade_data/Week04Prefix.pkl | Bin 0 -> 172 bytes
27 files changed, 601 insertions(+), 13 deletions(-)
create mode 100644 cp/ex04/__init__.py
create mode 100644 cp/ex04/bug.py
create mode 100644 cp/ex04/hangman.py
create mode 100644 cp/ex04/mathematics.py
create mode 100644 cp/ex04/palindrome.py
create mode 100644 cp/ex04/parenthesis.py
create mode 100644 cp/ex04/prefix.py
create mode 100644 cp/project2/__init__.py
create mode 100644 cp/project2/project2_grade.py
create mode 100644 cp/project2/project2_tests.py
create mode 100644 cp/project2/unitgrade_data/Hangman.pkl
create mode 100644 cp/project2/unitgrade_data/HangmanAvailableLetters.pkl
create mode 100644 cp/project2/unitgrade_data/HangmanGuessedWord.pkl
create mode 100644 cp/project2/unitgrade_data/HangmanIsGuessed.pkl
create mode 100644 cp/project2/unitgrade_data/TestBisect.pkl
create mode 100644 cp/project2/unitgrade_data/TestIsThereARoot.pkl
create mode 100644 cp/project2/unitgrade_data/TestTheFunctionToBisect.pkl
create mode 100644 cp/tests/tests_week04.py
create mode 100644 cp/tests/unitgrade_data/Week04Bug.pkl
create mode 100644 cp/tests/unitgrade_data/Week04Dialogue.pkl
create mode 100644 cp/tests/unitgrade_data/Week04Math.pkl
create mode 100644 cp/tests/unitgrade_data/Week04Palindrome.pkl
create mode 100644 cp/tests/unitgrade_data/Week04Parenthesis.pkl
create mode 100644 cp/tests/unitgrade_data/Week04Prefix.pkl
diff --git a/.gitignore b/.gitignore
index 82365f3..13d9271 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,13 +20,13 @@ cp/tests/unitgrade_data/Week01Palindrome.pkl
######################## Comment these out upon release. #############################
cp/exam
#cp/project1
-cp/project2
+#cp/project2
cp/project3
cp/project4
cp/project5
cp/project6
cp/tests/tests_week01.py
-*04*
+#*04*
*05*
*06*
*07*
diff --git a/cp/ex03/bisect.py b/cp/ex03/bisect.py
index 9f56037..ded6718 100644
--- a/cp/ex03/bisect.py
+++ b/cp/ex03/bisect.py
@@ -4,17 +4,12 @@ import math
def f(x : float) -> float:
r"""Find the roots of this function.
- You should implement the function :math:`f(x)` here. It is defined as:
+ You should implement the function f(x) here.
- .. math::
-
- f(x) = \sin(3\cos(\frac{1}{2} x^2))
-
- :param x: The value to evaluate the function in :math:`x`
- :return: :math:`f(x)`.
+ :param x: The value to evaluate the function in x
+ :return: f(x)
"""
- Compute f(x) here.
- # TODO: Code has been removed from here.
+ # TODO: Code has been removed from here.
def is_there_a_root(a : float, b : float) -> bool:
diff --git a/cp/ex04/__init__.py b/cp/ex04/__init__.py
new file mode 100644
index 0000000..c984687
--- /dev/null
+++ b/cp/ex04/__init__.py
@@ -0,0 +1 @@
+"""Exercises for week 4."""
diff --git a/cp/ex04/bug.py b/cp/ex04/bug.py
new file mode 100644
index 0000000..75761e3
--- /dev/null
+++ b/cp/ex04/bug.py
@@ -0,0 +1,37 @@
+"""Exercise 4.4-4.5: Let the world know you have written your last bug."""
+
+def last_bug():
+ """Write a nice message enclosed by lines and pipes that clearly indicate you have written your last bug.
+
+ The function should print out the following three lines in the console:
+
+ .. code-block:: console
+
+ ------------------------------
+ | I have written my last bug |
+ ------------------------------
+ """
+ # TODO: Code has been removed from here.
+
+
+def nice_sign(msg : str):
+ """Print the input string as a nice sign by enclosing it with pipes.
+
+ Note that the input message can vary in length.
+
+ .. code-block:: console
+
+ ---------------
+ | {input msg} |
+ ---------------
+
+ :param msg: The message to enclose.
+ """
+ # You can use len(msg) to get the number of characters and "-"*10 to repeat a character (try in the console!)
+ # TODO: Code has been removed from here.
+
+
+if __name__ == "__main__":
+ # here you can try out your functions
+ last_bug() # Done with the bugs
+ nice_sign("Hello world")
diff --git a/cp/ex04/hangman.py b/cp/ex04/hangman.py
new file mode 100644
index 0000000..f85debe
--- /dev/null
+++ b/cp/ex04/hangman.py
@@ -0,0 +1,70 @@
+"""Exercise 4.12-4.16."""
+
+def is_word_guessed(secret_word : str, letters_guessed : str) -> bool:
+ """Determine if the word has been guessed.
+
+ :param secret_word: The word to guess
+ :param letters_guessed: A ``str`` containing the letters that have currently been guessed
+ :return: True if and only if all letters in ``secret_word`` have been guessed.
+ """
+ # TODO: Code has been removed from here.
+
+
+def get_available_letters(letters_guessed : str) -> str:
+ """
+ Return the letters which are available, i.e. have not been guessed so far.
+
+ The input string represents the letters the user have guessed, and the output should then be the lower-case
+ letters which are not contained in that string. The function is used to show the user which
+ letters are available in each round.
+
+ :param letters_guessed: A `str` representing the letters the user has already guessed
+ :return: A `str` containing the letters the user has not guessed at yet.
+ """
+ # TODO: Code has been removed from here.
+
+def get_guessed_word(secret_word : str, letters_guessed : str) -> str:
+ """Format the secret word for the user by removing letters that have not been guessed yet.
+
+ Given a list of the available letters, the function will replace the letters in the secret word with `'_ '`
+ (i.e., a lower-case followed by a space). For instance, if the secret word is ``"cat"``, and the
+ available letters are ``"ct"``, then the function should return ``"c_ t"``.
+
+ :param secret_word: A ``str``, the word the user is guessing
+ :param letters_guessed: A ``str`` containing which letters have been guessed so far
+ :return: A ``str``, comprised of letters, underscores (_), and spaces that represents which letters in secret_word have been guessed so far.
+ """
+ # TODO: Code has been removed from here.
+
+def hangman(secret_word : str, guesses : int):
+ """
+ Play an interactive game of Hangman.
+
+ This function should launch an interactive game of Hangman. The details of the game is defined in the
+ project description available online, and should be read carefully.
+
+ * The game should first display how many letters are in the secret word. You should start by generating this output.
+ * Before each round, the user should see how many guesses that are left and which letters are not yet used
+ * In each round, the user is prompted to input a letter. Use the ``input('..')`` function for this.
+ * The user is given feedback based on whether the letter is in the word or not. The program also performs error handling.
+ * The game terminates when the user win, has exceeded the number of guesses, or if the user makes an illegal input.
+ in this case the user is shown a score.
+
+ :param secret_word: The secret word to guess, for instance ``"cow"``
+ :param guesses: The number of available guesses, for instance ``6``
+ """
+ # TODO: Code has been removed from here.
+
+
+
+if __name__ == "__main__":
+ # here you can try out your functions
+ print("This should return True: ", is_word_guessed("dog", "tdohg"))
+ print("This should return False: ", is_word_guessed("dog", "dthk"))
+
+ print("This should be 'c_ w': ", get_guessed_word('cow', 'kcwt'))
+
+ print("Available letters when we have tried 'abcdefghijk'; this should be about half the alphabet: ", get_available_letters('abcdefghijk'))
+
+ print("Lets launch hangman. Try the inputs in the exercise description and see if you get the same")
+ hangman("cow", 4)
diff --git a/cp/ex04/mathematics.py b/cp/ex04/mathematics.py
new file mode 100644
index 0000000..c74e811
--- /dev/null
+++ b/cp/ex04/mathematics.py
@@ -0,0 +1,22 @@
+"""Exercise 4.1 and 4.2."""
+import math
+
+def square_root(a : float) -> float:
+ r"""Compute the square root, see section 7.5 in Think Python.
+
+ :param a: A number to compute the square root of.
+ :return: :math:`\sqrt{a}`.
+ """
+ # TODO: Code has been removed from here.
+
+def ramanujan() -> float:
+ r"""Compute the Ramanujan approximation of :math:`\pi` using a sufficient number of terms.
+
+ :return: A high-quality approximation of :math:`\pi` as a ``float``.
+ """
+ # TODO: Code has been removed from here.
+
+if __name__ == "__main__":
+ # here you can try out your functions
+ print("approximate pi", ramanujan())
+ print("square root of 2 is", square_root(2))
diff --git a/cp/ex04/palindrome.py b/cp/ex04/palindrome.py
new file mode 100644
index 0000000..4b30a88
--- /dev/null
+++ b/cp/ex04/palindrome.py
@@ -0,0 +1,14 @@
+"""Exercise 4.3: Checking if a word is a palindrome."""
+
+def is_palindrome(word : str) -> bool:
+ """Check if ``word`` is a palindrome.
+
+ :param word: The word to check
+ :return: ``True`` if input is a palindrome and otherwise ``False``
+ """
+ # TODO: Code has been removed from here.
+
+if __name__ == "__main__":
+ # here you can try out your functions
+ print("Is Madam a palindrome?", is_palindrome('madam'))
+ print("Is gentleman a palindrome?", is_palindrome('gentleman'))
diff --git a/cp/ex04/parenthesis.py b/cp/ex04/parenthesis.py
new file mode 100644
index 0000000..94d31d5
--- /dev/null
+++ b/cp/ex04/parenthesis.py
@@ -0,0 +1,72 @@
+"""Exercise 4.6-4.9."""
+def matching(expression :str) -> bool:
+ """Tell if the parenthesis match in a mathematical expression.
+
+ For instance, the parenthesis match in ``"3x(y-1)(3y+(x-1))"`` but not in ``"3x(y-4))"``
+
+ :param expression: An expression containing zero or more parenthesis.
+ :return: ``True`` if the number of open/close parenthesis match, otherwise ``False``
+ """
+ # TODO: Code has been removed from here.
+
+def find_innermost_part(s : str) -> str:
+ """Find the innermost part of a mathematical expression.
+
+ The innermost part is a substring enclosed in parenthessis but not containing parenthesis.
+ For instance, given ``"3(x+(4-y^2))"``, then ``"4-y^2"`` is an inner-most part.
+ The parenthesis can be assumed to match.
+
+ :param s: The mathematical expression as a ``str``
+ :return: The innermost part as a ``str``
+ """
+ # TODO: Code has been removed from here.
+
+
+def find_index_of_equality(expression : str) -> int:
+ """Find an index ``i`` which split the expression into two balanced parts.
+
+ Given an expression containing opening and closing parenthesis, for instance ``"(()())"``, this function should
+ return an index ``i``, such that when the string is split at ``i``, the
+ number of opening parenthesis ``(`` in the left-hand part equal the number of closing parenthesis ``)`` in the
+ right-hand part. For instance, if ``i=2``, the expression is split into the right, left hand parts:
+
+ - ``"(()"``
+ - ``"())"``
+
+ In this case the left-hand part contains ``2`` opening parenthesis and the right-hand part ``2`` closing parenthesis so ``i`` is the right index.
+ Similarly, for ``"()"``, the answer would be ``1``.
+
+ :param expression: An expression only consisting of opening and closing parenthesis.
+ :return: The index ``i`` as an int.
+ """
+ # TODO: Code has been removed from here.
+
+
+def print_the_dialogue(s : str):
+ """Print all dialogue in a manuscript.
+
+ Given a manuscript (as a ``str``), this function will find all lines of dialogue to the console, one line of
+ dialogue per printed line. Dialogue is enclosed by double ticks, i.e. this ``str`` contains two pieces of dialogue:
+ ``"''My dear Mr. Bennet,'' said his lady to him one day, ''have you heard that Netherfield Park is let at last?''"``
+
+ :param s: The manuscript as a ``str``.
+ """
+ # TODO: Code has been removed from here.
+
+
+
+if __name__ == "__main__":
+ # here you can try out your functions
+ print("Does the parenthesis match?", matching("2x(x+2)"))
+ print("Does the parenthesis match?", matching("2x(x+(2-y)^2)"))
+ print("Does the parenthesis match?", matching("4x"))
+
+ print("Does the parenthesis match?", matching("2x(x+2"))
+ print("Does the parenthesis match?", matching("2x)(x"))
+ print("Does the parenthesis match?", matching("4x()(()))"))
+
+ s = "(())))("
+
+ print("Index of equality for", s, "is", find_index_of_equality(s))
+ dialogue = "He said: ''How are you old wife''? She answered, perplexed, ''I am not your wife''"
+ print_the_dialogue(dialogue)
diff --git a/cp/ex04/prefix.py b/cp/ex04/prefix.py
new file mode 100644
index 0000000..233c2fa
--- /dev/null
+++ b/cp/ex04/prefix.py
@@ -0,0 +1,28 @@
+"""Exercise 4.10-4.11."""
+
+def common_prefix(word1 : str, word2 : str) -> str:
+ """
+ Return the longest string so that both ``word1``, and ``word2`` begin with that string.
+
+ :param word1: First word
+ :param word2: Second word
+ :return: The longest common prefix.
+ """
+ # TODO: Code has been removed from here.
+
+def common_prefix3(word1 : str, word2 : str, word3 : str) -> str:
+ """
+ Return the longest string so that both ``word1``, ``word2``, and ``word3`` begin with that string.
+
+ :param word1: First word
+ :param word2: Second word
+ :param word3: Third word
+ :return: The longest common prefix.
+ """
+ # TODO: Code has been removed from here.
+
+
+if __name__ == "__main__":
+ # here you can try out your functions
+ print("The longest Common Prefix is :", common_prefix("egregious", "egg"))
+ print("The longest Common Prefix is :", common_prefix3("egg", "egregious", "eggplant"))
diff --git a/cp/project2/__init__.py b/cp/project2/__init__.py
new file mode 100644
index 0000000..890dc18
--- /dev/null
+++ b/cp/project2/__init__.py
@@ -0,0 +1 @@
+"""Dummy (test) project from 02465."""
diff --git a/cp/project2/project2_grade.py b/cp/project2/project2_grade.py
new file mode 100644
index 0000000..efca94f
--- /dev/null
+++ b/cp/project2/project2_grade.py
@@ -0,0 +1,4 @@
+# cp/project2/project2_tests.py
+''' WARNING: Modifying, decompiling or otherwise tampering with this script, it's data or the resulting .token file will be investigated as a cheating attempt. '''
+import bz2, base64
+exec(bz2.decompress(base64.b64decode('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')))
\ No newline at end of file
diff --git a/cp/project2/project2_tests.py b/cp/project2/project2_tests.py
new file mode 100644
index 0000000..6d7b55f
--- /dev/null
+++ b/cp/project2/project2_tests.py
@@ -0,0 +1,206 @@
+import string
+from unitgrade import hide
+from cp import minput
+from unittest.mock import patch
+import io
+import unittest
+from unitgrade import UTestCase, Report
+import math
+
+class TestTheFunctionToBisect(UTestCase):
+ def test_f(self):
+ from cp.ex03.bisect import f
+ self.assertAlmostEqual(f(0), 0.1411200080598672)
+ self.assertAlmostEqual(f(1), 0.4871688735635369 )
+ self.assertAlmostEqual(f(2), -0.9484917234010158)
+ self.assertAlmostEqual(f(math.pi), 0.6145000731172406 )
+ self.assertAlmostEqual(f(-10), 0.244199939520782)
+ self.assertAlmostEqual(f(117), -0.9996260520700749)
+
+
+class TestIsThereARoot(UTestCase):
+
+ def test_root_exists(self):
+ from cp.ex03.bisect import is_there_a_root
+ self.assertTrue(is_there_a_root(1, 3)) # root exists between 0 and pi
+
+
+
+ def test_no_root_exists(self):
+ from cp.ex03.bisect import is_there_a_root
+ self.assertIs(is_there_a_root(3.2, 3.8), False) # no root exists between 0 and 2pi
+
+
+ def test_root_not_found(self):
+ from cp.ex03.bisect import is_there_a_root
+ self.assertIs(is_there_a_root(1, 3.5), False)
+
+
+
+class TestBisect(UTestCase):
+ def test_base_case(self):
+ from cp.ex03.bisect import bisect
+ self.assertAlmostEqual(bisect(1, 3, 0.1), 1.8125)
+ self.assertAlmostEqual(bisect(1, 5.5, 0.1), 4.0234375)
+
+
+
+ def test_tolerances(self):
+ from cp.ex03.bisect import bisect
+ self.assertAlmostEqual(bisect(2, 3.5, 10), 2.75)
+ self.assertAlmostEqual(bisect(2, 3.5, 0.1), 3.03125)
+
+
+ def test_no_solution(self):
+ from cp.ex03.bisect import bisect
+ self.assertTrue(math.isnan(bisect(1, 3.5, 1)))
+
+
+
+class HangmanIsGuessed(UTestCase):
+ def test_is_word_guessed(self):
+ from cp.ex04.hangman import is_word_guessed
+ self.assertTrue(is_word_guessed("dog", "tdohg"))
+ self.assertTrue(is_word_guessed("dog", "tdohg"))
+ self.assertIs(is_word_guessed("dog", ""), False)
+ self.assertIs(is_word_guessed("species", "sdcbwegk"), False)
+ self.assertTrue(is_word_guessed("species", "qseicps"))
+
+
+class HangmanGuessedWord(UTestCase):
+ def test_get_guessed_word(self):
+ from cp.ex04.hangman import get_guessed_word
+
+ self.assertEqual(get_guessed_word('cow', 'kcw'), 'c_ w')
+ self.assertEqual(get_guessed_word('apple', ''), '_ _ _ _ _ ')
+ self.assertEqual(get_guessed_word('tasks', 'ws'), '_ _ s_ s')
+
+
+
+class HangmanAvailableLetters(UTestCase):
+ def test_get_available_letters(self):
+ from cp.ex04.hangman import get_available_letters
+
+ self.assertEqual(len(get_available_letters('')), 26)
+ self.assertEqual(set(get_available_letters('bcdew')), set(string.ascii_lowercase).difference('bcdew'))
+
+
+
+
+
+class Hangman(UTestCase):
+ def test_hangman_startup(self):
+ from cp.ex04.hangman import hangman
+ with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+ try:
+ with unittest.mock.patch('builtins.input', minput([None])):
+ hangman("cow", guesses=4)
+ except GeneratorExit as e:
+ pass
+ out = mock_stdout.getvalue()
+ lines = out.splitlines()
+ self.assertEqual(len(lines), 4, msg='You must print 4 lines')
+ self.assertEqual(lines[0], 'Hangman! To save Bob, you must guess a 3 letter word within 4 attempts.', msg='First printed line is wrong')
+ self.assertEqual(lines[1], '----', msg='Second printed line is wrong')
+ self.assertEqual(lines[2], 'You have 4 guesses left.', msg='Third printed line is wrong')
+ self.assertTrue("." in lines[3] and ":" in lines[3], msg="Your fourth line must have both a colon and a period")
+
+ fp = lines[3].split(".")[0].split(":")[1].strip()
+ self.assertEqual(len(fp), 26, msg="The alphabet has 26 letters.")
+ self.assertEqual(set(fp), set(string.ascii_lowercase), msg="You failed to print the alphabet")
+
+
+ def chk_alphabet(self, line, missing):
+ self.assertTrue("." in line and ":" in line, msg="Your alphabet printout must have both a colon and a period")
+ fp = line.split(".")[0].split(":")[1].strip()
+ ab = set( [c for c in string.ascii_lowercase if c not in missing])
+ self.assertEqual(len(fp), len(ab), msg="The alphabet printout has to few characters")
+ self.assertEqual(set(fp), ab, msg="You failed to print the alphabet")
+
+ def test_hangman_correct(self):
+ from cp.ex04.hangman import hangman
+ with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+ try:
+ with unittest.mock.patch('builtins.input', minput(['w', None])):
+ hangman("cow", guesses=4)
+ except GeneratorExit as e:
+ pass
+ out = mock_stdout.getvalue()
+ lines = out.splitlines()
+ self.assertEqual(len(lines), 8, msg='You must print 8 lines')
+ self.assertEqual(lines[-4], 'Good guess: _ _ w', msg='Format guessed word correctly')
+ self.assertEqual(lines[-3], '----')
+ self.assertEqual(lines[-2], 'You have 3 guesses left.', msg='Third printed line is wrong')
+ self.chk_alphabet(lines[-1], missing='w')
+
+
+ def test_hangman_false(self):
+ from cp.ex04.hangman import hangman
+ with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+ try:
+ with unittest.mock.patch('builtins.input', minput(['q', None])):
+ hangman("doggy", guesses=4)
+ except GeneratorExit as e:
+ pass
+ out = mock_stdout.getvalue()
+ lines = out.splitlines()
+ self.assertEqual(len(lines), 8, msg='You must print 8 lines')
+ self.assertEqual(lines[-4], 'Oh no: _ _ _ _ _ ', msg='Format guessed word correctly')
+ self.assertEqual(lines[-3], '----')
+ self.assertEqual(lines[-2], 'You have 3 guesses left.', msg='Third printed line is wrong')
+ self.chk_alphabet(lines[-1], missing='q')
+
+
+ def test_hangman_win(self):
+ from cp.ex04.hangman import hangman
+ with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+ try:
+ with unittest.mock.patch('builtins.input', minput(['q', 'd', 'g', 'o', 'y', None])):
+ hangman("doggy", guesses=8)
+ except GeneratorExit as e:
+ pass
+ out = mock_stdout.getvalue()
+ lines = out.splitlines()
+ self.assertEqual(len(lines), 22, msg='You must print 22 lines')
+ self.assertTrue(lines[-1], 'Your score is 20')
+
+ # @unittest.mock.patch('sys.stdout', new_callable=io.StringIO)
+ def test_hangman_loose(self):
+ from cp.ex04.hangman import hangman
+ with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+ try:
+ with unittest.mock.patch('builtins.input', minput(['%'])):
+ hangman("cat", guesses=5)
+ except GeneratorExit as e:
+ pass
+ out = mock_stdout.getvalue()
+ lines = out.splitlines()
+ self.assertEqual(len(lines), 5, msg='You must print 5 lines')
+ self.assertTrue(lines[-1], 'Game over :-(. Your score is 0 points.')
+
+
+
+
+
+
+
+class Project2(Report):
+ title = "Project 2"
+ remote_url = "https://cp.pages.compute.dtu.dk/02002public/_static/evaluation/"
+
+ abbreviate_questions = True
+ questions = [(TestTheFunctionToBisect, 5),
+ (TestIsThereARoot, 15),
+ (TestBisect, 15),
+ (HangmanIsGuessed, 10),
+ (HangmanGuessedWord, 10),
+ (HangmanAvailableLetters, 10),
+ (Hangman, 30),
+ ]
+ import cp
+ pack_imports = [cp]
+
+
+if __name__ == "__main__":
+ from unitgrade import evaluate_report_student
+ evaluate_report_student(Project2())
diff --git a/cp/project2/unitgrade_data/Hangman.pkl b/cp/project2/unitgrade_data/Hangman.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..e53a63f8366c41fd8d9b0e8dc0958c1a598b1444
GIT binary patch
literal 8146
zcmeHMPiq@T6qk!hgDD}HTzY9Aq7WHmIe`|64k_-Rs1PVLxL|sycDx#C7gjUN%&b)%
z3_XP&_Nab<euUoo4f?hE-kY7(ZWRlf29v_-vg={?&70r*^ZU*Cm&4!w`nboxo6Vqn
z|68FJOQAO9k(KU;{Hsh@yLq)K4_&&H_%iw8lbmNK2jwFtt(zwPi>Y<OxFV;?_wXZW
z9KPOcl7r;lt4(r9pFVw5eM&>+{a9a1BNk-#W>X%=`I-Fr$){(P!BM`(;X(QNOwM5;
z-BetQG!s{uoMzHFY3!hSP8Ws51!ph@>&yw9KBMP&^Wvk+-g~_s;IH5BAJOxrbcIpi
z5((AEuu9T60bwN63k)G0$q^*tT7uFJuB22D7O@)U!i<jC-US*;RbDt+F;xpNGB?sn
z<!oyaTChM&yv@qg5QLiXG+j8hk?11h5ru1d19~ORX)LVd^>&>m|6;A2NEITG(%wYy
zW(4Hlyil=AwSv@=4`^S5P4tTGvr`N~%YF+EvML3FWOSis)y~JcFk%@{3?Uf9IYbCW
zv;~4tY2w|0!h*<*6ti^zmwgx;4${_CwY|ND2!;?L-2Ym-5gWt6Q%0r~{EGw;sL?<O
z2<%KCJQ#n3M`2P4gbJg+5K9Sq4pljLAZHR$&Mb}7CU_27#QfZ1FE=l~E5E1JDCH*S
zFTXsWd;>?}?M<J!hr;fZT&#_eG1XaezpAwlL#>@X47El>5B8SWb1JdaPFLE@LL>)P
z#ux}5^My71XRsUfcBOTO1^2<_@j+d1UrWSuiO@jm0VDHR0Jc?6?R07^I>vZO;BPQt
zIkrAMZcjYUyeO2zZoXh*a81Vr;-*}-Zh6v9z6(>Z<5Z$r;Z)p&$g+R|)kG9E+>Ih{
zyV)yRDcJR~u8(n>-p$LJ8!Xe!o<7EvN@Q5g;qv@<rRu5i>E)kWYJ9HE5^IB+n$Kuo
zc5`jE9C5YAmcG>2<b7ZvrkdBYBsXBLs0sE{1p>0vy3jgnrVXZsyinbnS1DE+QfVgQ
ziUvL7dwy$sxk_CE(c>vRj(EKRaW_&cWHoidTxayx3~(0$Y>sA6Mu6K!gQ#0nERphk
zlWGEh%{_|xv2gt;s>zxc+1UUK2%7BYB9vZb)LW|P#&a8+odV6>)Bli4eMj@?_*RH9
zV$Me2I0rBuzH!~s7KxB|`=S>;A&wlvX5#`ca=hUN9S3(}z06HYS^~MSvN8k|2dK)B
zl%$2h^u!~^V3Qca1Z#++wgcEq8?AJ=kyie+`srO#`eph1Tc`9ll>)bY7bL=QOO?+>
zW=UYz0^vyz2&b$MdZ^E7s1pcPj&=ee&`)>J+1ps(&4W%S5O!otClL1LaVHSo!kPd7
zBoH391i~s+O?fa0^5C;F+#k@;9m#_S-TgsRhPU)?cYn~`A9VKz{*b<N{O;}#{PDkW
zist+CaA2pao$mgi)la+o1OLy7aG&t{`-4pD_Wi+6K_Co&4FZ9N_6vlLyE^Xr&)jvF
U1^Z+9$2))F7Ya8#xqyq&-{~5-I{*Lx
literal 0
HcmV?d00001
diff --git a/cp/project2/unitgrade_data/HangmanAvailableLetters.pkl b/cp/project2/unitgrade_data/HangmanAvailableLetters.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..fb6460676db76919064db7cd59d0f835b2e7127e
GIT binary patch
literal 767
zcmaKqF>BmF5QXh<7;|MBgNra+V;gMQMT(#ziE)uYT!jSEoyXFgc0so*c4zN=#X%}p
zDwThlB4uXxB-@9L)vQ?bzW3&hevkhAeY2CEb$8qzd__~u(OfQ2*LYjgH8GR(T|4%~
zKbxx>z3=Y3cEoy4^77@=;pe1QyX_&9=V?Ve#X&x;d%Z~ZL`sfDwC>cd+Pm-6C<2cD
z^?-QQ?iY4J4yy=XckSDvIj6ge_vdO8ENfQr`a?-Gc+u&&cbry%#IJ-LJi8M(`xwu>
z`}XeFjtmU)OeT|YJiikMXMhz!FNUSkg#vU052Kud&L{(g3j$*qZix&GCf>pfT{cd<
z9|F>*2^<}@slZX=$dh5eWfBd8RI*|As8c{wrq68P#85WW>BflX24I)u&I<ID{GNx7
z`3h?owUGvNoDGLG8N__EU<%gOfc7zi@GW>{mx-T3r3$wATXjS#p_JroFl9e^-k`(z
z(BiOy94_HTs<?S9BDV6h?<ZAwz}gX(tD)SKA$Ms>kEnjUS3$9cVM8+iia1L!S-kvR
H-iPczWGD<|
literal 0
HcmV?d00001
diff --git a/cp/project2/unitgrade_data/HangmanGuessedWord.pkl b/cp/project2/unitgrade_data/HangmanGuessedWord.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..327e4e929c75ee11f4dbf26bf1f14ae747e674da
GIT binary patch
literal 955
zcmZuwv5wO~5Y0h!LMczWf^L-N63OQSiOK~CAzhHD5p?!uJ<hIV?^?U-gcOmeu5xL5
zK7o>wPh)o1fn30nrS<I0dvE5AzfQmXcsdEsVOaE6@0r>(OszV!7RyiCltVwW=svdZ
zYG&>5F!WO=8>GYP>QOP+aua4z0^KNN=pncfOReFR2QRqvK%^7vl0^5K~`!{e7(U
zq5c`yTQqFraSua(#oIgl^5WH<h;q_)@5A>cR&Y+Tu*eM&dqT*-I+H++&Y`hKF)_S^
z+t>a&8$P`J{PW3V0`$!1^LuR?=D-Pr2n7ME(k8?@k`L=W7;N-bs?8CcE~!eeErQYx
z)`$wm=3$R6oy|P{N^U96pqAEwt^y+4GFh{AjYp^?gsV<*C$)l|tZSlcYsN9$jO~C_
z;qz4GPC5a_O%69j;9JNP)5H_%9hzItEJCGg|5f@f7}%Czmnl%&1ZW*o921aH+9|ZO
zP!w~{+`K3VQI(!Nko?mCFoPjE=2Bi%`llr;bXS+ul<SNNnK}5}aY|Xs3~R>m2PZRl
zOKIem=l0eFPy8YHLE6Hs$&a9D1UU0OgTE-iwQ@`<@8C{IE{?;G7Cy4iYN(irz)|ue
zIb1ibk@S0bLr2O4I#trjac$7TB45Udg<)H2fL4VZr8`v4o(UjZPj@)1)PMA(K@cr0
J{Ug?P>2LoMOXdIo
literal 0
HcmV?d00001
diff --git a/cp/project2/unitgrade_data/HangmanIsGuessed.pkl b/cp/project2/unitgrade_data/HangmanIsGuessed.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..dabccd920f6a03c97bc15fb560dbf9069754b191
GIT binary patch
literal 671
zcmZ8fJx{|h5N%O~PzHn$3)`s!DiX8|Oc_AsD<C!mf~|FvYi!A}E88hBRAOSvX#NR5
zkaL;}il@{0y?gJT{n7dI8?E{*e6QNMWhyV2y0b}%)?((X$fA3iT}o!H|MXSIi2|ue
z&JS*D8gEy74y_vrJ9^b78|4j?z?(!u;|RX+yv;X1J?{kS^LIlHt!gXPb2KauV;8>K
zO=kmqJ2@TjrI-Hfo!Y(XCc`QG6X{t@4Z2zwVzAB}fkfxf*p-iE`w))LV4}5*{r&dK
zZoAb2I^Ayf3JF{Yg&?NjI6~L~II}Q8RM0HbkD`E&XUwny{)oo#xZ*gyME^zp^Af`l
z#$$3h9z&{?V?qg)*Rl<gYUW6Oj*yndpmOqk&B<~)?OYl~;-;*PGnIi>1f?aIl&cIt
zsG#?o5$V>m*LQ282+u1*{m6xdX{k~tv;xa@DKn6a8XTCSp%fXTOEQ_W0zprq`8WMK
sjtprtX+u9GT4QJ;y&vVA1yj`a_er(iC`ZZg;bNFvL$s>MOKHpg4>r~39smFU
literal 0
HcmV?d00001
diff --git a/cp/project2/unitgrade_data/TestBisect.pkl b/cp/project2/unitgrade_data/TestBisect.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..9e599e9d5d67992e6f8c79a822b44ebc739f4f60
GIT binary patch
literal 3222
zcmeHJO=}cE5KSP2u!I;-LGe&5A{$6HL2q*~5FrYB5LqEAveP?LyVEe!y>$0v$3wtV
zF3!Qj_$&M~{v@k<KC<x;^q?T@9G0His_uHP-n^O58{fWculeh;8kD^eT6ZcfMy@J*
z7Tw$Vvs74HT~+0VlNr+D`N=)-1<883<0yYT5f;Z0{czeQrK54QysVP-Wb>*@Hn`~F
z*QSU=<yNFG(1;nATvp}XXnusn@sp#8KYKX;MA1QcKgKCc2L%K$O|@|QaQL)d1=Y*#
z@;lIF`u+ZyR57>&!D#I)=qcSu3)5UhPHHvm^*HmL&cP-+Ph*hTJjD!^^HpsgAGHq&
z8f+?pxiBJwB7hNXej(Bv!D&EV2}f&+cEwUb;m-*Sy4)!0nYQy0YLTgV%y6U~Q<=fB
z7<0D+(SkdGNxSqoCt9ZjbMJh2eQk~Vr(NFoogoZICdV)YIfVs+FbK1pT2&6w6F~vO
zFFYSiM;J~yTltP9r5S<%K_*-hgdYSQ{V}|WSp@J(FKD_@9CpAXt*ngE)G%vuCIP&V
zv*gyymXJT}n|WH0AgKK_ky-*gT&DAc>8u4aC^7=qsN?{OOmvz#fEZKPv3x^9kIvs;
zbL&MUAQCE;F;ADr0}Dw~Qq%#TKpfJ){zepZ)BMRYn8^zydUZ;wR?)8lqS{(Rw2)a&
zlDeH#2GA6U;&%!>#=2su2Ubm|#u1BE8k%T5&u01s!ANA3uwXi{emepfOY0a8Yp79^
zh$3xbsb>5nF!Fi=^q7H2XW9^7+0vA9OEz)G+eFtG+exz37{r6tAohN=2En17l`nL1
zUirdJKU?_%0vW{r?+d%$7nB}bo#y<eUN(l~))<anx5mJsl`&ku=T^q>kBy<f`d|qE
J`UgWk{0S36GEM*h
literal 0
HcmV?d00001
diff --git a/cp/project2/unitgrade_data/TestIsThereARoot.pkl b/cp/project2/unitgrade_data/TestIsThereARoot.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..727933791d5e417e11ccdf540e8c6b6f83d638ee
GIT binary patch
literal 1971
zcmeHHO^Xvj5KSPgOOPd^Akj;aQ&!xp=xq)zBCN`KkR^g5lIhIUq#I_shyK`%hk&O&
z&2jt>!d~_#`BSX!WWwq}+<W>|Q`D=j_vTf9@BR3BrxVVq8P|g;8vD*nIcj`$u9R)+
zzCru3e4R66n#-o{Sy3PbZ%!Wn3NYTS2bNGXP31GJgt4J;j{vAGm984z<$IS6?|IlT
z-oSjS-cQs8YPRq#S518{DUY#w_TqRh3?_C`exvNTew1Pc*|>rTvRpBH2uCm1QPiB>
zt*?NN9*st)LZ)Cjf}h2J%IHHF$ec{9P;%1m`^wMCf#J&KDTt!Xu|R19s;%=^9fH?j
zgNRC|Spii9qzqiJ+#y&6=p$w+rtB6hBvj#^NTYRH(#+H@WN1XM;d4(%m>Iz|&R9@x
z%vy3!Vcv#;=Ul0rXg>Tj=yp1Oe(G`_Izt>!wZk|Dk--vyX@rHNQKdx;LQsPEv!I8U
zBaSm)EyKiu$}~}cs9=^y@fSu{e~tg-%p!QNmh^w2I@%IXlr$nmy{5SqXCA>@vEcu#
zYz4XH++L?88G^<?Ww{~3lN)k6Ll(RrEGX4qF68?g`wd(BJ-BY|=Tiqe*KJm6=Q_WP
rH@D@#T^AlcNsnKqoJ?uKx2}8Ax^DQPb)8S`T-QEuJJ;RTb#C$-!##~I
literal 0
HcmV?d00001
diff --git a/cp/project2/unitgrade_data/TestTheFunctionToBisect.pkl b/cp/project2/unitgrade_data/TestTheFunctionToBisect.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..e1c59772b0f22e0d4cd3b4d49200b5b83a301b02
GIT binary patch
literal 795
zcma))F^|+R5QTTeYK2x5M}<T+Y_%ud?IF>n-~>oVaqS`j&BfT0wWZjOY-b6@N>o>+
z3_U%6k%E~d8y!@*8jt7M^S$x+#gDT`vwj`BP5W$zG3_+o)J`Vj-Oj%?5oPMyRmAk6
zdRK}VyZf$PBx8|+_t!6e_G&$Emx;u81s^Y|3`3&u*y*`m-gkPz#czI(#hhv%OMk#1
z_I%N?YoE&M3Y(X&uD<kdZmVyU-L%gY7Eo*&$e<{_Nat|*dWf>__DTB-XodB9ePf)0
zq!EJmDS|I(V<HqI%67Hl%1^$AsC`{3Ft#euqD#H%RL4)9gT{cPBCA9Y7Mcvm7&wTs
zMo1ozBatYk>?Af0n*N<EV5)<op6R+iLoKp3*Nig|ZW>GVBi02pR!oo=ps-Bhbodvu
z{rGu4n=#CZT7VQz8O7}|J$yC9?jX<kg**p3?Kh&K&3MRt@67=n(Udd>C;ufT?Ep=I
zu{C*cIpIt1qEQ$I*wG>a7zLvFA3@JJC?52{WRrdDd0|3Kqw|>+NoRRO7}`h;G~o%h
qzm5QviHULe4~W4KA*Bz>xIK@K$%hHh7Y9-9eIUQ=gDKUq-u?mRiVP+I
literal 0
HcmV?d00001
diff --git a/cp/tests/tests_week03.py b/cp/tests/tests_week03.py
index bcea09b..1d29ede 100644
--- a/cp/tests/tests_week03.py
+++ b/cp/tests/tests_week03.py
@@ -133,11 +133,11 @@ class Week03IsThereARoot(UTestCase):
def test_no_root_exists(self):
from cp.ex03.bisect import is_there_a_root
- self.assertFalse(is_there_a_root(3.2, 3.8)) # no root exists between 0 and 2pi
+ self.assertIs(is_there_a_root(3.2, 3.8), False) # no root exists between 0 and 2pi
def test_root_not_found(self):
from cp.ex03.bisect import is_there_a_root
- self.assertFalse(is_there_a_root(1, 3.5))
+ self.assertIs(is_there_a_root(1, 3.5), False)
class Week03Bisect(UTestCase):
diff --git a/cp/tests/tests_week04.py b/cp/tests/tests_week04.py
new file mode 100644
index 0000000..d34692f
--- /dev/null
+++ b/cp/tests/tests_week04.py
@@ -0,0 +1,138 @@
+from unitgrade import UTestCase, Report
+import unittest
+from unittest.mock import patch
+import cp
+import io
+
+def string_fixer(s):
+ return s.strip().replace(' ', ' ')
+
+class Week04Palindrome(UTestCase):
+ def test_is_palindrome(self):
+ from cp.ex04.palindrome import is_palindrome
+ self.assertTrue(is_palindrome('madam'))
+ self.assertTrue(is_palindrome('kk'))
+ self.assertTrue(is_palindrome('m'))
+ self.assertIs(is_palindrome('gentleman'), False)
+ self.assertIs(is_palindrome('ma'), False)
+
+
+class Week04Bug(UTestCase):
+ def test_nice_sign(self):
+ from cp.ex04.bug import nice_sign
+ with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+ nice_sign('hello')
+ out = mock_stdout.getvalue()
+
+ self.assertEqual(len(out.splitlines()), 3, msg="You did not print out 3 seperate lines")
+ l1 = out.splitlines()[0]
+ l2 = out.splitlines()[1]
+ l3 = out.splitlines()[2]
+
+ self.assertEqual(string_fixer(l1), "---------")
+ self.assertEqual(string_fixer(l2), "| hello |")
+ self.assertEqual(string_fixer(l3), "---------")
+
+ def test_last_bug(self):
+ from cp.ex04.bug import last_bug
+ with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+ last_bug()
+ out = mock_stdout.getvalue()
+
+ self.assertEqual(len( out.splitlines()), 3, msg="You did not print out 3 seperate lines")
+ l1 = out.splitlines()[0]
+ l2 = out.splitlines()[1]
+ l3 = out.splitlines()[2]
+
+ self.assertEqual(l1, "------------------------------")
+ self.assertEqual(l2, "| I have written my last bug |")
+ self.assertEqual(l3, "------------------------------")
+
+
+class Week04Math(UTestCase):
+ def test_square_root(self):
+ from cp.ex04.mathematics import square_root
+ self.assertAlmostEqual(square_root(9), 3, places=3)
+ self.assertAlmostEqual(square_root(25), 5, places=3)
+
+ def test_pi(self):
+ from cp.ex04.mathematics import ramanujan
+ self.assertAlmostEqual(ramanujan(), 3.1416, places=3)
+
+
+class Week04Parenthesis(UTestCase):
+ def test_matching(self):
+ from cp.ex04.parenthesis import matching
+ self.assertTrue(matching('3x(y+x)'))
+ self.assertTrue(matching('3x'))
+ self.assertTrue(matching('3x(y+(x-1))'))
+ self.assertTrue(matching('3(x-8)^2(y+(x-1))'))
+ self.assertIs(matching('3x(y+x))'), False)
+ self.assertIs(matching('(3x(y+x)'), False)
+
+ def test_innermost(self):
+ from cp.ex04.parenthesis import find_innermost_part
+ self.assertEqual(find_innermost_part('(3+x)'), '3+x')
+ self.assertEqual(find_innermost_part('3+x'), '3+x')
+ self.assertEqual(find_innermost_part('3x((y+2)y+x)'), 'y+2')
+ self.assertEqual(find_innermost_part('3x((y+(1 - q^2)y+x)'), '1 - q^2')
+
+
+ def test_find_index_of_equality(self):
+ from cp.ex04.parenthesis import find_index_of_equality
+ self.assertEqual(find_index_of_equality("()"), 1)
+ self.assertEqual(find_index_of_equality("(()())"), 3)
+ self.assertEqual(find_index_of_equality("())"), 2)
+ self.assertEqual(find_index_of_equality("())((((("), 2)
+ # self.assertEqual(find_index_of_equality(""), 0)
+ self.assertEqual(find_index_of_equality(")(()())("), 4)
+
+
+class Week04Dialogue(UTestCase):
+ def test_print_the_dialogue(self):
+ from cp.ex04.parenthesis import print_the_dialogue
+ with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+ print_the_dialogue("He said: ''How are you doing?''")
+ out = mock_stdout.getvalue()
+ self.assertEqual(out.strip(), "How are you doing?")
+
+ def test_print_the_dialogue_twolines(self):
+ from cp.ex04.parenthesis import print_the_dialogue
+ with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+ print_the_dialogue("He: ''How are you doing?'' She: ''Still stuck on my 02002 programming problems''.")
+ out = mock_stdout.getvalue()
+ self.assertEqual(out.strip(), "How are you doing?\nStill stuck on my 02002 programming problems")
+
+
+class Week04Prefix(UTestCase):
+ def test_common_prefix(self):
+ from cp.ex04.prefix import common_prefix
+ self.assertEqual( common_prefix("cat", "cawabunga"), "ca")
+ self.assertEqual(common_prefix("caterpillar", "catapult"), "cat")
+ self.assertEqual(common_prefix("cat", "dog"), "")
+
+ def test_common_prefix3(self):
+ from cp.ex04.prefix import common_prefix3
+ self.assertEqual(common_prefix3("cat", "cawabunga", "catapult"), "ca")
+ self.assertEqual(common_prefix3("cawabunga", "cow", "catapult"), "c")
+ self.assertEqual(common_prefix3("selenium", "sealant", "sensei"), "se")
+ self.assertEqual(common_prefix3("selenium", "apple", "sensei"), "")
+
+
+class Week04Tests(Report):
+ title = "Tests for week 04"
+ # version = 1.0
+ # url = "https://gitlab.compute.dtu.dk/cp/02002students/-/blob/master/cp/tests"
+ pack_imports = [cp]
+ questions = [
+ (Week04Math, 10),
+ (Week04Palindrome, 10),
+ (Week04Bug, 10),
+ (Week04Parenthesis, 10),
+ (Week04Dialogue, 10),
+ (Week04Prefix, 10),
+ ]
+
+if __name__ == '__main__':
+ from unitgrade import evaluate_report_student
+ evaluate_report_student(Week04Tests())
diff --git a/cp/tests/unitgrade_data/Week04Bug.pkl b/cp/tests/unitgrade_data/Week04Bug.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..ee50790b0915d830c81e05636fc6d9dea1d81247
GIT binary patch
literal 159
zcmZo*nL3350&1sd^l*l!re+(MIF+VP>ES9)EeS1f&PgmTp3*j@hovMlHx<Zmw-;{!
zYsg^i;VVfkE{V^}Oiqn2&P>k(DPsdFPc13|GHa(~FlMl|P03&ZY0_Q*)5Htb1T?lJ
XJ_%?KPyq*2F)viH-9HDg;!-^Txn?#z
literal 0
HcmV?d00001
diff --git a/cp/tests/unitgrade_data/Week04Dialogue.pkl b/cp/tests/unitgrade_data/Week04Dialogue.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..365c219060ef5e18a88a1900a5ffb4ea1e51c2d8
GIT binary patch
literal 192
zcmZo*nYxt$0&1sd^zenJre+(MxMU{g<foUWPU+z)PAv&7aL!3AE}qghrH7>?GdC5;
zaJQE{0M?bk*dtz&T3ixeP?VWh5?_*$8lM8w3{=ks)R$UR0@P7EC4(`8t!+vM3rIKT
i1DI|F9J=F6%JXwF^HM?9W^h3D^FsC8{e;+Fss{jgphYDB
literal 0
HcmV?d00001
diff --git a/cp/tests/unitgrade_data/Week04Math.pkl b/cp/tests/unitgrade_data/Week04Math.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..b958b1065ea174dc48d76074ea59fb05334de6e1
GIT binary patch
literal 156
zcmZo*nL3dH0&1sd^l*izre+(M_$HQQOzGh&PAv&7aL!3AE}qghrH7>?GdC5;aJLsN
z0PDzL>=7tQEiQ>KE-XzfN{uhd&o2QfWCLnQEdnuXr(`f@u(eIeU;$|}*a6eV4%SwX
V2~?870aeBeRc80+09aY69sn*(HMjr(
literal 0
HcmV?d00001
diff --git a/cp/tests/unitgrade_data/Week04Palindrome.pkl b/cp/tests/unitgrade_data/Week04Palindrome.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..eeeddf4ffbc53547dbe7945d16fb46923d0fa7f4
GIT binary patch
literal 125
zcmZo*nOejE0ku;!dIZ8#Q?m_B0upmF^HPfPb5p1Ea22PPgcdmGBo-G>X`9l+Qj!T2
zZJXk5FR1|5m%-R0RFYa;5}#QdUx3gDRLTa_l3G*(R9rhHgE51xZAu0UP@~;_h<&Ac
E06lFgf&c&j
literal 0
HcmV?d00001
diff --git a/cp/tests/unitgrade_data/Week04Parenthesis.pkl b/cp/tests/unitgrade_data/Week04Parenthesis.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..a9d41832452b8944b23bcca61f0b406aacdc762d
GIT binary patch
literal 226
zcmZo*nR=Z80&1sd^azHhre+(M1SA%v=9Ofm7H1Yu>ES9)EeS1f&PgmTp3*j@hovMl
zHx<Zmx0gx)Ys_Hm;VnrmE{V@gEJ@DD%u5HUVgss9Eh+&rYo}x|X0WwQ$zTELF?NCJ
z;REZ*%*#tH%FQnZsm$Pjs^*2Nw)+fm8PEo4u<EqTyp(t#POXT~Pm512EKSVGEU84+
ODh$*5!vU<fR1W~qdrvO_
literal 0
HcmV?d00001
diff --git a/cp/tests/unitgrade_data/Week04Prefix.pkl b/cp/tests/unitgrade_data/Week04Prefix.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..3c8550a026eda150dc9006b2d0121f1435d090a5
GIT binary patch
literal 172
zcmZo*nYxex0&1sd^zekIre+(M1QeyFWmZh-;VMoo2`zBWNh~g&(l(`sr6e;q707V6
zmofnB$zbdeDoHIaiBHbY&CSn?FM#L+DrEy|Ni8Y?Dz2T9!I;6;HYI}vq|xvLOrtQS
VMq{Az3=XIkUZ@s3hz^EQJpksFJAeQH
literal 0
HcmV?d00001
--
GitLab