You are the judge at a competitive eating competition and you need to choose a winner!

There are three foods at the competition and each type of food is worth a different amount of points.
Points are as follows:

- Chickenwings: 5 points  

- Hamburgers: 3 points   

- Hotdogs: 2 points

Write a function that helps you create a scoreboard. 
It takes as a parameter a list of objects representing the participants, for example:
```
[
  {name: "Habanero Hillary", chickenwings: 5 , hamburgers: 17, hotdogs: 11},
  {name: "Big Bob" , chickenwings: 20, hamburgers: 4, hotdogs: 11}
]
```
It should return 
"name" and "score" properties sorted by score; if scores are equals, sort alphabetically by name.
```
[
  {name: "Big Bob", score: 134},
  {name: "Habanero Hillary", score: 98}
]
```
Happy judging!

Difficulty: EASY
Starter code: def scoreboard(who_ate_what):
	

Solutions:
def scoreboard(who_ate_what):
	scores = {'chickenwings': 5, 'hamburgers': 3, 'hotdogs': 2}
	return sorted(({'name': person.pop('name'), 'score': sum((scores.get(k, 0) * v for (k, v) in list(person.items())))} for person in who_ate_what), key=lambda a: (-a['score'], a['name']))


PTS = {'name': 0, 'chickenwings': 5, 'hamburgers': 3, 'hotdogs': 2}

def scoreboard(who_ate_what):
	return sorted(({'name': d['name'], 'score': sum((d.get(what, 0) * coef or 0 for (what, coef) in PTS.items()))} for d in who_ate_what), key=lambda d: (-d['score'], d['name']))


def scoreboard(who_ate_what):
	for d in who_ate_what:
		d['score'] = 5 * d.get('chickenwings', 0) + 3 * d.get('hamburgers', 0) + 2 * d.get('hotdogs', 0)
	return sorted([{k: d[k] for k in ('name', 'score')} for d in who_ate_what], key=lambda d: (-1 * d['score'], d['name']))


SCORES = {'chickenwings': 5, 'hamburgers': 3, 'hambrgers': 3, 'hotdogs': 2}

def scoreboard(who_ate_what):
	return sorted([{'name': d['name'], 'score': sum((SCORES[food] * count for (food, count) in d.items() if food != 'name'))} for d in who_ate_what], key=lambda d: (-d['score'], d['name']))


def scoreboard(who_ate_what):
	weights = {'chickenwings': 5, 'hamburgers': 3, 'hotdogs': 2}

	def score(dude):
		return sum((weights[key] * amount for (key, amount) in dude.items() if key != 'name'))
	return sorted(({'name': dude['name'], 'score': score(dude)} for dude in who_ate_what), key=lambda d: (-d['score'], d['name']))


def scoreboard(who_ate_what):
	return sorted(({'name': p['name'], 'score': 5 * p.get('chickenwings', 0) + 3 * p.get('hamburgers', 0) + 2 * p.get('hotdogs', 0)} for p in who_ate_what), key=lambda dict: (-dict['score'], dict['name']))


POINTS = {'chickenwings': 5, 'hamburgers': 3, 'hotdogs': 2}
scoreboard = lambda b: sorted(({'name': p['name'], 'score': sum((v * p.get(k, 0) for (k, v) in POINTS.items()))} for p in b), key=lambda d: (-d['score'], d['name']))


def scoreboard(who_ate_what):
	score_board = []
	for person in who_ate_what:
		score = person.get('chickenwings', 0) * 5 + person.get('hamburgers', 0) * 3 + person.get('hotdogs', 0) * 2
		contestant = {x: person[x] for x in ['name']}
		contestant.update({'score': score})
		score_board.append(contestant)
	return sorted(score_board, key=lambda k: (-k['score'], k['name']))


def scoreboard(who_ate_what):
	new = [{'name': n['name'], 'score': n.get('chickenwings', 0) * 5 + n.get('hamburgers', 0) * 3 + n.get('hotdogs', 0) * 2} for n in who_ate_what]
	return sorted(new, key=lambda n: (-n['score'], n['name']))


class eater:

	def __init__(self, dict):
		self.name = dict['name']
		self.chickenwings = dict['chickenwings'] if 'chickenwings' in dict.keys() else 0
		self.hamburgers = dict['hamburgers'] if 'hamburgers' in dict.keys() else 0
		self.hotdogs = dict['hotdogs'] if 'hotdogs' in dict.keys() else 0

	def score(self):
		return 5 * self.chickenwings + 3 * self.hamburgers + 2 * self.hotdogs

def scoreboard(who_ate_what):
	score = []
	for D in who_ate_what:
		score.append({'name': D['name'], 'score': eater(D).score()})
	return sorted(score, key=lambda x: (-x['score'], x['name']))