In the board game Talisman, when two players enter combat the outcome is decided by a combat score, equal to the players power plus any modifiers plus the roll of a standard 1-6 dice. The player with the highest combat score wins and the opposing player loses a life. In the case of a tie combat ends with neither player losing a life.

For example:
```
Player 1: 5 Power, 0 Modifier
Player 2: 3 Power, 2 Modifier

Player 1 rolls a 4, Player 2 rolls a 2.

(5 + 0 + 4) -> (3 + 2 + 2)
Player 1 wins (9 > 7)
```

Your task is to write a method that calculates the required roll for the player to win.

The player and enemy stats are given as an array in the format:
```python
[power, modifier]
```

For example for the examples used above the stats would be given as:
```python
get_required([5, 0], [3, 2]) # returns 'Random'
```

If the player has at least 6 more power (including modifiers) than the enemy they automatically wins the fight, as the enemy's combat score couldn't possibly exceed the player's. In this instance the method should return "Auto-win".

For example:
```python
get_required([9, 0], [2, 1]) # returns 'Auto-win' as the enemy can't possibly win
```

If the enemy has at least 6 more power (including modifiers) than the player they automatically wins the fight, as the player's combat score couldn't possibly exceed the enemy's. In this instance the method should return "Auto-lose".

For example:
```python
get_required([2, 1], [9, 0]) # returns 'Auto-lose' as the player can't possibly win
```

If the player and enemy have the same power (including modifiers) the outcome is purely down to the dice roll, and hence would be considered completely random. In this instance the method should return "Random".

For example (as above):
```python
get_required([5, 0], [3, 2]) # returns 'Random' as it is purely down to the dice roll
```

If the player has greater power than the enemy (including modifiers) the player could guarantee a win by rolling a high enough number on the dice. In this instance the method should return a range equal to the numbers which would guarantee victory for the player.

```python
get_required([6, 0], [2, 2]) # returns '(5..6)' as rolling a 5 or 6 would mean the enemy could not win
get_required([7, 1], [2, 2]) # returns '(3..6)' as rolling anything 3 through 6 would mean the enemy could not win
```

If the player has less power than the enemy (including modifiers) the player can only win if the enemy rolls a low enough number, providing they then roll a high enough number. In this instance the method should return a range equal to the numbers which would allow the player a chance to win.

```python
get_required([4, 0], [6, 0]) # returns '(1..3)' as this would be the only outcome for which the player could still win
get_required([1, 1], [6, 0]) # returns '(1..1)' as this would be the only outcome for which the player could still win
```

If the better case scenario for the player is to hope for a tie, then return `"Pray for a tie!"`.

```python
get_required([7, 2], [6, 8]) # returns "Pray for a tie!"
```

Difficulty: EASY
Tags: Game theory

Starter code:
def get_required(player,enemy):
	

Solutions:
def get_required(player, enemy):
	p_sum = sum(player)
	e_sum = sum(enemy)
	diff = p_sum - e_sum
	if diff == 0:
		return 'Random'
	if diff > 5:
		return 'Auto-win'
	if diff < -5:
		return 'Auto-lose'
	if diff == -5:
		return 'Pray for a tie!'
	s = ''
	if diff < 0:
		s = '(1..{0})'.format(6 - abs(diff) - 1)
	else:
		s = '({0}..6)'.format(6 - diff + 1)
	return s


def get_required(player, enemy):
	(s1, s2) = (sum(player), sum(enemy))
	return 'Auto-win' if s1 >= s2 + 6 else 'Auto-lose' if s2 >= s1 + 6 else 'Random' if s1 == s2 else 'Pray for a tie!' if s1 + 5 == s2 else f'(1..{5 + s1 - s2})' if s1 < s2 else f'({7 - s1 + s2}..6)'


def get_required(player, enemy):
	p = player[0] + player[1]
	e = enemy[0] + enemy[1]
	if p == e:
		return 'Random'
	elif p > e:
		if p - 6 >= e:
			return 'Auto-win'
		else:
			return '(%d..6)' % (e + 7 - p)
	elif p < e:
		if p <= e - 6:
			return 'Auto-lose'
		elif e - p == 5:
			return 'Pray for a tie!'
		else:
			return '(1..%d)' % (p + 5 - e)


def get_required(p, e):
	(s1, s2) = (sum(p), sum(e))
	if s1 >= s2 + 6:
		return 'Auto-win'
	elif s2 >= s1 + 6:
		return 'Auto-lose'
	elif s1 == s2:
		return 'Random'
	elif s1 == s2 - 5:
		return 'Pray for a tie!'
	elif s2 > s1:
		return f'(1..{5 - (s2 - s1)})'
	else:
		return f'({7 - (s1 - s2)}..6)'


def get_required(player, enemy):
	(p, e) = (sum(player), sum(enemy))
	if p == e:
		return 'Random'
	elif p - e >= 6:
		return 'Auto-win'
	elif e - p >= 6:
		return 'Auto-lose'
	elif p > e:
		return f'({e - p + 7}..6)'
	elif e - p < 5:
		return f'(1..{p + 5 - e})'
	return 'Pray for a tie!'


def get_required(player, enemy):
	difference = player[0] + player[1] - enemy[0] - enemy[1]
	if difference >= 6:
		return 'Auto-win'
	elif difference <= -6:
		return 'Auto-lose'
	elif difference == -5:
		return 'Pray for a tie!'
	elif difference == 0:
		return 'Random'
	elif difference > 0:
		return '(' + str(6 - difference + 1) + '..' + '6)'
	else:
		return '(1' + '..' + str(6 - abs(difference - 1)) + ')'


def get_required(player, enemy):
	p = player[0] + player[1]
	e = enemy[0] + enemy[1]
	if p == e:
		return 'Random'
	if p >= e + 6:
		return 'Auto-win'
	if e >= p + 6:
		return 'Auto-lose'
	if p > e:
		return '({0}..6)'.format(e - p + 7)
	if p + 5 > e:
		return '(1..{0})'.format(p - e + 5)
	return 'Pray for a tie!'


def get_required(player, enemy):
	(p, e) = (sum(player), sum(enemy))
	math_wins = [x for x in range(1, 7) if p + x > e + 6]
	lucky = [x for x in range(1, 7) if e + x < p + 6]
	return 'Random' if p == e else 'Auto-win' if p >= e + 6 else 'Auto-lose' if e >= p + 6 else 'Pray for a tie!' if e - p == 5 else '({}..{})'.format(min(math_wins), max(math_wins)) if p > e else '({}..{})'.format(min(lucky), max(lucky))