Background
----------
In another dimension, there exist two immortal brothers: Solomon and Goromon. As sworn loyal subjects to the time elemental, Chronixus, both Solomon and Goromon were granted the power to create temporal folds. By sliding through these temporal folds, one can gain entry to parallel dimensions where time moves relatively faster or slower.

Goromon grew dissatisfied and one day betrayed Chronixus by stealing the Temporal Crystal, an artifact used to maintain the time continuum. Chronixus summoned Solomon and gave him the task of tracking down Goromon and retrieving the Temporal Crystal.

Using a map given to Solomon by Chronixus, you must find Goromon's precise location.

Mission Details
---------------
The map is represented as a 2D array. See the example below:

```python
map_example = [[1,3,5],[2,0,10],[-3,1,4],[4,2,4],[1,1,5],[-3,0,12],[2,1,12],[-2,2,6]]
```
Here are what the values of each subarray represent:
- **Time Dilation:** With each additional layer of time dilation entered, time slows by a factor of `2`. At layer `0`, time passes normally. At layer `1`, time passes at half the rate of layer `0`. At layer `2`, time passes at half the rate of layer `1`, and therefore one quarter the rate of layer `0`.
- **Directions** are as follow: `0 = North, 1 = East, 2 = South, 3 = West`
- **Distance Traveled:** This represents the distance traveled relative to the current time dilation layer. See below:

```
The following are equivalent distances (all equal a Standard Distance of 100):
Layer: 0, Distance: 100
Layer: 1, Distance: 50
Layer: 2, Distance: 25
```
For the `mapExample` above:
```
mapExample[0] -> [1,3,5]
1 represents the level shift of time dilation
3 represents the direction
5 represents the distance traveled relative to the current time dilation layer

Solomon's new location becomes [-10,0]

mapExample[1] -> [2,0,10]
At this point, Solomon has shifted 2 layers deeper.
He is now at time dilation layer 3.
Solomon moves North a Standard Distance of 80.
Solomon's new location becomes [-10,80]

mapExample[2] -> [-3,1,4]
At this point, Solomon has shifted out 3 layers.
He is now at time dilation layer 0.
Solomon moves East a Standard Distance of 4.
Solomon's new location becomes [-6,80]
```
Your function should return Goromon's `[x,y]` coordinates.

For `mapExample`, the correct output is `[346,40]`.

Additional Technical Details
----------------------------
- Inputs are always valid.
- Solomon begins his quest at time dilation level `0`, at `[x,y]` coordinates `[0,0]`.
- Time dilation level at any point will always be `0` or greater.
- Standard Distance is the distance at time dilation level `0`.
- For given distance `d` for each value in the array: `d >= 0`.
- Do not mutate the input

**Note from the author:** I made up this story for the purpose of this kata. Any similarities to any fictitious persons or events are purely coincidental.

