cp/ex03/heart_attack.py

-"""Exercise 3.7: Heart attack."""
+"""Exercise 3.8: Heart attack."""
 
 def heart_attack(age:int, weight:int, smoker:bool) -> str:
     """Return a string indicating the risk of a person for having heart attack.
@@ -8,6 +8,4 @@ def heart_attack(age:int, weight:int, smoker:bool) -> str:
     :param smoker: Does the person smoke cigarettes?
     :return: A string, either "low" or "high", indicating the risk for having heart attack.
     """
-    # TODO: 12 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return risk
+    # TODO: Code has been removed from here. 

cp/ex03/simple_function.py

-"""This example is used in the lecture notes to illustrate the import statement. Ignore it for the exercises."""
-
-def just_a_function(): 
-    """Print two lines to the terminal."""
-    print("Hello!") 
-    print("I am justin-a-function :-).") 

cp/ex03/solar_panel.py

-"""Exercise 3.6: Solar panel."""
+"""Exercise 3.7: Solar panel."""
 
-def solar_panel(move : bool, swap : bool, hot : bool, empty : bool):
+def solar_panel(move : bool, swap : bool, hot : bool, empty : bool) -> str:
     """Print out whether it is a good idea to install solar panels on an object with the given properties.
 
     :param move: does the object move around?
     :param swap: does the object allow swapping or recharging battery?
     :param hot: is the object hot to the touch when it is running?
     :param empty: are there other empty places near the object?
+    :return: Whether you should put solar panels on the object as a string.
     """
-    # TODO: 19 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
+    # TODO: Code has been removed from here. 

cp/ex04/bug.py

-"""Exercise 4.2-4.3: Let the world know you have written your last bug."""
+"""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.
@@ -11,8 +11,7 @@ def last_bug():
         | I have written my last bug |
         ------------------------------
     """
-    # TODO: 5 lines missing.
-    raise NotImplementedError("Use print(...) to print the output here.")
+    # TODO: Code has been removed from here. 
 
 
 def nice_sign(msg : str):
@@ -29,10 +28,10 @@ def nice_sign(msg : str):
     :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: 4 lines missing.
-    raise NotImplementedError("Use print(...) to print the output here.")
+    # 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")

cp/ex04/hangman.py

 """Exercise 4.12-4.16."""
+
 def is_word_guessed(secret_word : str, letters_guessed : str) -> bool:
     """Determine if the word has been guessed.
 
@@ -6,25 +7,7 @@ def is_word_guessed(secret_word : str, letters_guessed : str) -> bool:
     :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: 4 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return guessed
-
-
-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: 6 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return word
+    # TODO: Code has been removed from here. 
 
 
 def get_available_letters(letters_guessed : str) -> str:
@@ -38,13 +21,22 @@ def get_available_letters(letters_guessed : str) -> str:
     :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: 2 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return letters
+    # 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 : str):
+def hangman(secret_word : str, guesses : int):
     """
     Play an interactive game of Hangman.
 
@@ -62,11 +54,11 @@ def hangman(secret_word : str, guesses : str):
     :param guesses: The number of available guesses, for instance ``6``
     """
     # TODO: Code has been removed from here. 
-    raise NotImplementedError("Insert your solution and remove this error.")
 
 
 
 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"))
 

cp/ex04/mathematics.py

@@ -7,19 +7,16 @@ def square_root(a : float) -> float:
     :param a: A number to compute the square root of.
     :return: :math:`\sqrt{a}`.
     """
-    # TODO: 7 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return 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: 9 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return pi
+    # 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))

cp/ex04/palindrome.py

-"""Exercise 4.1: Checking if a word is a palindrome."""
+"""Exercise 4.3: Checking if a word is a palindrome."""
 
 def is_palindrome(word : str) -> bool:
     """Check if ``word`` is a palindrome.
@@ -6,10 +6,9 @@ def is_palindrome(word : str) -> bool:
     :param word: The word to check
     :return: ``True`` if input is a palindrome and otherwise ``False``
     """
