Uke 8¶
Oppgave 1
def return_change(payment, price):
coins = [20, 10, 5, 1]
difference = payment - price
change = []
for coin in coins:
while difference >= coin:
change.append(coin)
difference -= coin
return change
Oppgave 2
def pearson_corr(xs, ys):
mean_x = sum(xs) / len(xs) # calculate mean of x
mean_y = sum(ys) / len(ys) # calculate mean of y
dx = [(x - mean_x) for x in xs] # (x - x_mean)
dy = [(y - mean_y) for y in ys] # (y - y_mean)
sum_dxdy = sum([x * y for x, y in zip(dx, dy)]) # covariance
dx2 = sum([x * x for x in dx]) # x-standard deviation
dy2 = sum([y * y for y in dy]) # y-standard deviation
sqrt_dx2dy2 = (dx2 * dy2) ** 0.5
r = sum_dxdy / sqrt_dx2dy2 # coefficient
return r
Oppgave 3
my_fridge = [
"tomato sauce",
"mustard",
"potatoes",
"carrots",
"chicken",
"frozen fish",
]
meals = [
# name of dish [0], ingredients [1]
("fish_sticks", ["frozen fish", "potatoes", "mustard"]),
("chicken_curry", ["chicken", "curry paste", "carrots", "potatoes", "rice"]),
("chicken_veg", ["chicken", "potatoes", "carrots"]),
("pasta", ["spaghetti", "tomato sauce"]),
]
# end goal: [fish_sticks, chicken_veg]
def meal_list(fridge, ingredient_list):
"""
1. set up a tally that counts the ingredients you do have for a given
meal in your fridge
2. _for each_ ingredient in a meal
3. check _if_ that ingredient is in your fridge
4. _add_ to tally of ingredients for a given meal that are in your fridge
5. once you have looped through the ingredient list,
check _if_ your count tally matches the number of items in the ingredient list
"""
count = 0
for ingredient in ingredient_list:
if ingredient in fridge:
count += 1
return count == len(ingredient_list)
# if you really want it on one line, this works, too:
# return sum(i in fridge for i in ingredient_list) == len(ingredient_list)
def meal_options(fridge, meals):
"""
1. _for each_ tuple pair in meals
2. run meal_list()
3. _if_ function evaluates to true, then add to a new list of meals that are possible to make
"""
meal_options_ls = []
for meal in meals:
if meal_list(fridge, meal[1]):
meal_options_ls.append(meal[0])
return meal_options_ls
Oppgave 4
from math import log
# no error check required
a = int(input("Factor A: "))
b = int(input("Factor B: "))
# keep original input for printout later
in_a, in_b = a, b
if a > b:
a, b = b, a
maxbinary = int(log(a, 2))
# using reverse order, since we start with the biggest binary
reverse_table = reversed([(2 ** n, b * 2 ** n) for n in range(maxbinary + 1)])
# manual list build
#
# table = []
# n = 1
# while n <= a:
# table.append((n, b))
# n *= 2
# b *= 2
# reverse_table = reversed(table)
# output strings
output = []
# marked numbers (for use in the + lines later)
a_list, b_list = [], []
# pick out the Xs
for bin, bfact in reverse_table:
if bin <= a:
tag = "X"
a -= bin
a_list.append(bin)
b_list.append(bfact)
else:
tag = " "
output.append(f"{tag} {bin:4d} {bfact:4d}")
# reverse all lists back to increasing
for l in (a_list, b_list, output):
l[:] = reversed(l)
divider = "=" * 25
print(divider)
print("\n".join(output))
print(divider)
print(" + ".join(map(str, a_list)), "=", sum(a_list))
print(" + ".join(map(str, b_list)), "=", sum(b_list))
print(divider)
print(f"{in_a} * {in_b} = {in_a * in_b}")
Oppgave 5
N_seats = 15
parties = ["H", "Ap", "FrP", "SP", "SV", "KrF", "R", "V", "MdG"]
votes = [
74282,
68945,
38352,
29981,
26901,
14724,
14150,
13163,
11940,
]
def valgresultat(parties, votes, mandater):
"""
1. zip tuple
2. calculate vote count factors using mandate (for Hordaland is 15)
3. calculate ranking for each party with each vote count factor
4. sort rankings from highest to lowest across all parties for all factors
5. slice out first 15 rankings from rankings list (=15 seats)
"""
vote_data = tuple(zip(parties, votes))
divisor = [1.4] # first number will always be 1.4, initialize list with this
for n in range(1, mandater):
next = 2 * n + 1
divisor.append(next)
# list comprehension way:
# divisor = [1.4] + [2 * n + 1 for n in range(1, mandater)]
ranking = []
for party, count in vote_data:
for i, f in enumerate(divisor, 1):
ranking.append((count / f, f"{party}")) # f"{party}{i}"
ranking.sort(reverse=True)
assigned_seats = ranking[:mandater]
return assigned_seats
def parti_mandater(party_list, votes, mand):
"""
1. loop through each party in master data list
2. count number of seats and add to total
"""
assigned_seats = valgresultat(party_list, votes, mand)
mandater = [] # ('H', 74282, 4),()
for name, num_votes in zip(party_list, votes):
num_seats = 0
for _, seat_name in assigned_seats:
if name == seat_name:
num_seats += 1
if num_seats > 0:
mandater.append((name, num_votes, num_seats))
return mandater
def pretty(mandater):
result = ["Parti Stemmer Mandater"]
width = len(result[0])
result.append(width * "=")
for name, votes, seats in mandater:
result.append(f"{name:5} {votes:8d} {seats:9d}")
return "\n".join(result)
Oppgave 6
def line_w_whitespace(words, len_w_one_space, line_len):
"""Add whitespace evenly to a list of words to return
a string of given length.
words: a list of strings
len_w_one_space: an integer, combined length of words
with one space between
line_len: an integer, length of output string
"""
extra_spaces = line_len - len_w_one_space
positions = len(words) - 1
equal_spaces = extra_spaces // positions + 1
remaining_spaces = extra_spaces % positions
# add the leftover spaces to the last few words
for i in range(remaining_spaces):
words[-(i % positions + 2)] += " "
# add equal number of spaces for the rest
return (" " * equal_spaces).join(words)
def justify(text, line_len):
"""Justify margins of a text to be straight with lines
of given length.
text: a string, the text to be justified
line_len: an integer, the length of the output lines
"""
words = text.split()
if not words:
return ""
current_line = words[:1]
current_len = len(current_line[0])
justified_text = ""
for w in words[1:]:
word_len = len(w)
if current_len + word_len + 1 <= line_len:
current_line.append(w)
current_len += word_len + 1
else:
justified_text += (
line_w_whitespace(current_line, current_len, line_len) + "\n"
)
current_line = [w]
current_len = word_len
justified_text += " ".join(current_line)
return justified_text