Mixed-Up Code Questions

Section 10.9 Mixed-Up Code Questions

Checkpoint 10.9.1.

Create a function letter_dict that takes in string as a parameter and returns a dictionary containing the amount of times letters appear in the given string. For example, letter_dict('It is') should return {'i': 2, 't': 1, 's': 1}. (Note: Pretend the string doesn't have any punctuation besides spaces.)

def letter_dict(string):
---
    d = dict()
---
    d = dictionary()  #paired
---
    for char in string:
---
        if char == ' ':
---
        if char = ' ':  #paired
---
            continue
---
            break  #paired
---
        if char.lower() not in d:
---
        if char in d:  #paired
---
            d[char.lower()] = 1
---
        else:
---
            d[char.lower()] += 1
---
    return d

Checkpoint 10.9.2.

Create a function word_dict that takes in string as a parameter and returns a dictionary containing the amount of times a word appears in the given string. For example, word_dict('HELLO heLlo there ') should return {'hello': 2, 'there': 1}. (Note: Pretend the string doesn't have any punctuation besides spaces.)

def word_dict(string):
---
    dictionary = {}
---
    for word in string.split():
---
    for word.lower() in string.split():  #paired
---
        dictionary[word.lower()] = dictionary.get(word.lower(), 0) + 1
---
        dictionary[word.lower()] = dictionary.get(word.lower(), 0)  #paired
---
    return dictionary

Checkpoint 10.9.3.

Create a function a_counter that takes in string as a parameter, creates a dictionary, and returns the amount of a's in the given string using the dictionary. For example, a_counter('Alice and Apples') should return 3.

def a_counter(string):
---
    dictionary = {}
---
    for char in string:
---
    for char in string.split():  #paired
---
        dictionary[char.lower()] = dictionary.get(char.lower(), 0) + 1
---
        dictionary[char.lower()] = dictionary.get(char.lower(), 0)  #paired
---
    return dictionary.get('a', 0)
---
    return dictionary['a']  #paired

Checkpoint 10.9.4.

Create a function called sales_tax that takes in a list_of_costs (floating point values) as a parameter and returns a dictionary with the original costs as keys and the final costs after the sales tax of 6 percent as values. The final costs should be rounded to the hundredths place. For example, sales_tax([1.25, 8, 5]) returns {1.25: 1.33, 8: 8.48, 5: 5.3}.

def sales_tax(list_of_costs):
---
    final_dictionary = {}
---
    final_dictionary = []  #paired
---
    for cost in list_of_costs:
---
        final_dictionary[cost] = round(cost * 1.06, 2)
---
        final_dictionary[cost] = round(cost * 0.06, 2)  #paired
---
    return final_dictionary

Checkpoint 10.9.5.

Create a function called discount_and_tax that takes in a list_of_costs (floating point values) and a discount percentage as parameters and returns a dictionary with the original costs as keys and the final costs after applying the discount (first) and the sales tax of 6 percent (second) as values. The final costs should be rounded to the hundredths place. For example, discount_and_tax([1.25, 8, 5], 20) should return {1.25: 1.06, 8: 6.78, 5: 4.24}.

def discount_and_tax(list_of_costs, discount):
---
    discount_multiplier = 1 - (discount / 100)
---
    discount_multiplier = (discount / 100)  #paired
---
    dictionary = {}
---
    for cost in list_of_costs:
---
        dictionary[cost] = round(cost * discount_multiplier * 1.06, 2)
---
        dictionary[cost] = round(cost * discount_multiplier * 0.06, 2)  #paired
---
    return dictionary

Checkpoint 10.9.6.

Create a function called create_dictionary that takes in keys_list and values_list as parameters and returns a dictionary with the keys_list as keys and the values_list as values. Assume keys_list and values_list are the same length, and they only contain numbers and strings. For example, create_dictionary(['one', 'two', 'three'], [1, 2, 3]) should return {'one': 1, 'two': 2, 'three': 3}.

def create_dictionary(keys_list, values_list):
---
    combination = {}
---
    for i in range(len(keys_list)):
---
    for i in len(keys_list):  #paired
---
        combination[keys_list[i]] = values_list[i]
---
        combination[keys_list[i]] = combination[values_list[i]]  #paired
---
    return combination

Checkpoint 10.9.7.

Create a function called lowest_value_keys that takes in dictionary as a parameter and returns a list of the keys containing the lowest value of all the keys in the dictionary. Assume all values of the dictionary are integers or floats. For example, lowest_value_keys({'pizza': 11, 'fruits': 0, 'toys': 0, 'rice bags': 1.9, 'ice': 1.8}) should return ['fruits', 'toys'].

def lowest_value_keys(dictionary):
---
    keys_list = []
---
    minimum = min(dictionary.values())
---
    minimum = min(dictionary)  #paired
---
    minimum = minimum(dictionary) 
---
    for key, value in dictionary.items():
---
    for value in dictionary.values():  #paired
---
    for key in dictionary.keys(): 
---
        if value == minimum:
---
            keys_list.append(key)
---
    return keys_list

Checkpoint 10.9.8.

Create a function called duplicated_data that takes in dictionary1 and dictionary2 as parameters and returns a dictionary with key-value pairs that are in both dictionaries. For example, duplicated_data({'Ten': 10, 'Twenty' : 20, 'Thirty' : 30}, {'Ten': 10, 'Twenty' : 20}) should return {'Ten': 10, 'Twenty': 20}.

def duplicated_data(dictionary1, dictionary2):
---
    dict = {}
---
    for key, value in dictionary1.items():
---
    for key, value in dictionary2:  #paired
---
    for key, value in dictionary2.items(): 
---
        if dictionary2.get(key) == value:
---
        if dictionary2[key] == value:  #paired
---
            dict[key] = value
---
    return dict

Checkpoint 10.9.9.

Create a function called total_price that takes in quantity_dict and price_dict and returns the total cost of all items. Assume keys in both dictionaries are the same, and the values in quantity_dict are integers. For example, total_price({'fries': 7, 'hot dogs': 9, 'soda': 9}, {'fries': 1.5, 'hot dogs': 1, 'soda': 1.1}) should return 29.4.

def total_price(quantity_dict, price_dict):
---
    total_price = 0
---
    for key in quantity_dict.keys():
---
    for value in quantity_dict.values():  #paired
---
        total_price += quantity_dict.get(key) * price_dict.get(key)
---
        total_price += quantity_dict[key] + price_dict[key]  #paired
---
    return total_price

Checkpoint 10.9.10.

Create a function called scale_recipe that takes in quantity_dict and scale_factor as parameters and returns a dictionary with quantity_dict scaled by the scale_factor. For example, scale_recipe({'fries': 7, 'hot dogs': 9, 'soda': 8}, 4) should return {'fries': 28, 'hot dogs': 36, 'soda': 32}.

def scale_recipe(quantity_dict, scale_factor):
---
    for key in quantity_dict.keys():
---
        quantity_dict[key] = quantity_dict.get(key) * scale_factor
---
        quantity_dict[key] = quantity_dict.get(key) / scale_factor  #paired
---
    return quantity_dict

Python for Everyone: The PreTeXt Interactive Edition

Search Results: