Compare revisions

*.artifacts.pkl

.coveragerc

*_tests_complete_grade.py

tmp.txt

tmp.zip

# Lock file. DISABLE checking with gitlab (and syncing), so you *wnat* this on your computer, but *not* on the students computer.

**/unitgrade_data/dont_check_remote.lock

cp/ex03/simple_function.py

cp/tests/unitgrade_data/Week01Dummy.pkl

cp/tests/unitgrade_data/Week01Palindrome.pkl

######################## Comment these out upon release. #############################

cp/ex05

cp/ex06

cp/ex07

cp/ex08

cp/ex09

cp/ex10

cp/ex11

cp/ex12

cp/exam

cp/project1

#cp/project1

#cp/project2

cp/project3

#cp/project3

cp/project4

cp/project5

cp/project6

cp/tests/tests_week01.py

#*04*

#*05*

#*06*

*07*

*08*

*09*

*10*

*11*

*12*

"""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)

"""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))

"""Exercise 2.1: Printing full name."""

def full_name(first_name:str, last_name:str):

    """Determine and print the full name given first name and last name.

    :param first_name: your first name.

    :param last_name: your last name.

    """

    # TODO: Code has been removed from here.

    raise NotImplementedError("Insert your solution and remove this error.")

"""Exercise: Estimate fetal weight using Hadlock formula."""

import math

def hadlock(head_circ:float,abdominal_circ:float,femur_length:float):

    """Estimate fetal weight using Hadlock formula.

    :param head_circ: head circumference in cm.

    :param abdominal_circ: abdominal circumference in cm.

    :param femur_length: femur length in cm.

    """

    # TODO: Code has been removed from here.

    raise NotImplementedError("Insert your solution and remove this error.")

"""Exercise 2.3: Printing number of characters in name."""

def name_length(name:str):

    """Calculate and print the number of characters in name.

    :param name: your name.

    """

    # TODO: Code has been removed from here.

    raise NotImplementedError("Insert your solution and remove this error.")

"""Exercise 2.2: Round a number to the next nearest thousand."""

import math

def next_thousand(a:int):

    """Round a number to the next nearest thousand and print.

    :param a: the number to be rounded.

    """

    # TODO: Code has been removed from here.

    raise NotImplementedError("Insert your solution and remove this error.")

"""Exercise 2.5: Calculate the normal weight range for a given height."""

import math

def normal_weight(height:float):

    """Calculate and print the range of normal weights for a given height.

    :param height: the height.

    """

    # TODO: Code has been removed from here.

    raise NotImplementedError("Insert your solution and remove this error.")

"""Exercise 2.6: Calculate the lowest survival temperature."""

def survival_temperature(metabolic_heat:int, thermal_conductance:float):

    """Calculate and print the lowest survival temperature.

    :param metabolic_heat: the metabolic heat production.

    :param thermal_conductance: the thermal conductance.

    """

    # TODO: Code has been removed from here.

    raise NotImplementedError("Insert your solution and remove this error.")

"""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

"""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.")

"""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.

"""Exercise: Convert length in foot and inch to centimeter."""

import math

def unit_conversion(foot:int, inch:int):

    """Convert length in foot and inch to centimeter.

    :param foot: foot portion of the length in imperical unit.

    :param inch: inch portion of the length in imperical unit.

    """

    # TODO: Code has been removed from here.

    raise NotImplementedError("Insert your solution and remove this error.")

"""Exercise 2.4: Wind chill."""

def wind_chill(temperature:int, windspeed:float):

    """Calculate and print the wind chill temperatures.

    :param temperature: the actual temperature.

    :param windspeed: the wind speed.

    """

    # TODO: Code has been removed from here.

    raise NotImplementedError("Insert your solution and remove this error.")

"""Exercise 3.9: Ackermann's function."""

"""Exercise 3.10: Ackermann's function."""

def ackermann(m:int, n:int):

    """Compute the Ackermann's function :math:`A(m, n)`.

    :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.")

    # TODO: Code has been removed from here. 

"""Exercise 3.5: BAC Calculator."""

"""Exercise 3.6: 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 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

    # TODO: Code has been removed from here. 

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)

    """

    # TODO: 1 lines missing.

    raise NotImplementedError("Compute f(x) here.")

    return y

    # TODO: Code has been removed from here. 

def is_there_a_root(a : float, b : float) -> bool:

    :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

    # TODO: Code has been removed from here. 

def bisect(xmin : float, xmax : float, delta : float) -> float:

    """Find a candidate root within ``xmin`` and ``xmax`` within the given tolerance.

    :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))

    # TODO: Code has been removed from here. 

    print("Should return math.nan")

    print(bisect(1, 3.5, 0.1))

"""Exercise 3.4: Body Temperature."""

def body_temperature(temperature : float) -> str:

def body_temperature(temperature):

    """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

    # TODO: Code has been removed from here. 

"""Exercise 3.3: Compare numbers."""

"""Exercise 3.5: 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 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

    # TODO: Code has been removed from here. 

"""Exercise 3.8: Exponential function."""

"""Exercise 3.9: Exponential function."""

def exponential(x : float, n : int) -> float:

    """Compute the exponential :math:`x^n` using recursion.

    :param n: the power :math:`n`.

    :return: the computed value.

    """

    # TODO: 6 lines missing.

    raise NotImplementedError("Insert your solution and remove this error.")

    # TODO: Code has been removed from here. 

"""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.

    :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. 

"""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 :-).") 

"""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. 

"""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.

        | 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):

    :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")

"""Exercise 4.12-4.16."""

def is_word_guessed(secret_word : str, letters_guessed : str) -> bool:

    """Determine if the word has been guessed.

    :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:

    :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.

    :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"))

    :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))

"""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.

    :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'))

"""Exercise 4.x-4.y."""

"""Exercise 4.6-4.9."""

def matching(expression :str) -> bool:

    """Tell if the parenthesis match in a mathematical expression.

    :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:

    - ``"(()"``

    - ``"())"``

    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):

    :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"))

"""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)

"""Exercise XX."""

"""Exercise 4.10-4.11."""

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:

    """

    :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"))

"""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. 

"""Exercise 5.11. Best Buy."""