Removed future files

cp/ex01/examples.py

-"""A handful of python programming examples."""
-# Example 1
-print("Hello world")
-
-# Example 2
-print("hello")
-print("world")
-
-a = 2
-b = 3
-c = 1
-x = 3
-y = a*x**2 + b * x + c
-
-# Example 3
-def second_poly(x):
-    """Compute a first order polynomial.
-
-    :param x: Input value :math:`x`
-    :return: :math:`y = 2x + 4`
-    """
-    return 2 * x + 4
-
-# example 4
-def say_hello(name):
-    """Print out "Hello {name}.
-
-    :param name: The name to say hello to
-    """
-    print("Hello " + name)

cp/ex02/__init__.py

-"""This package represents exercise 1."""

cp/ex02/fibonacci.py

-"""Exercise 2.3: The Fibonacci sequence and recursion."""
-
-def fibonacci_number(k):
-    """Compute the :math:`k`'th Fibonacci number :math:`x_k`.
-
-    The function use the recursive relationship :math:`x_{k+1} = x_k + x_{k-1}`, along with the initial conditions
-    :math:`x_0 =0, x_1 = 1`, to complete the sequence up to :math:`k`.
-
-    :param k: An integer
-    :return:  The corresponding term :math:`x_k` of the Fibonacci sequence as an integer.
-    """
-    if k == 0:
-        # TODO: 1 lines missing.
-        raise NotImplementedError("Insert your solution and remove this error.")
-    elif k == 1:
-        # TODO: 1 lines missing.
-        raise NotImplementedError("Insert your solution and remove this error.")
-    else:
-        # TODO: 1 lines missing.
-        raise NotImplementedError("Fix this stuff")
-
-if __name__ == "__main__":
-    print("The term x_0 should be 0, you got:", fibonacci_number(0))
-    print("The term x_1 should be 1, you got:", fibonacci_number(1))
-    print("The term x_2 should be 1, you got:", fibonacci_number(1))
-    print("The term x_6 should be 8, you got:", fibonacci_number(6))

cp/ex02/taylor.py

-"""Problem 1.1."""
-def evaluate_taylor(x: float) -> float:
-    r"""Compute the third order taylor approximation.
-
-    Compute (and return) the Taylor approximation of :math:`\log(x)`. Remember the function must return a ``float``.
-
-    :param x: The input to evaluate.
-    :return: The taylor approximation of :math:`\log(x)`, i.e. :math:`y`
-    """
-    # TODO: 1 lines missing.
-    raise NotImplementedError("Define y = (x-1) - 1/2 * ... here.")
-    return y

cp/ex02/taylor_variant1.py

-"""Problem 1.2. Implement a function that computes (and return) the third order Taylor-approximation here."""
-# TODO: Code has been removed from here.
-raise NotImplementedError("Insert your solution and remove this error.")

cp/ex02/taylor_variant2.py

-"""Problem 1.3. Compute the third order taylor approximation evaluated in x here and store it in a variable y."""
-
-x = 1.5
-# Define y = ... here.
-# TODO: 1 lines missing.
-raise NotImplementedError("Insert your solution and remove this error.")
-# print(y) should work.

cp/ex03/__init__.py

-"""Exercises for week 3."""

cp/ex03/ackermann.py

-"""Exercise 3.9: Ackermann's function."""
-
-def ackermann(m:int, n:int):
-    """Compute the Ackermann's function :math:`A(m, n)`.
-
-    Your implementation should use recursion and not loops.
-
-    :param m: the variable m.
-    :param n: the variable n.
-    :return: the computed value :math:`A(m,n)`.
-    """
-    # TODO: 5 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")

cp/ex03/bac_calculator.py

-"""Exercise 3.5: BAC Calculator."""
-
-
-def bac_calculator(alcohol_consumed: float, weight: float, gender: str, time: float) -> float:
-    """Calculate the blood alcohol concentration based on the alcohol consumed, body weight, and time since consumption.
-    
-    :param alcohol_consumed: The total amount of alcohol consumed in grams (float)
-    :param weight: The person's body weight in kilograms (float)
-    :param gender: The person's gender, which must be a string of either "male" or "female" (str)
-    :param time: The time elapsed since alcohol consumption in hours (float)
-    :return: The calculated blood alcohol concentration (BAC) as a float value.
-    """
-    # TODO: 10 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return bac

