## 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: introductory

Starter code:

def move(position, roll):
	

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

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

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

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

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

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

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

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

def move(position, roll):
    print(position)
    print(roll)
    position =  position + roll * 2
    return position
    # your code here


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

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


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

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

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):
    s = position + ( roll * 2)
    return s
    # your code here


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

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


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

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

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


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

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

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

# player moves from left to right
# The player rolls the dice and moves the number of spaces indicated by the dice two times.
# input - two integers
# output - integer

#edge cases - die roll can only be (1-6), no numbers given

# sample test (2, 7) = 16
# 2 + (7 * 2)

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

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):
    # your code here
    double = roll*2
    return position + double
    
move(1,1)

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

def move(position, roll):
    # your code here
    move = roll*2
    sum = position + move
    return sum

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


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

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

def move(position, roll):
    """Return the new player position"""
    return position + 2 * roll

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

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

def move(position, roll):
    # your code here
    new_pos = position + (roll *2)
    return new_pos 

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

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


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

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

def move(p, r):
    # your code here
    p=p+2*r
    return p 

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

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

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

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

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

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

def move(position, roll):
    pos = position + 2 * roll
    return pos# your code here

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

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

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

def move(position, roll):
    # your code here
    goal = position + 2 * roll
    return goal;

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

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

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):
    # your code here
    sum = (position + 2*roll)
    return sum

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

def move(position, roll):
    # your code here
    return position + roll * 2
    
print(move(3, 6))

def move(position, roll):
    # your code here
    return position + 2 * roll
    
print(move(3, 6))

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

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

def move(position, roll):
    new_pos = position + (roll*2)
    print(new_pos)
    return new_pos
    # your code here


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(position, roll):
    m = position+2*roll
    return(m)

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

def move(position, roll):
    # your code here
    new_pos=position+2*roll
    return new_pos

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

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

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

    return new_position

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

def move(position, roll):
    # Takes current p[osition and double the roll dice (1-6)
    return position + (roll * 2)

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

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

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

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

def move(position, roll):

    intPosition = position + roll * 2

    return intPosition

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

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

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


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

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

def move(position, roll):
    # your code here
    return (position + 2 * roll)

print((move(2, 5)))


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

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

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):
    new=position + (roll*2)
    return new

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