Initial commit

Author: github-classroom[bot]

.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+.idea/
+*.iml
+.vscode
+__pycache__
+*pyc
+*.ipynb_checkpoints
+venv/

exam1/README.md

@@ -0,0 +1,74 @@
+## Exercise 1
+
+Open the program called *converter.py*
+
+* Remove the line containing the pass statement and implement the functionality described in the docstring.
+* Run the unit tests to validate that the implementation passes unit tests. 
+
+```
+python3 -m unittest exam1.test_converter
+```
+
+## Exercise 2
+
+Open the program called *evaluator.py*
+
+* Remove the line containing the pass statement and implement the functionality described in the docstring.
+* Run the unit tests to validate that the implementation passes unit tests. 
+
+```
+python3 -m unittest exam1.test_evaluator
+```
+
+## Exercise 3 
+
+[Leap years](https://www.timeanddate.com/date/leapyear.html) are years where an extra day is added to the end of 
+the month of February.
+
+Criteria to identify a leap year:
+* The year must be evenly divisible by 4;
+    * If the year can also be evenly divided by 100, it is not a leap year; unless
+        * The year is also evenly divisible by 400. Then it is a leap year.
+
+Open the program called *gregorian_cal_utils.py*
+
+* Remove the line containing the pass statement and implement the functionality described in the docstring.
+* Run the unit tests to validate that the implementation passes unit tests. 
+
+```
+python3 -m unittest exam1.test_gregorian_cal_utils
+```
+
+## Exercise 4
+
+Open the program called *loopty_loop.py*
+
+* Remove the line containing the pass statement and implement the functionality described in the docstring.
+* Run the unit tests to validate that the implementation passes unit tests. 
+
+```
+python3 -m unittest exam1.test_loopty_loop
+```
+
+## Exercise 5
+
+Open the program called *listies.py*
+
+* Remove the line containing the pass statement and implement the functionality described in the docstring.
+* Run the unit tests to validate that the implementation passes unit tests. 
+
+```
+python3 -m unittest exam1.test_listies
+```
+
+## Exercise 6
+
+Open the program called *dictionaries.py*
+
+* Remove the line containing the pass statement and implement the functionality described in the docstring.
+* Run the unit tests to validate that the implementation passes unit tests. 
+
+```
+python3 -m unittest exam1.test_dictionaries
+```
+

exam1/__init__.py

@@ -0,0 +1,24 @@
+# cases
+'''
+In some languages, it’s common to use camel case (otherwise known as “mixed case”) for variables’ 
+names when those names comprise multiple words, whereby the first letter of the first word is 
+lowercase but the first letter of each subsequent word is uppercase. For instance, whereas a variable 
+for a user’s name might be called name, a variable for a user’s first name might be called firstName, and a variable for a user’s preferred first name (e.g., nickname) might be called preferredFirstName.
+
+Python, by contrast, recommends snake case, whereby words are instead separated by underscores (_), 
+with all letters in lowercase. For instance, those same variables would be called name, first_name, 
+and preferred_first_name, respectively, in Python.
+
+In a file called cases.py, implement a function called camel2snake() that takes the name of a 
+variable in camel case and outputs the corresponding name in snake case. 
+Assume that the user’s input will indeed be in camel case.
+'''
+
+
+'''
+Now make one that does the opposite: snake2camel()
+'''
+
+
+def foo():
+    pass

exam1/cases.py

@@ -0,0 +1,48 @@
+def meters_to_feet(meters: float) -> float:
+    """
+    This function takes a float representing a measurement in meters
+    and returns the corresponding value converted to feet.
+    The result is rounded to 2 decimal places.
+
+    :param meters: A float representing a measurement in meters.
+    :return: A float representing the input measurement converted to feet.
+    """
+    pass  # implement me
+
+
+def feet_to_meters(feet: float) -> float:
+    """
+    This function takes a float representing a measurement in feet
+    and returns the corresponding value converted to meters.
+    The result is rounded to 2 decimal places.
+
+    :param feet: A float representing a measurement in feet.
+    :return: A float representing the input measurement converted to meters.
+    """
+    pass  # implement me
+
+
+def kilometer_to_miles(kilometers: float) -> float:
+    """
+    This function takes a float representing a measurement in kilometers
+    and returns the corresponding value converted to miles.
+    The result is rounded to 2 decimal places.
+
+    :param kilometers: A float representing a measurement in kilometers.
+    :return: A float representing the input measurement converted to miles.
+    """
+    pass  # implement me
+
+
+def miles_to_kilometers(miles: float) -> float:
+    """
+    This function takes a float representing a measurement in miles
+    and returns the corresponding value converted to kilometers.
+    The result is rounded to 2 decimal places.
+
+    :param miles: A float representing a measurement in miles.
+    :return: A float representing the input measurement converted to kilometers.
+    """
+    pass  # implement me
+
+

exam1/converter.py

@@ -0,0 +1,31 @@
+
+def delete_keys_from_dict(datadict, keylist):
+    """
+    Delete a list of keys from a dictionary
+    """
+    pass
+
+def check_dict_for_key(datadict, key):
+    """
+    Check if a value exists in a dictionary
+    (NO FOR loops!)
+    """
+    pass
+
+def get_key_of_min_value(ddd):
+    """
+    Get the key of the minimum value from a dictionary
+    """
+    pass
+
+def get_key_of_max_value(ddd):
+    """
+    Get the key of the maximum value from a dictionary
+    """
+    pass
+
+def letterfreq(word):
+    '''
+    # Write a function that returns a dictionary of letter frequencies from a word
+    '''
+    pass

exam1/dictionaries.py

@@ -0,0 +1,88 @@
+from typing import List, Tuple, Set, TypeVar
+
+N = TypeVar('N', int, float)
+C = TypeVar('C', List, Tuple)
+
+
+def find_lowest_value(list_in: List[N]) -> N:
+    """
+    Returns the lowest value in a list of numbers.
+
+    :param list_in: A list of numbers (integers and/or floats)
+    :return: The lowest number in the list
+    """
+    pass  # implement me
+
+
+def find_highest_value(list_in: List[N]) -> N:
+    """
+    Returns the highest value in a list of numbers.
+
+    :param list_in: A list of numbers (integers and/or floats)
+    :return: The highest number in the list
+    """
+    pass  # implement me
+
+
+def find_value(value_to_find, values: C) -> int:
+    """
+    This function evaluates whether a value exists within a List or a Set.
+    If the value exists, the function returns the index of the value in the collection.
+    If the value does not exist, the function returns -1.
+
+    :param value_to_find: A value that may or may not exist within a collection.
+    :param values: A List or a Set.
+    :return: an integer. Either the index where the value exists or -1
+    """
+    pass  # implement me
+
+
+def compare_two_numbers(a: N, b: N) -> int:
+    """
+    Compares two numbers.
+
+    If the numbers are the same, this function will return the number 0.
+    If the first number is greater than the second, this function will return the number 1.
+    If the second number is greater than the second, this function will return the number -1.
+
+    :param a: The first number.
+    :param b: The second number.
+    :return: an integer 0, 1, or -1
+    """
+    pass  # implement me
+
+
+def compare_two_strings(a: str, b: str) -> int:
+    """
+    Compares two strings.
+
+    If the strings have the same length, this function will return the number 0.
+    If the first string is longer than the second string, this function will return the number 1.
+    If the second string is longer than the first string, this function will return the number -1.
+
+    :param a: The first string.
+    :param b: The second string.
+    :return: an integer 0, 1, or -1
+    """
+    pass  # implement me
+
+
+def find_common(tuple_a: Tuple, tuple_b: Tuple) -> Set:
+    """
+    Given two tuples, this function returns a set containing items common in both tuples.
+
+    :param tuple_a: The first tuple.
+    :param tuple_b: The second tuple.
+    :return: A set containing items common on both tuples.
+    """
+    pass  # implement me
+
+
+def find_duplicates(tuple_in: Tuple) -> List:
+    """
+    Given a tuple, this function returns a list of the items that contain more than one instance.
+
+    :param tuple_in: A tuple
+    :return: a A list containing duplicate items in the tuple_in parameter
+    """
+    pass  # implement me

exam1/evaluator.py

@@ -0,0 +1,8 @@
+def is_leap_year(year: int) -> bool:
+    """
+    Given a year, this function returns a boolean indicating whether or not it is a leap year.
+
+    :param year: an integer indicating a year.
+    :return: A boolean indicating whether or not the year parameter is a leap year.
+    """
+    pass  # implement me

exam1/gregorian_cal_utils.py

@@ -0,0 +1,39 @@
+
+def drop_last(lst):
+    """
+    This function takes a list and returns a list with the last item removed.
+    """
+    pass  # implement me
+
+def drop_mangle(lst):
+    """
+    This function takes a list and returns a list with the first two items AND last item removed.
+    """
+    pass  # implement me
+
+def add_item_front(lst, a):
+    """
+    This function takes a list and an item,
+    returning the list with the item prepended to the list
+    """
+    pass  # implement me
+
+def add_item_end(lst, a):
+    """
+    This function takes a list and an item,
+    returning the list with the item appended to the list
+    """
+    pass  # implement me
+
+def drop_first_two(lst):
+    """
+    This function takes a list and returns a list with the first two items removed.
+    """
+    pass  # implement me
+
+def drop_last_two(lst):
+    """
+    This function takes a list and returns a list with the last two items removed.
+    """
+    pass  # implement me
+

exam1/listies.py

@@ -0,0 +1,26 @@
+from typing import Callable, List
+
+
+def generate_list(start: int, stop: int, step: int = 1) -> List[int]:
+    """
+    Generate a list of integers.
+
+    :param start: Where to start the list (inclusive).
+    :param stop: Where to stop the list (exclusive).
+    :param step: How many digits apart each number is from the others around it.
+    :return: A list of integers.
+    """
+    pass  # implement me
+
+
+def generate_list_with_strategy(start: int, stop: int, step: int, strategy: Callable) -> List[int]:
+    """
+    Generate a list of integers.
+
+    :param start: Where to start the list (inclusive).
+    :param stop: Where to stop the list (exclusive).
+    :param step: How many digits apart each number is from the others around it.
+    :param strategy: A function to manipulate each digit .
+    :return: A list of integers.
+    """
+    pass  # implement me