有意思的面试题 Spiral Memory

Spiral Memory

You come across an experimental new kind of memory stored on an infinite two-dimensional grid.

Each square on the grid is allocated in a spiral pattern starting at a location marked 1 and then
counting up while spiraling outward. For example, the first few squares are allocated like this:
“”"
Draws a sprial memory, e.g
17 16 15 14 13
18 5 4 3 12
19 6 1 2 11
20 7 8 9 10
21 22 -->…
While this is very space-efficient (no squares are skipped), requested data must be carried back to
square 1 (the location of the only access port for this memory system) by programs that can only
move up, down, left, or right. They always take the shortest path: the Manhattan Distance between
the location of the data and square 1.

For example:

Data from square 1 is carried 0 steps, since it’s at the access port.
Data from square 12 is carried 3 steps, such as: down, left, left.
Data from square 23 is carried only 2 steps: up twice.
Data from square 1024 must be carried 31 steps.
How many steps are required to carry the data from the square identified in your puzzle input all
the way to the access port?

How to test your answer:
If you input: 100000 Your Answer should be: 173
If you input: 2345678 　Your Answer should be: 　　1347

import numpy as np

orgGird = np.array([[4, 3], [1, 2]], dtype=int)

#shape是用来生成多大的矩阵。
def madeGird(shape, maxNum):
    global orgGird
    for i in range(2, shape):
        oldSize, _ = orgGird.shape
        newSize = oldSize + 1
        newGird = np.zeros((newSize, newSize))
        try:
            #当是奇数矩阵的时候向右上角挪动
            if newSize % 2 == 1:
                newGird[0:-1, 1:] = orgGird
                for j in range(newSize):
                    newGird[j, 0] = oldSize*oldSize + 1 + j
                    if newGird[j, 0] == maxNum:
                        return
                for j in range(1, newSize):
                    newGird[newSize - 1, j] = newGird[newSize -1, 0] + j
                    if newGird[newSize - 1, j] == maxNum:
                        return
            else:
                #当是偶数的时候向左下角移动
                newGird[1:, 0:-1] = orgGird
                for j in reversed(range(newSize)):
                    newGird[j, -1] = oldSize*oldSize + 1 + oldSize -j
                    if newGird[j, -1] == maxNum:
                        return
                for j in reversed(range(newSize -1)):
                    newGird[0, j] = 1 + newGird[0, j + 1]
                    if newGird[0, j] == maxNum:
                        return
        finally:
            orgGird = newGird


def main():
    ################### At here input your number################
    inputNum = 2345678
    ################### At here input your number################

    sqrt = inputNum ** 0.5
    sqrt_int = int(sqrt)
    if sqrt > float(sqrt_int):
        sqrt_int += 1

    madeGird(sqrt_int, inputNum)
    #print(orgGird)
    one_pos = np.argwhere(orgGird == 1)
    one_x = one_pos[0][0]
    one_y = one_pos[0][1]

    input_pos = np.argwhere(orgGird == inputNum)
    inputNum_x = input_pos[0][0]
    inputNum_y = input_pos[0][1]

    distance = (max(one_x, inputNum_x) - min(one_x, inputNum_x)) + (max(one_y, inputNum_y) - min(one_y, inputNum_y))
    print('************************')
    print('         ' + str(distance) + '      ')
    print('************************')

if __name__ == '__main__':
    main()