-    # TODO: 2 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return is_a_palindrome
+    # 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'))

cp/ex04/parenthesis.py

-"""Exercise 4.x-4.y."""
+"""Exercise 4.6-4.9."""
 def matching(expression :str) -> bool:
     """Tell if the parenthesis match in a mathematical expression.
 
@@ -7,9 +7,19 @@ def matching(expression :str) -> bool:
     :param expression: An expression containing zero or more parenthesis.
     :return: ``True`` if the number of open/close parenthesis match, otherwise ``False``
     """
-    # TODO: 9 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return matching
+    # 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:
@@ -23,15 +33,13 @@ def find_index_of_equality(expression : str) -> int:
     - ``"(()"``
     - ``"())"``
 
-    In this case the left-hand part contains ``2`` opening parenthesis and ``2`` closign parenthesis so ``i`` is the right index.
+    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: 6 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return i
+    # TODO: Code has been removed from here. 
 
 
 def print_the_dialogue(s : str):
@@ -43,26 +51,12 @@ def print_the_dialogue(s : str):
 
     :param s: The manuscript as a ``str``.
     """
-    # TODO: 4 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-
-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: 3 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return inner_part
+    # 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"))

cp/ex04/play_hangman.py

-"""Play a game of hangman by loading a random word."""
-import random
-import os
-
-def load_words() -> list:
-    """
-    Return a list of valid words. Words are strings of lowercase letters.
-
-    Depending on the size of the word list, this function may
-    take a while to finish.
-
-    :return: The available words as a list.
-    """
-    from cp.ex08.words import load_words
-    wordlist = load_words(os.path.join(os.path.dirname(__file__), "files", "5000-words.txt")).split()
-    return wordlist
-
-
-def choose_word() -> str:
-    """Select a word at random.
-
-    :return: A randomly selected word, useful for playing hangman.
-    """
-    wordlist = load_words()
-    return random.choice(wordlist)

cp/ex04/prefix.py

-"""Exercise XX."""
-
+"""Exercise 4.10-4.11."""
 
 def common_prefix(word1 : str, word2 : str) -> str:
     """
@@ -9,9 +8,7 @@ def common_prefix(word1 : str, word2 : str) -> str:
     :param word2: Second word
     :return: The longest common prefix.
     """
-    # TODO: 6 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return prefix
+    # TODO: Code has been removed from here. 
 
 def common_prefix3(word1 : str, word2 : str, word3 : str) -> str:
     """
