MT1 Sample TA Testing Solutions¶
Ex0¶
In [2]:
def cleanse_skater_names(skaters: list) -> list:
###
### YOUR CODE HERE
###
intermediate = [x.split() for x in skaters]
result = []
for name in skaters:
if ',' in name:
ind = name.split(',')
name = ind[0].title()
result.append(name.strip())
else:
vl = ''
ind = name.split()
for n in ind:
if n.isupper():
vl+= n.replace(',' , '').title() + ' '
result.append(vl.strip())
return result
In [3]:
def cleanse_skater_names(skaters: list) -> list:
###
### YOUR CODE HERE
###
cleansed_names = []
for name in skaters:
parts = name.split(',')
if len(parts) > 1:
cleansed_names.append(parts[0].title())
else:
words = name.split()
upper_words = [w for w in words if w.isupper()]
cleansed_names.append(" ".join(upper_words).title())
return cleansed_names
In [4]:
### Solution - Exercise 0
def cleanse_skater_names(skaters: list) -> list:
def capitalize_name(name):
return ' '.join(n.capitalize() for n in name.split())
r = []
for skater in skaters:
if ',' in skater:
last_name = skater.split(',')[0]
last_name_normalized = capitalize_name(last_name)
else:
upper_case_name = []
for word in skater.split():
if word.isupper():
upper_case_name.append(word)
last_name = ' '.join(upper_case_name)
r.append(capitalize_name(last_name))
return r
In [5]:
def cleanse_skater_names(skaters: list) -> list:
fin_names = []
for name in skaters:
if ',' in name:
last_name = name.split(',')[0]
#print(last_name)
else:
y = name.split(' ')
last_name = ' '.join(i for i in y if i.isupper())
fin_name = last_name.title()
#print(fin_name)
fin_names.append(fin_name)
return fin_names
In [6]:
def cleanse_skater_names(skaters: list) -> list:
###
### YOUR CODE HERE
###
ans = []
#print(skaters)
for skater in skaters:
if ',' in skater:
name_split = skater.split(",")
last_name = name_split[:-1]
#print(last_name)
else:
name_split = skater.split()
last_name = []
for word in name_split:
if word == word.upper():
last_name.append(word)
if " " not in last_name[0]:
for index, word in enumerate(last_name):
last_name[index] = word[0].upper() + word[1:].lower()
final_last_name = " ".join(last_name)
ans.append(final_last_name)
return ans
In [7]:
### Solution - Exercise 0
def cleanse_skater_names(skaters: list) -> list:
###
result =[]
for name in skaters:
name = name.strip()
if ',' in name:
last = name.split(',')[0]
else:
parts = name.split()
if parts[0].isupper():
i=0
while i< len(parts) and parts[i].isupper():
i+=1
last = " ".join(parts[:i])
else:
i = len(parts)- 1
last_parts = []
while i>= 0 and parts[i].isupper():
last_parts.insert(0, parts[i])
i-=1
last = " ".join(last_parts)
result.append(last.title())
return result
In [8]:
### Solution - Exercise 0
def cleanse_skater_names(skaters: list) -> list:
res = []
for n in skaters:
if ',' in n:
last = n.split(',')[0]
last = last.split()
last = ' '.join(l.title() for l in last)
else:
sns = n.split()
last = []
for w in sns:
if w.isupper():
last.append(w.title())
last = ' '.join(last)
res.append(last)
return res
In [9]:
def cleanse_skater_names(skaters: list) -> list:
###
### YOUR CODE HERE
###
l=[]
for i in skaters:
if ',' in i:
l.append(i.split(',')[0])
else:
ss=i.split(' ')
l.append(' '.join([s for s in ss if s==s.upper()]))
return [' '.join(ii[0].upper()+ii[1:].lower() for ii in i.split(' ')) for i in l]
Ex1¶
In [10]:
def compute_ranking(scores: dict) -> dict:
from collections import defaultdict
###
### YOUR CODE HERE
###
result = defaultdict(list)
for k,v in scores.items():
ind = []
sc_1 , sc_2 = v[0] , v[1]
for i in range(len(sc_1)):
tt = (k , round(sc_1[i] + sc_2[i] , 2))
result[f'J{i}'].append(tt)
return {j: sorted(sc , key = lambda x: (-x[1] , x[0])) for j,sc in result.items()}
In [11]:
def compute_ranking(scores: dict) -> dict:
###
### YOUR CODE HERE
###
ranking_by_judge = {}
for skater, scores in scores.items():
for i in range(len(scores[0])):
judge_index = f"J{i}"
if judge_index not in ranking_by_judge:
ranking_by_judge[judge_index] = []
total_score = scores[0][i] + scores[1][i]
skater_scores = (skater, round(total_score, 1))
ranking_by_judge[judge_index].append(skater_scores)
for judge in ranking_by_judge.values():
judge.sort(key=lambda x: (-x[1], x[0]))
return ranking_by_judge
In [12]:
### Solution - Exercise 1
def compute_ranking(scores: dict) -> dict:
from collections import defaultdicat
j = defaultdict(list)
for skater, scores in scores.items():
for i, _ in enumerate(scores[0]):
total_score = round(scores[0][i] + scores[1][i],2)
j['J'+str(i)].append((skater, total_score))
r = dict()
for k, v in j.items():
r[k] = sorted(v, key=lambda x: (-x[1],x[0]))
return r
In [13]:
def compute_ranking(scores: dict) -> dict:
###
num_judges = range(len(scores[list(scores.keys())[0]][0]))
ranking_by_judge = {f"J{j}": [] for j in num_judges}
# iterate through the size of the inner list to get each judge
for j in num_judges:
for s in scores.keys():
ranking_by_judge[f"J{j}"].append((s, round(scores[s][0][j] + scores[s][1][j], 2)))
# iterate through each skater to get the scores
for j in ranking_by_judge.keys():
ranking_by_judge[j] = sorted(ranking_by_judge[j], key=lambda x: (-x[1], x[0]))
return ranking_by_judge
###
In [14]:
def compute_ranking(scores: dict) -> dict:
###
num_judges = range(len(scores[list(scores.keys())[0]][0]))
ranking_by_judge = {f"J{j}": [] for j in num_judges}
# iterate through the size of the inner list to get each judge
for j in num_judges:
for s in scores.keys():
ranking_by_judge[f"J{j}"].append((s, round(scores[s][0][j] + scores[s][1][j], 2)))
# iterate through each skater to get the scores
for j in ranking_by_judge.keys():
ranking_by_judge[j] = sorted(ranking_by_judge[j], key=lambda x: (-x[1], x[0]))
return ranking_by_judge
###
In [15]:
def compute_ranking(scores: dict) -> dict:
j = 0
dictionary = {}
for score in scores.values():
num_judges = len(score[0])
break
while j < num_judges:
lis = []
for name, score in scores.items():
x = 0
for i in score:
x += i[j]
lis.append((name, round(x, 2)))
judge = f'J{j}'
dictionary[judge] = sorted(lis, key=lambda x: -x[1])
j += 1
return dictionary
In [16]:
def compute_ranking(scores: dict) -> dict:
###
### YOUR CODE HERE
###
ranking_by_judge = defaultdict(list)
# Loop through all skaters
for skater in scores:
# Loop through all scores for judges
for index in range(len(scores[skater][0])):
total_score = scores[skater][0][index] + scores[skater][1][index]
total_score = round(total_score, 2)
ranking_by_judge["J" + str(index)].append((skater, total_score))
# Sort lists
for judge in ranking_by_judge:
ranking_by_judge[judge].sort(key=lambda t: (-t[1], t[0]))
return ranking_by_judge
In [17]:
### Solution - Exercise 1
def compute_ranking(scores: dict) -> dict:
ranking_by_judge ={}
num_judges = len(next(iter(scores.values()))[0])
for j in range(num_judges):
judge_scores = []
for skater, (tech, pres) in scores.items():
total = round(tech[j]+ pres[j], 2)
judge_scores.append((skater, total))
judge_scores.sort(key=lambda x: (-x[1], x[0]))
ranking_by_judge[f'J{j}'] = judge_scores
return ranking_by_judge
In [18]:
### Solution - Exercise 1
def compute_ranking(scores: dict) -> dict:
from collections import defaultdict
rdict = defaultdict(list)
for skt, s_scores in scores.items():
for score in list(zip(*s_scores)):
rdict[skt].append(round(sum(score), 2))
res = defaultdict(list)
for sname, jscores in rdict.items():
for j,jscore in enumerate(jscores):
res[f'J{j}'].append((sname, jscore))
for j in res.values():
j.sort(key=lambda x: (-x[1], x[0]))
res = dict(res)
return res
In [19]:
def compute_ranking(scores: dict) -> dict:
###
### YOUR CODE HERE
###
o={}
first=True
for skater,v in scores.items():
t,p=v
if first:
for i in range(len(t)):
o[f'J{i}']=[]
first=False
for i in range(len(t)):
o[f'J{i}'].append((skater,round(t[i]+p[i],2)))
return {k:sorted(v, key=lambda tup: (-tup[1],tup[0])) for k,v in o.items()}
Ex2¶
In [20]:
def determine_winner(ranking_by_judge: dict) -> str:
from collections import Counter
###
### YOUR CODE HERE
###
majority = []
result = 'No Winner'
for k,v in ranking_by_judge.items():
ind = v[0]
majority.append(ind[0])
cnt = Counter(majority)
maj = cnt.most_common(2)
if len(maj) > 1 and maj[0][1] == maj[1][1]:
return 'No Winner'
else:
return maj[0][0]
In [21]:
def determine_winner(ranking_by_judge: dict) -> str:
###
### YOUR CODE HERE
###
from collections import defaultdict
skater_votes = defaultdict(int)
for judge, rankings in ranking_by_judge.items():
skater_votes[rankings[0][0]] += 1
max_votes = max(skater_votes.values())
winner = [skater for skater, votes in skater_votes.items() if votes == max_votes]
if len(winner) > 1:
return "No Winner"
else:
return winner[0]
In [22]:
### Solution - Exercise 2
def determine_winner(ranking_by_judge: dict) -> str:
from collections import defaultdict
d = defaultdict(int)
for _, w in ranking_by_judge.items():
d[w[0][0]] += 1
d = [(k,v) for k,v in sorted(d.items(), key=lambda x: -x[1])]
print(d)
if len(d) == 1:
return d[0][0]
if d[0][1] > d[1][1]:
return d[0][0]
else:
return 'No Winner'
In [23]:
from collections import Counter
def determine_winner(ranking_by_judge: dict) -> str:
num_judge = len(ranking_by_judge)
lis = []
for jud, tup_lis in ranking_by_judge.items():
lis.append(tup_lis[0])
names = (i[0] for i in lis)
counts = Counter(names)
#print(counts)
rank = 0
for name, score in counts.items():
if score > rank:
top = score
t_name = name
rank = score
all_ranks = list(counts.values())
count_ranks = Counter(all_ranks)
#print(count_ranks)
if count_ranks[top] > 1:
return 'No Winner'
else:
return t_name
In [24]:
def determine_winner(ranking_by_judge: dict) -> str:
###
### YOUR CODE HERE
###
first_votes = defaultdict(int)
for judge in ranking_by_judge:
first_place = ranking_by_judge[judge][0]
first_votes[first_place[0]] += 1
# Find most wins
most_wins = 0
is_winner = True
skater_name = ''
for winner in first_votes:
if first_votes[winner] == most_wins:
is_winner = False
elif first_votes[winner] > most_wins:
is_winner = True
most_wins = first_votes[winner]
skater_name = winner
if not is_winner:
return 'No Winner'
return skater_name
In [25]:
### Solution - Exercise 2
def determine_winner(ranking_by_judge: dict) -> str:
if not ranking_by_judge:
return "No Winner"
votes = {}
total_judges = len(ranking_by_judge)
for rankings in ranking_by_judge.values():
if rankings:
winner_name = rankings[0][0]
votes[winner_name] = votes.get(winner_name, 0) +1
for skater,v in votes.items():
if v > (total_judges/2):
return skater
return "No Winner"
In [26]:
### Solution - Exercise 2
def determine_winner(ranking_by_judge: dict) -> str:
from collections import Counter
counted = Counter([j[0][0] for j in ranking_by_judge.values()])
max_counted = max(counted.values())
if Counter(counted.values())[max_counted] != 1:
return 'No Winner'
else:
winner = counted.most_common(1)[0][0]
return winner
In [27]:
def determine_winner(ranking_by_judge: dict) -> str:
###
### YOUR CODE HERE
###
winnerh={}
for k,v in ranking_by_judge.items():
winner=v[0][0]
if winner not in winnerh.keys():
winnerh[winner]=0
winnerh[winner]+=1
total=sum(winnerh.values())
for k,v in winnerh.items():
if 1.0*v/total>.5:
return k
return 'No Clear Winner'
Ex3¶
In [28]:
def DEBUG_calc_avg_score(scores: dict) -> list:
from collections import defaultdict
rr = defaultdict(float)
for key, value in scores.items():
technical = sum(value[0]) / len(value[0])
presentation = sum(value[1]) / len(value[1])
rr[key] = round(technical + presentation , 2)
avg_tuple_list = list(rr.items())
return sorted(avg_tuple_list, key=lambda x: (-x[1] , x[0]))
In [29]:
def DEBUG_calc_avg_score(scores: dict) -> list:
avg_scores = {}
for key, value in scores.items():
technical = sum(value[0]) / len(value[0])
presentation = sum(value[1]) / len(value[1])
avg_scores[key] = round(technical + presentation, 2)
avg_tuple_list = list(avg_scores.items())
return sorted(avg_tuple_list, key=lambda x: (-x[1], x[0]))
In [30]:
### Solution - Exercise 3
def DEBUG_calc_avg_score(scores: dict) -> list:
r = []
for key, value in scores.items():
#technical = round(sum(value[0]) / len(value[0]), 2)
technical = sum(value[0]) / len(value[0])
#presentation = round(sum(value[1]) // len(value[1]), 2)
presentation = sum(value[1]) / len(value[1])
#scores[key] = technical + presentation
r.append((key, round(technical+presentation, 2)))
#avg_tuple_list = list(scores.items())
avg_tuple_list = r
print(avg_tuple_list)
return sorted(avg_tuple_list, key=lambda x: -x[1])
In [31]:
def DEBUG_calc_avg_score(scores: dict) -> list:
avg_tuple_list = []
for key, value in scores.items():
technical = sum(value[0]) / len(value[0])
presentation = sum(value[1]) / len(value[1])
scores = round((technical + presentation), 2)
avg_tuple_list.append((key, scores))
return sorted(avg_tuple_list, key=lambda x: (-x[1], x[0]))
In [32]:
def DEBUG_calc_avg_score(scores: dict) -> list:
avg_ans = []
for key, value in scores.items():
technical = sum(value[0]) / len(value[0])
presentation = sum(value[1]) / len(value[1])
score = technical + presentation
score = round(score, 2)
avg_ans.append((key, score))
return sorted(avg_ans, key=lambda x: (-x[1], x[0]))
In [33]:
### Solution - Exercise 3
def DEBUG_calc_avg_score(scores: dict) -> list:
avg_score_by_skater = []
for skater,(tech_scores, pres_scores) in scores.items():
technical = sum(tech_scores) / len(tech_scores)
presentation = sum(pres_scores) / len(pres_scores)
total = round(technical+ presentation, 2)
avg_score_by_skater.append((skater, total))
avg_score_by_skater.sort(key= lambda x: (-x[1], x[0]))
return avg_score_by_skater
In [34]:
### Solution - Exercise 3
def DEBUG_calc_avg_score(scores: dict) -> list:
from copy import deepcopy
scores = deepcopy(scores)
for key, value in scores.items():
technical = sum(value[0]) / len(value[0])
presentation = sum(value[1]) / len(value[1])
scores[key] = round(technical + presentation, 2)
avg_tuple_list = list(scores.items())
return sorted(avg_tuple_list, key=lambda x: -x[1])
In [35]:
def DEBUG_calc_avg_score(scores: dict) -> list:
scores2={}
for key, value in scores.items():
technical = sum(value[0]) / len(value[0])
presentation = sum(value[1]) / len(value[1])
# print(f"t {technical} p {presentation}")
scores2[key] = round(technical + presentation,2)
avg_tuple_list = list(scores2.items())
return sorted(avg_tuple_list, key=lambda x: (-x[1],x[0]))
Ex5¶
In [36]:
def get_element_scores(elements: dict) -> dict:
###
### YOUR CODE HERE
###
from collections import defaultdict
result = defaultdict(list)
for tp in elements:
tpe = None
if tp == 'jumps':
tpe = 'j'
ind = elements[tp]
for p in ind:
code = ind[p]['code']
sov = float(ind[p]['SOV'])
result[code] = [sov , tpe]
elif 'spin' in tp or 'step sequence' in tp:
tpe = 's'
ind = elements[tp]
for p in ind:
code = ind[p]['code']
if 'L4' in ind[p].keys():
l4 = float(ind[p]['L4'])
result[code] = [l4 , tpe]
else:
lb = float(ind[p]['LB'])
result[code] = [lb , tpe]
return result
In [37]:
def get_element_scores(elements: dict) -> dict:
###
### YOUR CODE HERE
###
base_value_dict = {}
for score_type, element in elements.items():
for exercise, scores in element.items():
if score_type == 'jumps':
base_value_dict[scores['code']] = [float(scores['SOV']), 'j']
else:
if ('L4' in scores) and (scores['L4'] != ''):
base_value_dict[scores['code']] = [float(scores['L4']), 's']
else:
base_value_dict[scores['code']] = [float(scores['LB']), 's']
return base_value_dict
In [38]:
def get_element_scores(elements: dict) -> dict:
r = dict()
for _, v in elements['jumps'].items():
r[v['code']] = [float(v['SOV']), 'j']
for _, v in elements['spins and step sequences'].items():
if 'L4' in v.keys():
r[v['code']] = [float(v['L4']), 's']
else:
r[v['code']] = [float(v['LB']), 's']
return r
In [39]:
### Solution - Exercise 4
from pprint import pprint
def get_element_scores(elements: dict) -> dict:
###
base_value_dict = {}
# base value dict is a dictionary of code names, where the values are [point value, j/s]
for j, val in elements['jumps'].items():
base_value_dict[val['code']] = [float(val['SOV']), 'j']
for s, val in elements['spins and step sequences'].items():
try:
base_value_dict[val['code']] = [float(val['L4']), 's']
except:
base_value_dict[val['code']] = [float(val['LB']), 's']
return base_value_dict
In [40]:
def get_element_scores(elements: dict) -> dict:
dictionary = {}
for key, value in elements.items():
for name, dicti in value.items():
if key == 'jumps':
abb = 'j'
dictionary[dicti['code']] = [float(dicti['SOV']), abb]
else:
abb = 's'
if 'L4' in dicti:
dictionary[dicti['code']] = [float(dicti['L4']), abb]
else:
dictionary[dicti['code']] = [float(dicti['LB']), abb]
return dictionary
In [41]:
def get_element_scores(elements: dict) -> dict:
###
### YOUR CODE HERE
###
#print(elements)
base_val_dict = {}
for element in elements:
element_dict = elements[element]
for move in element_dict:
move_dict = element_dict[move]
if element == 'jumps':
base_val_dict[move_dict['code']] = [float(move_dict['SOV']), 'j']
else:
if 'L4' in move_dict:
base_val_dict[move_dict['code']] = [float(move_dict['L4']), 's']
else:
base_val_dict[move_dict['code']] = [float(move_dict['LB']), 's']
return base_val_dict
In [42]:
### Solution - Exercise 5
def get_element_scores(elements: dict) -> dict:
###
base_value_dict = {}
for jump in elements.get('jumps', {}).values():
code = jump['code']
base_value_dict[code] = [float(jump['SOV']),'j']
for elem in elements.get('spins and step sequences', {}).values():
code = elem['code']
value = elem.get('L4', elem.get('LB'))
base_value_dict[code] = [float(value), 's']
return base_value_dict
In [43]:
### Solution - Exercise 5
def get_element_scores(elements: dict) -> dict:
from collections import defaultdict
res = defaultdict(list)
for k,v in elements.items():
for k1, v1 in v.items():
if k == 'jumps':
res[v1['code']].append(float(v1['SOV']))
res[v1['code']].append('j')
else:
if 'L4' in v1.keys():
res[v1['code']].append(float(v1['L4']))
else:
res[v1['code']].append(float(v1['LB']))
res[v1['code']].append('s')
return dict(res)
In [44]:
def get_element_scores(elements: dict) -> dict:
###
### YOUR CODE HERE
###
o={}
i='j'
for k,v in elements['jumps'].items():
o[v['code']]=[float(v['SOV']),i]
i='s'
for k,v in elements['spins and step sequences'].items():
o[v['code']]=[float(v.get('L4',v['LB'])),i]
return o
Ex6¶
In [45]:
def DEBUG_compute_base_score(exec_element_str: str, base_value_dict: dict) -> float:
base_score = 0
element_list = exec_element_str.split()
element_list.reverse()
bonus_jump_count = 0
for e in element_list:
if '+' in e:
# need to split and sum up
combo_list = e.split('+')
#bonus_flag = False
combo_sum = 0
for c in combo_list:
if base_value_dict[c][1] == 'j':
#bonus_flag = True
#combo_sum += base_value_dict[c][0]
if bonus_jump_count < 3:
combo_sum += (base_value_dict[c][0] * 1.1)
bonus_jump_count += 1
else:
combo_sum+= base_value_dict[c][0]
else:
combo_sum += base_value_dict[c][0]
base_score+=combo_sum
else:
if base_value_dict[e][1] == 'j':
if bonus_jump_count < 3:
base_score += (base_value_dict[e][0] * 1.1)
bonus_jump_count += 1
else:
base_score+=base_value_dict[e][0]
else:
base_score += base_value_dict[e][0]
return round(base_score, 3)
In [46]:
def DEBUG_compute_base_score(exec_element_str: str, base_value_dict: dict) -> float:
base_score = 0.
element_list = exec_element_str.split()
element_list.reverse()
bonus_jump_count = 0
for e in element_list:
if '+' in e:
# need to split and sum up
combo_list = e.split('+')
combo_sum = 0.
for c in combo_list:
bonus_flag = base_value_dict[c][1] == 'j' and bonus_jump_count < 3
base_value = float(base_value_dict[c][0])
if bonus_flag:
combo_sum += (base_value * 1.1)
bonus_jump_count += 1
else:
combo_sum += base_value
base_score += combo_sum
else:
bonus_flag = base_value_dict[e][1] == 'j' and bonus_jump_count < 3
base_value = float(base_value_dict[e][0])
if bonus_flag:
base_score += (base_value * 1.1)
bonus_jump_count += 1
else:
base_score += base_value
return round(base_score, 3)
In [47]:
### Solution - Exercise 5
def DEBUG_compute_base_score(exec_element_str: str, base_value_dict: dict) -> float:
base_score = 0
element_list = exec_element_str.split()
element_list.reverse()
bonus_jump_count = 0
for e in element_list:
if '+' in e:
# need to split and sum up
combo_list = e.split('+')
bonus_flag = False
combo_sum = 0
for c in combo_list:
if base_value_dict[c][1] == 'j':
bonus_flag = True
combo_sum += base_value_dict[c][0]
if bonus_flag == True & bonus_jump_count < 3:
base_score += (combo_sum * 1.1)
bonus_jump_count += 1
else:
if base_value_dict[e][1] == 'j':
base_score += (base_value_dict[e][0] * 1.1)
bonus_jump_count += 1
return round(base_score, 3)
In [48]:
### Solution - Exercise 5
def DEBUG_compute_base_score(exec_element_str: str, base_value_dict: dict) -> float:
print(exec_element_str)
base_score = 0
# splitting the list into elements
element_list = exec_element_str.split()
# reversing the element lists
element_list.reverse()
# no bonus jumps yet
bonus_jump_count = 0
for e in element_list:
if '+' in e:
# need to split and sum up
combo_list = e.split('+')
bonus_flag = False
combo_sum = 0
for c in combo_list:
if base_value_dict[c][1] == 'j':
bonus_flag = True
combo_sum += base_value_dict[c][0]
if bonus_flag == True and bonus_jump_count < 3:
base_score += (combo_sum * 1.1)
bonus_jump_count += 1
else:
base_score += combo_sum
else:
if base_value_dict[e][1] == 'j' and bonus_jump_count < 3:
base_score += (base_value_dict[e][0] * 1.1)
bonus_jump_count += 1
else:
base_score += base_value_dict[e][0]
return round(base_score, 3)
In [49]:
def DEBUG_compute_base_score(exec_elements: list, base_value_dict: dict) -> list:
base_score_list = []
element_list = exec_elements.copy()
element_list.reverse()
bonus_jump_count = 0
for e in element_list:
if '+' in e:
# need to split and sum up
combo_list = e.split('+')
bonus_flag = False
combo_sum = 0
for c in combo_list:
if base_value_dict[c][1] == 'j':
bonus_flag = True
combo_sum += base_value_dict[c][0]
if (bonus_flag == True) & (bonus_jump_count < 3):
combo_sum = combo_sum + (combo_sum * 0.1)
bonus_jump_count += 1
base_score_list.append(round(combo_sum,2))
else:
base_score_list.append(round(combo_sum,2))
elif (base_value_dict[e][1] == 'j') & (bonus_jump_count < 3):
base_score_list.append(round((base_value_dict[e][0]+(base_value_dict[e][0] * 0.1)),2))
bonus_jump_count += 1
elif (base_value_dict[e][1] == 'j') & (bonus_jump_count >= 3):
base_score_list.append(round(base_value_dict[e][0],2))
elif (base_value_dict[e][1] == 's'):
base_score_list.append(round(base_value_dict[e][0],2))
base_score_list.reverse()
return base_score_list
In [50]:
def DEBUG_compute_base_score(exec_elements: list, base_value_dict: dict) -> list:
base_score_list = []
element_list = exec_elements.copy()
element_list.reverse()
bonus_jump_count = 0
for e in element_list:
if '+' in e:
# need to split and sum up
combo_list = e.split('+')
bonus_flag = False
combo_sum = 0
for c in combo_list:
if base_value_dict[c][1] == 'j':
bonus_flag = True
combo_sum += base_value_dict[c][0]
if bonus_flag == True and bonus_jump_count < 3:
combo_sum = combo_sum * 1.1
bonus_jump_count += 1
base_score_list.append(round(combo_sum,2))
else:
if base_value_dict[e][1] == 'j' and bonus_jump_count < 3:
base_score_list.append(round(base_value_dict[e][0] * 1.1,2))
bonus_jump_count += 1
# Need to add score if no jump
else:
base_score_list.append(round(base_value_dict[e][0], 2))
base_score_list.reverse()
return base_score_list
In [51]:
### Solution - Exercise 6
def DEBUG_compute_base_score(exec_elements: list, base_value_dict: dict) -> list:
base_score_list = []
element_list = exec_elements.copy()
element_list.reverse()
bonus_jump_count = 0
for e in element_list:
if '+' in e:
# need to split and sum up
combo_list = e.split('+')
bonus_flag = False
combo_sum = 0
for c in combo_list:
if base_value_dict[c][1] == 'j':
bonus_flag = True
combo_sum += base_value_dict[c][0]
if bonus_flag and bonus_jump_count < 3:
combo_sum *= 1.1
bonus_jump_count += 1
base_score_list.append(round(combo_sum,2))
else:
if base_value_dict[e][1] == 'j' and bonus_jump_count < 3:
base_score_list.append(round(base_value_dict[e][0] * 1.1,2))
bonus_jump_count += 1
else:
base_score_list.append(round(base_value_dict[e][0],2))
base_score_list.reverse()
return base_score_list
In [52]:
def DEBUG_compute_base_score(exec_elements: list, base_value_dict: dict) -> list:
base_score_list = []
element_list = exec_elements.copy()
element_list.reverse()
bonus_jump_count = 0
for e in element_list:
# print(f"e {e}")
if '+' in e:
# need to split and sum up
combo_list = e.split('+')
bonus_flag = False
combo_sum = 0
for c in combo_list:
if base_value_dict[c][1] == 'j':
bonus_flag = True
combo_sum += base_value_dict[c][0]
# print(f'e {e} combo_sum {combo_sum}')
if bonus_flag == True and bonus_jump_count < 3:
combo_sum = combo_sum * 1.1
bonus_jump_count += 1
base_score_list.append(round(combo_sum,2))
else:
# print(f"base_value_dict[e] {base_value_dict[e]}")
if base_value_dict[e][1] == 'j' and bonus_jump_count < 3:
base_score_list.append(round(base_value_dict[e][0] * 1.1,2))
bonus_jump_count += 1
elif base_value_dict[e][1]=='j':
base_score_list.append(round(base_value_dict[e][0],2))
if base_value_dict[e][1] == 's':
base_score_list.append(round(base_value_dict[e][0],2))
return base_score_list[::-1]
Ex7¶
In [53]:
def calc_goe_score(base_scores: list, judge_technical_scores: dict, exec_element_str: str, base_value_dict: dict) -> float:
###
import math
print(exec_element_str)
### YOUR CODE HERE
element_list = exec_element_str.split()
goe = 0.0
for idx, e in enumerate(element_list):
judge_list = sorted([v[idx] for k, v in judge_technical_scores.items()])
judge_list = judge_list[1:-1]
if 'ChSq' not in e:
if '+' in e:
combo_list = e.split('+')
max_element = 0
for p in combo_list:
if base_value_dict[p][0] > max_element:
max_element = base_value_dict[p][0]
max_element = max_element * 0.1
else:
max_element = base_value_dict[e][0] * 0.1
judge_list = [max_element * x for x in judge_list]
avg_g = sum(judge_list) / len(judge_list)
goe += avg_g
else:
judge_list = [x / 2 for x in judge_list]
avg_g = sum(judge_list) / len(judge_list)
goe += avg_g
return round(math.fsum(base_scores) + goe, 2)
In [54]:
def calc_goe_score(base_scores: list, judge_technical_scores: dict, exec_element_str: str, base_value_dict: dict) -> float:
###
### YOUR CODE HERE
###
import statistics as stats
goe_list = []
pattern = r"ChSq"
element_list = exec_element_str.split()
print(exec_element_str)
print(base_value_dict)
for i, e in enumerate(element_list):
scores = [scores[i] for scores in judge_technical_scores.values()]
filtered_scores = sorted(scores, reverse=True)[1:-1]
if '+' in e:
combo_list = e.split('+')
highest_base_value = 0.0
contains_ChSq = False
for c in combo_list:
base_value = base_value_dict[c][0]
highest_base_value = max(highest_base_value, base_value)
if re.match(pattern, c) and not contains_ChSq:
contains_ChSq = True
if contains_ChSq:
scaled_judge_scores = [s * 0.5 for s in filtered_scores]
else:
scale = 0.1 * highest_base_value
scaled_judge_scores = [s * scale for s in filtered_scores]
goe = stats.mean(scaled_judge_scores)
goe_list.append(goe)
else:
base_value = base_value_dict[e][0]
contains_ChSq = re.match(pattern, e)
if contains_ChSq:
scaled_judge_scores = [s * 0.5 for s in filtered_scores]
else:
scale = 0.1 * base_value
scaled_judge_scores = [s * scale for s in filtered_scores]
goe = stats.mean(scaled_judge_scores)
goe_list.append(goe)
total_goe_score = sum(goe_list)
total_base_scores = sum(base_scores)
return round(total_goe_score + total_base_scores, 2)
In [55]:
def calc_goe_score(base_scores: list, judge_technical_scores: dict, exec_element_str: str, base_value_dict: dict) -> float:
total_GOE_score = []
for i, e in enumerate(exec_element_str.split()):
judge_score = sorted([a[i] for a in judge_technical_scores.values()])[1:-1]
if 'ChSq' in e:
scaled_judge_score = [j/2 for j in judge_score]
else:
if '+' in e:
max_ = max([base_value_dict[f][0] for f in e.split('+')])
else:
max_ = base_value_dict[e][0]
scaled_judge_score = [j*max_/10 for j in judge_score]
total_GOE_score.append(sum(scaled_judge_score) / len(scaled_judge_score))
return round(sum(total_GOE_score) + sum(base_scores), 3)
In [56]:
def calc_goe_score(base_scores: list, judge_technical_scores: dict, exec_element_str: str, base_value_dict: dict) -> float:
###
goe_scores = []
for i, element in enumerate(exec_element_str.split()):
# Discard lowest and highest judge technical scores for each element
judge_scores = sorted([v[i] for k, v in judge_technical_scores.items()])
judge_scores = judge_scores[1:-1]
# Check if this is a combination
if '+' in element:
# Find the element with the highest base value in the combination
combo_elements = element.split('+')
max_base_value = max(base_value_dict[e][0] for e in combo_elements)
else:
# Use the base score from base_scores_list
max_base_value = base_scores[i]
# Check if element contains 'ChSq'
if 'ChSq' in element:
scaled_scores = [score / 2 for score in judge_scores]
else:
scaling_factor = max_base_value * 0.10
scaled_scores = [score * scaling_factor for score in judge_scores]
# Average the scaled scores for this element
element_goe = sum(scaled_scores) / len(scaled_scores)
# Add to total GOE score
goe_scores.append(element_goe)
# Final score = base scores + GOE scores
return round(sum(base_scores) + sum(goe_scores), 2)
In [57]:
def calc_goe_score(judge_scores: dict, exec_elements: list, base_value_dict: dict) -> dict:
goe_dict = {}
n = len(exec_elements)
for i in range(n):
j_lis = []
for lis in judge_scores.values():
j_lis.append(lis[i])
min_sco = min(j_lis)
max_sco = max(j_lis)
j_lis.remove(min_sco)
j_lis.remove(max_sco)
if exec_elements[i].startswith('ChSq'):
scaled_jlis = [x/2 for x in j_lis]
avg_score = sum(scaled_jlis) / len(scaled_jlis)
goe_dict[exec_elements[i]] = round(avg_score, 2)
elif '+' in exec_elements[i]:
if 'ChSq' in exec_elements[i]:
scaled_jlis = [x/2 for x in j_lis]
avg_score = sum(scaled_jlis) / len(scaled_jlis)
goe_dict[exec_elements[i]] = round(avg_score, 2)
else:
ele = exec_elements[i].split('+')
y = []
for el in ele:
y.append(base_value_dict[el][0])
base_val = max(y) * 0.1
scaled_jlis = [x*base_val for x in j_lis]
avg_score = sum(scaled_jlis) / len(scaled_jlis)
goe_dict[exec_elements[i]] = round(avg_score, 2)
else:
base_val = base_value_dict[exec_elements[i]][0] * 0.1
scaled_jlis = [x*base_val for x in j_lis]
avg_score = sum(scaled_jlis) / len(scaled_jlis)
goe_dict[exec_elements[i]] = round(avg_score, 2)
return goe_dict
In [58]:
def calc_goe_score(judge_scores: dict, exec_elements: list, base_value_dict: dict) -> dict:
###
### YOUR CODE HERE
###
goe_dict = {}
for index, move in enumerate(exec_elements):
# Get highest score
highest_score = 0
if '+' in move:
moves = move.split('+')
for move_item in moves:
if base_value_dict[move_item][0] > highest_score:
highest_score = base_value_dict[move_item][0]
else:
highest_score = base_value_dict[move][0]
# Get judges scores for that move
judge_scores_list = []
for judge in judge_scores:
judge_scores_list.append(judge_scores[judge][index])
judge_scores_list.sort()
judge_scores_list = judge_scores_list[1: -1]
if 'ChSq' not in move:
for index in range(len(judge_scores_list)):
judge_scores_list[index] = judge_scores_list[index] * highest_score * 0.1
else:
for index in range(len(judge_scores_list)):
judge_scores_list[index] = judge_scores_list[index] / 2
# Average them
avg = sum(judge_scores_list) / len(judge_scores_list)
goe_dict[move] = round(avg, 2)
return goe_dict
In [59]:
### Solution - Exercise 7
def calc_goe_score(judge_scores: dict, exec_elements: list, base_value_dict: dict) -> dict:
goe_dict = {}
judges = list(judge_scores.keys())
for i, elem in enumerate(exec_elements):
raw = [judge_scores[j][i] for j in judges]
raw.sort()
trimmed = raw[1:-1]
parts =elem.split('+')
max_base = max(base_value_dict[p][0] for p in parts)
if 'ChSq' in elem:
scaled = [x/2 for x in trimmed]
else:
scale = 0.1* max_base
scaled = [x*scale for x in trimmed]
goe_dict[elem] = round(sum(scaled)/len(scaled), 2)
return goe_dict
In [60]:
### Solution - Exercise 7
def calc_goe_score(judge_scores: dict, exec_elements: list, base_value_dict: dict) -> dict:
res = {}
judges_t = list(zip(*judge_scores.values()))
for i, e in enumerate(exec_elements):
scores = sorted(judges_t[i])[1:-1]
if 'ChSq' in e and not '+' in e:
goe = round(sum(s / 2 for s in scores) / len(scores), 2)
res[e] = goe
elif not '+' in e:
score = 0.1 * base_value_dict[e][0]
goe = round(sum(s * score for s in scores) / len(scores), 2)
res[e] = goe
elif '+' in e and not 'ChSq' in e:
elist = e.split('+')
score = 0.1 * max(base_value_dict[em][0] for em in elist)
goe = round(sum(s * score for s in scores) / len(scores), 2)
res[e] = goe
elif '+' in e and 'ChSq' in e:
elist = e.split('+')
goe = round(sum(s / 2 for s in scores) / len(scores), 2)
res[e] = goe
return res
In [61]:
def calc_goe_score(judge_scores: dict, exec_elements: list, base_value_dict: dict) -> dict:
###
### YOUR CODE HERE
###
o={}
for i in range(len(exec_elements)):
e=exec_elements[i]
scores=[1.0*v[i] for v in judge_scores.values()]
scores2=sorted(scores)[1:-1]
print(f'e {e} scores {scores} scores2 {scores2}')
if 'ChSq' in e:
goe=sum([i/2 for i in scores2])/len(scores2)
else:
es=e.split('+')
maxe=.1*max([base_value_dict[e2][0] for e2 in es])
goe=sum([i*maxe for i in scores2])/len(scores2)
o[e]=round(goe,2)
return o
Ex8¶
In [62]:
def calculate_corr_coeff(results: dict) -> float:
###
### YOUR CODE HERE
###
import statistics
base_scores = []
final_scores = []
for k,v in results.items():
if len(v) == 3:
base_scores.append(v[0])
final_scores.append(v[1] - v[2])
else:
base_scores.append(v[0])
final_scores.append(v[1])
n = len(base_scores)
mean_base_scores = sum(base_scores) / n
mean_final_scores = sum(final_scores) / n
numerator = sum(((base_scores[x] - mean_base_scores) * (final_scores[x] - mean_final_scores)) for x in range(n))
denominator_1 = sum((base_scores[x] - mean_base_scores)**2 for x in range(n))
denominator_2 = sum((final_scores[x] - mean_final_scores)**2 for x in range(n))
denominator = (denominator_1 ** 0.5) * (denominator_2 ** 0.5)
return round(numerator / denominator , 2)
In [63]:
def calculate_corr_coeff(results: dict) -> float:
###
### YOUR CODE HERE
###
import statistics as stats
from math import sqrt
x = [x[0] for x in results.values()]
y = [y[1] for y in results.values()]
assert len(x) == len(y)
mean_x = stats.mean(x)
mean_y = stats.mean(y)
r = 0
numerator = 0
denominator_x = 0
denominator_y = 0
for i in range(len(x)):
numerator += (x[i] - mean_x) * (y[i] - mean_y)
denominator_x += ((x[i] - mean_x)**2)
denominator_y += ((y[i] - mean_y)**2)
denominator = sqrt(denominator_x * denominator_y)
assert denominator != 0
return round((numerator / denominator), 2)
In [64]:
### Solution - Exercise 7
def calculate_corr_coeff(results: dict) -> float:
import math
x = [r[0] for r in results.values()]
y = [r[1] for r in results.values()]
x_mean = sum(x)/len(x)
y_mean = sum(y)/len(y)
x_deviation = [xi-x_mean for xi in x]
y_deviation = [yi-y_mean for yi in y]
numerator = sum([x_dev*y_dev for x_dev, y_dev in zip (x_deviation, y_deviation)])
denumerator_square = sum([x_dev**2 for x_dev in x_deviation]) * sum([y_dev**2 for y_dev in y_deviation])
denumerator = math.sqrt(denumerator_square)
return round(numerator/denumerator, 2)
In [65]:
def calculate_corr_coeff(results: dict) -> float:
###
base_values = [x[0] for x in results.values()]
final_values = []
# variable tuple sizes need to be handled
for x in results.values():
if len(x) > 2:
final_values.append(x[1] - x[2])
else:
final_values.append(x[1])
avg_base = sum(base_values) / len(base_values)
avg_final = sum(final_values) / len(final_values)
numerator = 0
sum_sq_dev_X = 0
sum_sq_dev_Y = 0
for i, (k, v) in enumerate(results.items()):
dev_X = base_values[i] - avg_base
dev_Y = final_values[i] - avg_final
numerator += dev_X * dev_Y
sum_sq_dev_X += dev_X**2
sum_sq_dev_Y += dev_Y**2
# Calculate the denominator (product of the standard deviations)
denominator = (sum_sq_dev_X * sum_sq_dev_Y) ** 0.5
# Calculate the Pearson correlation coefficient (r)
if denominator == 0:
return 0 # Avoid division by zero if one or both variables have no variance
r = numerator / denominator
In [66]:
import math
def calculate_corr_coeff(results: dict) -> float:
xlis = []
ylis = []
for tup in results.values():
xlis.append(tup[0])
ylis.append(tup[1])
x_bar = sum(xlis)/len(xlis)
y_bar = sum(ylis)/len(ylis)
x_diff = []
y_diff = []
for name, val in results.items():
x = val[0]
#print(x)
if len(val) == 3:
y = val[1] - val[2]
else:
y = val[1]
x_diff.append((x - x_bar))
y_diff.append((y - y_bar))
num = sum([x*y for (x,y) in zip(x_diff, y_diff)])
sum_x_sq = sum([x**2 for x in x_diff])
sum_y_sq = sum([y**2 for y in y_diff])
coeff = num / (math.sqrt(sum_x_sq*sum_y_sq))
return round(coeff, 2)
In [67]:
import math
def calculate_corr_coeff(results: dict) -> float:
###
### YOUR CODE HERE
###
base = []
final = []
for items in results.values():
base_val = float(items[0])
final_val = float(items[1])
deduct = float(items[2]) if len(items) >= 3 else 0.0
base.append(base_val)
final.append(final_val)
x_bar = sum(base) / len(base)
y_bar = sum(final) / len(base)
# Solve
num = sum((x - x_bar) * (y - y_bar) for x, y in zip(base, final))
den_x = sum((x - x_bar) ** 2 for x in base)
den_y = sum((y - y_bar) ** 2 for y in final)
bottom = math.sqrt(den_x * den_y)
r = num / bottom
r = round(r, 2)
return r
In [68]:
### Solution - Exercise 8
def calculate_corr_coeff(results: dict) -> float:
res = []
for s in results.values():
if len(s) == 3:
res.append((s[0], s[1] - s[2]))
else:
res.append((s[0], s[1]))
base = list(zip(*res))[0]
final = list(zip(*res))[1]
base_mean = sum(base) / len(base)
final_mean = sum(final) / len(final)
base_demean = [b - base_mean for b in base]
final_demean = [f - final_mean for f in final]
num = sum(b*f for b, f in zip(base_demean, final_demean))
den = (sum(b**2 for b in base_demean) * sum(f**2 for f in final_demean))**0.5
return round(num/den, 2)
In [69]:
def calculate_corr_coeff(results: dict) -> float:
###
### YOUR CODE HERE
###
xs=[]
ys=[]
for k,v in results.items():
x=v[0]
y=v[1]
if len(v)==3:
y-=v[2]
xs.append(x)
ys.append(y)
xmean=sum(xs)/len(xs)
ymean=sum(ys)/len(ys)
suma=0.0
sumb=0.0
sumc=0.0
for i in range(len(xs)):
x=xs[i]
y=ys[i]
suma+=(x-xmean)*(y-ymean)
sumb+=(x-xmean)**2
sumc+=(y-ymean)**2
return round(suma/(sumb*sumc)**(1/2),2)