cp/ex03/bisect.py

-"""Problems for the Bisection project in week 3."""
-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:
-
-    .. 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)`.
-    """
-    # TODO: 1 lines missing.
-    raise NotImplementedError("Compute f(x) here.")
-    return y
-
-
-def is_there_a_root(a : float, b : float) -> bool:
-    """Return ``True`` if we are guaranteed there is a root of ``f`` in the interval :math:`[a, b]`.
-
-    :param a: Lowest x-value to consider
-    :param b: Highest x-value to consider
-    :return: ``True`` if we are guaranteed there is a root otherwise ``False``.
-    """
-    # TODO: 1 lines missing.
-    raise NotImplementedError("Compute the condition here")
-    return has_root
-
-def bisect(xmin : float, xmax : float, delta : float) -> float:
-    """Find a candidate root within ``xmin`` and ``xmax`` within the given tolerance.
-
-    :param xmin: The minimum x-value to consider
-    :param xmax: The maximum x-value to consider
-    :param delta: The tolerance.
-    :return: The first value :math:`x` which is within ``delta`` distance of a root according to the bisection algorithm
-    """
-    # TODO: 6 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-
-
-
-if __name__ == "__main__":
-    print("Are we guaranteed there is a zero within the interval [1, 3]?", is_there_a_root(1, 3), "(this should be True)")
-    print("Are we guaranteed there is a zero within the interval [1, 3.5]?", is_there_a_root(1, 3.5), "(this should be False)")
-
-    print("Find a zero within tolerance 0.1 in the interval [1, 2]")
-    print(bisect(1, 2, 0.1))
-    print("Same, but with a tolerance of 0.5")
-    print(bisect(1, 2, 0.1))
-
-    print("Should return math.nan")
-    print(bisect(1, 3.5, 0.1))

cp/ex03/body_temperature.py

-"""Exercise 3.4: Body Temperature."""
-
-def body_temperature(temperature : float) -> str:
-    """Calculate the body's response based on the given temperature.
-    
-    :param temperature: The temperature in degrees Celsius.
-    :return: The body's response as a string.
-    """
-    # TODO: 10 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return response

cp/ex03/compare_numbers.py

-"""Exercise 3.3: Compare numbers."""
-
-def compare_numbers(first_number:int, second_number:int) -> str:
-    """Return a string based on which number has the greatest numerical value.
-
-    :param first_number: first number.
-    :param second_number: second number.
-    :return: string stating which number is the greatest.
-    """
-    # TODO: 6 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return comparison

cp/ex03/exponential.py

-"""Exercise 3.8: Exponential function."""
-
-def exponential(x : float, n : int) -> float:
-    """Compute the exponential :math:`x^n` using recursion.
-
-    First focus on the case where :math:`n=0`, then :math:`n > 0` and finally :math:`n < 0`.
-
-    :param x: the base number :math:`x`.
-    :param n: the power :math:`n`.
-    :return: the computed value.
-    """
-    # TODO: 6 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")

cp/ex03/heart_attack.py

-"""Exercise 3.7: 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.
-
-    :param age: The age of the person.
-    :param weight: The weight of the person in kilograms.
-    :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

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."""
-
-def solar_panel(move : bool, swap : bool, hot : bool, empty : bool):
-    """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?
-    """
-    # TODO: 19 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")

cp/ex04/__init__.py

-"""Exercises for week 4."""

cp/ex04/bug.py

-"""Exercise 4.2-4.3: 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: 5 lines missing.
-    raise NotImplementedError("Use print(...) to print the output 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: 4 lines missing.
-    raise NotImplementedError("Use print(...) to print the output here.")
-
-
-if __name__ == "__main__":
-    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.
-
-    :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: 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
-
-
-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: 2 lines missing.
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return letters
-
-
-
-def hangman(secret_word : str, guesses : str):
-    """
-    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.
-    raise NotImplementedError("Insert your solution and remove this error.")
-
-
-
-if __name__ == "__main__":
-    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)