@@ -22,12 +19,10 @@ def common_prefix3(word1 : str, word2 : str, word3 : str) -> str:
     :param word3: Third word
     :return: The longest common prefix.
     """
-    # TODO: 1 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return prefix
+    # TODO: Code has been removed from here. 
 
 
-# Driver Code
 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"))

cp/ex05/average.py

+"""Exercise 5.2. Average of lists."""
+
+def calculate_average(nums: list) -> float:
+    """Return the average of a list of numbers.
+    
+    :param nums: list of numbers
+    :return: average of list
+    """
+    # TODO: Code has been removed from here. 

cp/ex05/best_buy.py

+"""Exercise 5.11. Best Buy."""
+
+def best_buy(prices: list, money: int, start_index: int, reverse: bool) -> int:
+    """Return the number of items that can be bought with the given amount of money. The function should be able to handle arbitrary starting points and to run the list in reverse.
+    
+    :param prices: list of prices
+    :param money: amount of money
+    :param start_index: starting index in list
+    :param reverse: boolean to indicate if list should be run in reverse
+    :return: number of items that can be bought with the given amount of money
+    """
+    # TODO: Code has been removed from here. 

cp/ex05/conditioned_maximum.py

+"""Exercise 5.3-5.4. Conditioned maximum."""
+
+def conditioned_maximum(nums: list, threshold: float) -> float:
+    """Return the maximum of a list of numbers, that is strictly smaller than the given threshold.
+    
+    :param nums: list of numbers
+    :param threshold: limit for maximum value   
+    :return: maximum of list thats smaller than the threshold
+    """
+    # TODO: Code has been removed from here. 
+
+
+def conditioned_maximum_name(nums: list, names: list, threshold: float) -> str:
+    """Return the name of the maximum of a list of numbers, that is smaller than the given threshold.
+    
+    :param nums: list of numbers with animal heights.
+    :param names: list of animal names
+    :param threshold: limit for maximum value   
+    :return: animal name with the corresponding maximum height, which is shorter than the threshold height.
+    """
+    # TODO: Code has been removed from here. 

cp/ex05/multiples.py

+"""Exercise 5.8.-5-9. Count multiples."""
+
+def count_multiples(numbers: list, m: int)  -> int:
+    """Count the number of numbers that are divisible by m.
+    
+    :param numbers: list of numbers
+    :param m: number to divide by
+    :return: number of numbers that are divisible by m
+    """
+    # TODO: Code has been removed from here. 
+
+def multiples_list(numbers: list, m: int)  -> list:
+    """Make a list with all numbers from a list that are divisible by m.
+    
+    :param numbers: list of numbers
+    :param m: number to divide by
+    :return: list of numbers that are divisible by m
+    """
+    # TODO: Code has been removed from here. 

cp/ex05/rectangular.py

+"""Exercise 5.6. Rectangular list."""
+
+def is_rectangular(nested_list: list) -> bool:
+    """Check if a list is rectangular.
+    
+    :param nested_list: nested list
+    :return: True if list is rectangular, False otherwise
+    """
+    # TODO: Code has been removed from here. 

cp/ex05/short_words.py

+"""Exercise 5.5. short words."""
+
+def short_words(words: str, max_len: int) -> str:
+    """Return a string of words that are shorter than max_len.
+    
+    :param words: string of words
+    :param max_len: maximum length of words 
+    :return: string of words that are shorter than max_len
+    """
+    # TODO: Code has been removed from here. 

cp/ex05/tictactoe.py

+"""Exercise 5.12-5-16. TicTacToe."""
+def get_game_state(board: list) -> str:
+    """Check if a player has won the game, if it's a draw, or if it's ongoing.
+
+    :param board: List of lists of strings representing the game board.
+    :return: A string which is 'X' if player 'X' won, 'O' if player 'O' has won, 'Draw' if the game is a draw, or '-' if the game is ongoing.
+    """
+    # TODO: Code has been removed from here. 
+
+def update_board(board : list, player: str, position: list) -> list:
+    """Update the game board with the player's move.
+
+    :param board: List of lists of strings representing the game board.
+    :param player: Player making the move ('X' or 'O').
+    :param position: List containing two integer indices [row, column] indicating the position to make a move.
+    :return: Updated game board after the move.
+    """        
+    # TODO: Code has been removed from here. 
+
+def print_board(board: list):
+    """Print the current state of the game board.
+    
+    :param board: List of lists of strings representing the game board.
+    """
+    # TODO: Code has been removed from here. 
+
+def tictactoe(board: list, player: str, position: list) -> list:
+    """Play a move in the Tic-Tac-Toe game and determine the winner.
+    
+    :param board: List of lists of strings representing the game board.
+    :param player: Player making the move ('X' or 'O').
+    :param position: List containing two integer indices [row, column] indicating the position to make a move.
+    :return: Updated game board after the move.
+    """
+    # TODO: Code has been removed from here. 

cp/ex05/vector_add.py

+"""Exercise 5.7. Vector additon."""
+
+def vector_add(v: list, w: list) -> list:
+    """Add two vectors.
+    
+    :param v: vector 1 (list of numbers)
+    :param w: vector 2 (list of numbers, same length as v)
+    :return: sum of v and w (list of number)
+    """
+    # TODO: Code has been removed from here. 

cp/ex05/water_height.py

+"""Exercise 5.10. Water height."""
+
+def water_height(h0: int, r: list) -> int:
+    """Calculate the water height after multiple days of rain.
+
+    :param: h0: initial height of the water
+    :param: r: list of rain showers
+    :return: height of water after days of rain 
+    """
+    # TODO: Code has been removed from here.