Skill Tests

Skill Test #5 Practice Questions

Skill 1 (Time Complexity):

For this skill, you will analyze blocks of code and identify their time complexity using Big-O notation. Refer to lab06 for practice.

Skill 2 (Args + Default Args):

1. Write a function freqs that takes in an arbitrary number of integers and returns a dictionary mapping each integer to its frequency.

2. Write a function keep that takes in an arbitrary number of integers and a default argument keep_evens. If keep_evens is True, return a list of the even numbers; otherwise, return a list of the odd numbers. Make sure to fill out the function header.

Skill 3 (Kwargs):

1. Write a function oldest that takes in keyword arguments of the form name = age, and returns the name of the oldest person. If there is a tie, return the person whose name appears last among the keyword arguments.

2. Write a function reconstruct that takes in keyword arguments of the form string = frequency, and returns a list where each string appears frequency times.

Skill 4 (Recursion):

1. Given an integer n, write a function factorial that recursively computes n!. You may assume n is greater than 0.

2. Write a function calc_log2 that recursively computes log₂(num). You may assume num is a power of 2.

3. Given a list lst, write a function count that recursively counts the number of elements in lst.

4. Write a function count_ints that recursively counts how many elements in lst are integers.

5. Write a function banned that recursively checks whether banned_word appears in the list words.

6. Write a function palindrome that recursively checks whether a string is a palindrome (reads the same forward and backward). Refer to doctests.

7. Write a function evens_odds that recursively computes the difference between the sum of evens and the sum of odds in a list of integers, nums. Refer to doctests.

Requirements: Recursion only (no loops).

Code Editor

• skill_test_#5_practice_questions.py

### Skill #1: time complexity

# note: not going to provide practice problems here, refer to lab06
# you should feel comfortable looking at blocks of code and identifying
# the time complexity of the code

### Skill #2: args + default args

def freqs(*nums):
    """
    Takes in an abitrary number of integers, and returns
    a dictionary of the integers and their frequencies.

>>> freqs(0, 1, 1, 2, 2, 2)
    {0: 1, 1: 2, 2: 3}

>>> freqs(1, 2, 3, 4, 5)
    {1: 1, 2: 1, 3: 1, 4: 1, 5: 1}
    """
    return

def keep(*nums, keep_evens = None):
    """
    Takes in an arbitrary number of integers. If the default
    arg keep_evens is True it will keep the evens, otherwise,
    it will keep the odds. Return the evens/odds in a list.
    FILL OUT THE FUNCTION HEADER!!!

>>> keep(0, 1, 2, 3, 4, 5, 6, 7, 8)
    [0, 2, 4, 6, 8]

>>> keep(0, 1, 2, 3, 4, 5, 6, 7, 8, keep_evens = False)
    [1, 3, 5, 7]
    """
    return

### Skill #3: kwargs

def oldest(**people):
    """
    Takes in a list of keyword arguments of people and their
    ages, returns the name of the oldest person. If there are 
    ties, return the person whose name appears last.

>>> oldest(anish = 20, carter = 19, ty = 19)
    'anish'

>>> oldest(carter = 19, ty = 19)
    'ty'
    """
    return

def reconstruct(**freqs):
    """
    Takes in a list of keyword arguments of the form:
    string = frequency, reconstructs a list, where
    each string appears frequency times. Refer to doctests.

>>> reconstruct(one = 1, two = 2, three = 3)
    ['one', 'two', 'two', 'three', 'three', 'three']
    """
    return

# Skill #4: Recursion

def factorial(n):
    """
    Recursively calculates n!, n > 0

>>> factorial(1)
    1

>>> factorial(5) # 5 * 4 * 3 * 2 * 1 = 120
    120
    """
    
def calc_log2(num):
    """
    Recursively calculates the log base 2 of a number. 
    You can assume num = 2 ** ?.

>>> calc_log2(1)
    0

>>> calc_log2(2)
    1

>>> calc_log2(64)
    6
    """

def count(lst):
    """
    Recursively counts the number of elements in a list.

>>> count([1, 2, 3, 4])
    4

>>> count(["h", "e", "l", "l", "o"])
    5
    """

def count_ints(lst):
    """
    Recursively counts the number of INTEGERS in a list.

>>> count_ints([1, 2, 3, 4])
    4

>>> count_ints(["h", "e", "l", "l", "o"])
    0
    """

def banned(words, banned_word):
    """
    Recursively checks if the banned_word is in the list
    of words.

>>> banned(["a", "b", "c"], "a")
    True

>>> banned(["b", "c", "d"], "a")
    False
    """

def palindrome(word):
    """
    Takes in a word and checks if the word is a palindrome 
    recursively. Returns True if it is, False otherwise.

>>> palindrome("racecar")
    True

>>> palindrome("anish")
    False
    """
    
def evens_odds(nums):
    """
    Recursively calculates the difference
    between the sum of the evens and the sum
    of the odds in the list of integers.

>>> evens_odds([1, 2, 3, 4, 5]) # (2 + 4) - (1 + 3 + 5) = -2
    -3

>>> evens_odds([1, 3, 5])
    -9

>>> evens_odds([2, 4, 6])
    12
    """

Python UTF-8

Saved Ln 1, Col 1

Console

Output

Press Cmd/Ctrl + Enter to run tests

Code output and test results will appear here...