Alice and Bob have participated to a Rock Off with their bands. A jury of true metalheads rates the two challenges, awarding points to the bands on a scale from 1 to 50 for three categories: Song Heaviness, Originality, and Members' outfits.

For each one of these 3 categories they are going to be awarded one point, should they get a better judgement from the jury. No point is awarded in case of an equal vote.

You are going to receive two arrays, containing first the score of Alice's band and then those of Bob's. Your task is to find their total score by comparing them in a single line. 

Example:

Alice's band plays a Nirvana inspired grunge and has been rated 
``20`` for Heaviness, 
``32`` for Originality and only 
``18`` for Outfits.
Bob listens to Slayer and has gotten a good 
``48`` for Heaviness, 
``25`` for Originality and a rather honest 
``40`` for Outfits.

The total score should be followed by a colon ```:``` and by one of the following quotes:
if Alice's band wins: ```Alice made "Kurt" proud!```
if Bob's band wins: ```Bob made "Jeff" proud!```
if they end up with a draw: ```that looks like a "draw"! Rock on!```

The solution to the example above should therefore appear like 
``'1, 2: Bob made "Jeff" proud!'``.

Source: codewars | Difficulty: EASY
Tags: Fundamentals

Data structures

Starter code: def solve(a, b):
	

Solutions:
def solve(a, b):
	alice = sum((i > j for (i, j) in zip(a, b)))
	bob = sum((j > i for (i, j) in zip(a, b)))
	if alice == bob:
		words = 'that looks like a "draw"! Rock on!'
	elif alice > bob:
		words = 'Alice made "Kurt" proud!'
	else:
		words = 'Bob made "Jeff" proud!'
	return '{}, {}: {}'.format(alice, bob, words)


def solve(a, b):
	(s, n) = (0, 0)
	for (x, y) in zip(a, b):
		if x > y:
			n += 1
		elif x < y:
			s += 1
	if s != n:
		return f'''{n}, {s}: {('Alice' if s < n else 'Bob')} made "{('Kurt' if s < n else 'Jeff')}" proud!'''
	return f'{n}, {s}: that looks like a "draw"! Rock on!'


def solve(a, b):
	sa = sum((1 for (x, y) in zip(a, b) if x > y))
	sb = sum((1 for (x, y) in zip(a, b) if y > x))
	return '{}, {}: {}'.format(sa, sb, 'that looks like a "draw"! Rock on!' if sa == sb else ['Bob made "Jeff" proud!', 'Alice made "Kurt" proud!'][sa > sb])


from operator import gt
from numpy import sign
result = {-1: 'Bob made "Jeff" proud!', 0: 'that looks like a "draw"! Rock on!', 1: 'Alice made "Kurt" proud!'}

def solve(a, b):
	alice = sum(map(gt, a, b))
	bob = sum(map(gt, b, a))
	return f'{alice}, {bob}: {result[sign(alice - bob)]}'


def solve(a, b):
	x = sum([1 for i in range(3) if a[i] > b[i]])
	y = sum([1 for i in range(3) if a[i] < b[i]])
	if x > y:
		return f'{x}, {y}: Alice made "Kurt" proud!'
	elif x < y:
		return f'{x}, {y}: Bob made "Jeff" proud!'
	else:
		return f'{x}, {y}: that looks like a "draw"! Rock on!'


def solve(a, b):
	A = sum((x > y for (x, y) in zip(a, b)))
	B = sum((x < y for (x, y) in zip(a, b)))
	(winner, name) = ('Alice', 'Kurt') if A > B else ('Bob', 'Jeff')
	return '{}, {}: that looks like a "draw"! Rock on!'.format(A, B) if A == B else '{}, {}: {} made "{}" proud!'.format(str(A), str(B), winner, name)


def solve(a, b):
	alis = 0
	bob = 0
	for i in range(3):
		if a[i] > b[i]:
			alis += 1
		elif a[i] < b[i]:
			bob += 1
	if alis == bob:
		return str(bob) + ', ' + str(alis) + ':' + ' that looks like a "draw"! Rock on!'
	elif max(alis, bob) == alis:
		return str(alis) + ', ' + str(bob) + ':' + ' Alice made "Kurt" proud!'
	else:
		return str(alis) + ', ' + str(bob) + ':' + ' Bob made "Jeff" proud!'


def solve(a, b):
	alice = sum((x > y for (x, y) in zip(a, b)))
	bob = sum((x < y for (x, y) in zip(a, b)))
	return ('{}, {}: Alice made "Kurt" proud!' if alice > bob else '{}, {}: Bob made "Jeff" proud!' if alice < bob else '{}, {}: that looks like a "draw"! Rock on!').format(alice, bob)


def solve(a, b):
	count_A = 0
	count_B = 0
	for i in range(len(a)):
		if a[i] > b[i]:
			count_A += 1
		elif a[i] < b[i]:
			count_B += 1
	return f'{count_A}, {count_B}: that looks like a "draw"! Rock on!' if count_A == count_B else f'{count_A}, {count_B}: Alice made "Kurt" proud!' if count_A > count_B else f'{count_A}, {count_B}: Bob made "Jeff" proud!'


def solve(a, b):
	table_score = {'Player1': 0, 'Player2': 0}
	for (i, s) in enumerate(a):
		if s > b[i]:
			table_score['Player1'] += 1
		if s < b[i]:
			table_score['Player2'] += 1
	if table_score['Player1'] == table_score['Player2']:
		return '{0}, {1}: that looks like a "draw"! Rock on!'.format(table_score['Player1'], table_score['Player2'])
	if table_score['Player1'] > table_score['Player2']:
		return '{0}, {1}: Alice made "Kurt" proud!'.format(table_score['Player1'], table_score['Player2'])
	if table_score['Player1'] < table_score['Player2']:
		return '{0}, {1}: Bob made "Jeff" proud!'.format(table_score['Player1'], table_score['Player2'])


def solve(a, b):
	c1 = 0
	c2 = 0
	for i in range(len(a)):
		if a[i] > b[i]:
			c1 += 1
		elif a[i] == b[i]:
			pass
		else:
			c2 += 1
	if c1 == c2:
		return '{}, {}: that looks like a "draw"! Rock on!'.format(c1, c2)
	elif c1 > c2:
		return '{}, {}: Alice made "Kurt" proud!'.format(c1, c2)
	else:
		return '{}, {}: Bob made "Jeff" proud!'.format(c1, c2)


def solve(a, b):
	a_count = 0
	b_count = 0
	for i in range(len(a)):
		if a[i] > b[i]:
			a_count += 1
		elif a[i] < b[i]:
			b_count += 1
	if a_count > b_count:
		return '{a_count}, {b_count}: Alice made "Kurt" proud!'.format(a_count=a_count, b_count=b_count)
	elif b_count > a_count:
		return '{a_count}, {b_count}: Bob made "Jeff" proud!'.format(a_count=a_count, b_count=b_count)
	else:
		return '{a_count}, {b_count}: that looks like a "draw"! Rock on!'.format(a_count=a_count, b_count=b_count)