If you enjoyed this kata, be sure to check out [my other katas](https://www.codewars.com/users/docgunthrop/authored).

Difficulty: introductory

Starter code:

def solomons_quest(arr):
	

Solutions:
def solomons_quest(arr):
    pos, lvl = [0,0], 0
    for dilat,dir,dist in arr:
        lvl += dilat
        pos[dir in [0,2]] += dist * 2**lvl * (-1)**( dir in [2,3] )
    return pos

def solomons_quest(arr):
    level = 0
    ds = [1j, 1, -1j, -1]
    pos = 0
    for level_shift, direction, distance in arr:
        level += level_shift
        pos += (2**level) * (ds[direction] * distance)
    return [int(pos.real), int(pos.imag)]


#Directions player can move: North is positive y axis, East is positive x axis
class Direction:
    North = 0;  East = 1;  South = 2;  West = 3
#-----end classDirection


#The data of the hero of the story
class Solomon:
    curDir = Direction.North    #default direction is set to facing north
    xLoc = 0            # East and West directions (East is positive x)
    yLoc = 0            # North and South directions (Nortn is positive y)
    timeDepth = 0       #Current depth of the traveler
    timeFactor = 2      #This factor is constant and is based on game definition
#-----end class




def unpackWayPoint(wayPoint):
    amountTimeDialation = wayPoint[0]
    newDir = wayPoint[1]
    distToTravel = wayPoint[2]

    return amountTimeDialation, newDir, distToTravel
#-----end function



def updateHeroDistance(hero, dirOfTravel, trueDistToMove):

    if dirOfTravel == Direction.North:
        hero.yLoc += trueDistToMove
    elif dirOfTravel == Direction.South:
        hero.yLoc -= trueDistToMove
    elif dirOfTravel == Direction.East:
        hero.xLoc += trueDistToMove
    else:
        hero.xLoc -= trueDistToMove

#-----end fucntion

#a small helper debugger function
def printDist(hero):
    print(('''Hero's location: [''', hero.xLoc, ',', hero.yLoc, ']'))


def solomons_quest(wayPoints):
    hero = Solomon()

    for nextStop in wayPoints:
        amtTimeDialation, dirOfTravel, amtToTravel = unpackWayPoint(nextStop)

        #update hero based on the waypoint data
        hero.timeDepth += amtTimeDialation
        trueDistToMove = (hero.timeFactor**hero.timeDepth)*amtToTravel  #dist is based on depth and factor
        updateHeroDistance(hero, dirOfTravel, trueDistToMove)

    #pack data in a list
    heroFinalLoc = [hero.xLoc, hero.yLoc]

    return heroFinalLoc
#-----end function


def solomons_quest(arr):
    d, count, out = {0: 1, 1: 1, 2: -1, 3: -1}, 0, [0, 0]
    for i in arr:
        count += i[0]
        x = (2**count) * d[i[1]] * i[2]
        if i[1] % 2 == 1: out[0] += x
        else: out[1] += x
    return out

def solomons_quest(arr):
    south_north = 0
    east_west = 0
    layer = 0
    for el in arr:
        layer += el[0]
        if el[1] ==0:
            south_north +=  el[2] * 2**layer
        elif el[1]==2:
            south_north -= el[2] * 2**layer
        elif el[1]==1:
            east_west += el[2] * 2**layer
        elif el[1]==3:
            east_west -= el[2] * 2**layer
    
    return [east_west,south_north]


def solomons_quest(arr):
    d_t = 0
    loc = [0,0]
    for r in arr:
        d_t += r[0]
        if(r[1] > 1):
            loc[3%r[1]] -= r[2]*(2**d_t)
        else:
            loc[(r[1]+1)%2] += r[2]*(2**d_t)
    return loc

def solomons_quest(arr):
    l,c = 0,[0,0]
    for way in arr:
        l+=way[0]
        c[(way[1]+1)%2] += ((-1)**(way[1]//2)) *way[2]*(2**l)
    return c

def solomons_quest(arr):
  layer = 0
  coord = [0,0]
  for i in arr:
    layer = layer + i[0]
    if i[1] == 0: # increase the y-coordinate
      coord[1] = coord[1] + i[2] * 2 ** layer
    if i[1] == 1: # increase the x-coordinate
      coord[0] = coord[0] + i[2] * 2 ** layer
    if i[1] == 2: # decrease the y-coordinate
      coord[1] = coord[1] - i[2] * 2 ** layer
    if i[1] == 3: # decrease the x-coordinate
      coord[0] = coord[0] - i[2] * 2 ** layer
  return coord

def solomons_quest(arr):
    layer = x = y = 0
    for l, dir_, distance in arr:
        layer = [layer+l,0][layer+l<0]
        inc, dec, r = [1,0,-1,0][dir_], [0,1,0,-1][dir_], distance*2**layer
        x += inc * r ; y += dec * r
    return [y,x]

MOVE = [lambda d,x,y,l: (x, y+d, l), lambda d,x,y,l: (x+d, y, l), lambda d,x,y,l: (x, y-d, l), lambda d,x,y,l: (x-d, y, l)]

def solomons_quest(arr):
    x = y = l = 0
    for a,b,c in arr: x, y, l = MOVE[b](c * 2**(l+a), x, y, l+a)
    return [x, y]