## Terminal game move function

In this game, the hero moves from left to right. The player rolls the dice and moves the number of spaces indicated by the dice **two times**.

~~~if-not:sql
Create a function for the terminal game that takes the current position of the hero and the roll (1-6) and return the new position.
~~~
~~~if:sql
In SQL, you will be given a table `moves` with columns `position` and `roll`. Return a table which uses the current position of the hero and the roll (1-6) and returns the new position in a column `res`.
~~~

### Example:
```python
move(3, 6) should equal 15
```

```if:bf
### BF:

Since this is an 8kyu kata, you are provided a modified runBF function, numericRunBF, that automatically parses input and output for your ease.

See the sample test cases to see what I mean: You can simply input two numbers and get a number as output (unless you're doing something wrong), so it should be convenient for you to modify the tests as you wish.

Oh, and you won't have to worry about overflow, the correct answer will never be higher than 255. :)
```

Difficulty: EASY
Starter code: def move(position, roll):
	

Solutions:
def move(position, roll):
	return position + 2 * roll


move = lambda p, r: p + r * 2


def move(start, roll):
	return start + 2 * roll


def move(position, roll):
	return position + (roll << 1)


move = lambda p, m: p + 2 * m


move = lambda _, i: _ + 2 * i


move = lambda position, roll: position + roll * 2


def move(position, roll):
	x = position
	y = roll
	return x + y * 2


def move(p, r):
	return p + r * 2


import unittest

def move(position, roll):
	return position + roll * 2

class TestMove(unittest.TestCase):

	def test_move(self):
		self.assertEqual(move(position=0, roll=4), 8)


def move(position, roll):
	if roll < 1 or roll > 6:
		return 'Error'
	else:
		new_position = position + roll * 2
		return new_position


def move(position, roll):
	a = position
	b = roll
	c = 2 * b + a
	return c


move = lambda p, r: ['there are bees on my knees', 2, 4, 6, 8, 10, 12].__getitem__(r) + p


def move(pos, mov):
	return pos + 2 * mov


def move(position, roll):
	return position + 2 * roll
print(move(1, 4))


def move(position, roll):
	a = position + roll + roll
	return a


def move(pos, roll):
	return pos + 2 * roll


def move(position, roll):
	if roll < 7:
		return position + roll * 2


def move(position, roll):
	res = 0
	res = roll * 2 + position
	return res


move = lambda pos, roll: pos + roll * 2


def move(position, roll):
	if roll == 1:
		return position + 2 * roll
	if roll == 2:
		return position + 2 * roll
	if roll == 3:
		return position + 2 * roll
	if roll == 4:
		return position + 2 * roll
	if roll == 5:
		return position + 2 * roll
	if roll == 6:
		return position + 2 * roll


def move(position, roll):
	return roll * 2 if position == 0 else (position + roll) * 2 - position


def move(position, roll):
	double = roll * 2
	return position + double
move(1, 1)


move = lambda a, b: a + 2 * b


def move(position, roll):
	n = position + roll + roll
	return n


def move(position, roll):
	return roll + (position + roll)


def move(position, roll, moves=2):
	return move(position, roll, moves - 1) + roll if moves else position


def move(P, R):
	return P + 2 * R


def move(position, roll):
	moves = roll * 2
	new_position = position + moves
	return new_position


def move(position, roll):
	diceOver = 2 * roll
	newPos = diceOver + position
	return newPos


def move(position, roll):
	i = 0
	for i in range(roll):
		position += 2
	return position
move(0, 4)


def move(position, roll):
	x = roll * 2
	newpos = x + position
	return newpos


def move(position, roll):
	return position + roll * 2
print(move(3, 6))


def move(n, b):
	return n + 2 * b


def move(position, roll):
	new_pos = position + roll * 2
	print(new_pos)
	return new_pos


position = 0
roll = 0

def move(position, roll):
	inp = position + roll * 2
	return inp
move(0, 4)


def move(position, roll):
	new_position = position + roll + roll
	return new_position


def move(x, y):
	return y * 2 + x


def move(position, roll):
	total_roll = roll * 2
	new_position = position + total_roll
	return new_position


move = lambda x, n: x + 2 * n


def move(position, roll):
	return position + 2 * roll
print(move(2, 5))


def move(position, roll):
	pos = position + roll + roll
	return pos


def move(position, roll):
	a = position
	import random
	b = roll
	c = a + b + b
	return c


def move(position, roll):
	y = int(roll) * 2
	x = int(position)
	equ = y + x
	return equ


def move(position, roll):
	return position + roll * 2
print(move(0, 4))


def move(position, roll):
	if roll >= 1 and roll <= 6:
		position += roll * 2
		return position