如何在嵌套结构中查找元素并返回索引

Question

I have a square grid represented by a list of list of lists - for example:

grid = [[[9,3], [], [4]], 
        [[10, 1, 2], [], [11,5]],
        [[8], [7, 6], []]]

There is no limit on the lengths of the innermost lists (cells). The grid must contain all integers from 1 to n, where n is a given number (in this case, 11), and each number can only appear once.

I need to select a random number between 1 and n with uniform probability and return the location of the number (ie for '3' I would need grid[0][0][1]). Because the probability needs to be uniform, I can't just select a random cell, and then select a random number in the cell, because that would bias the selection towards numbers in cells with fewer numbers in them.

My initial approach has been to generate a random number between 1 and n, and then look through the entire grid for the number. However, the grid can become quite big. What is a more optimal approach to this problem?

Answer 1

If you have to find a number of items in the grid, you can create a map of the array and then just lookup the random number in the locations dictionary. But if you're only ever going to need to find a single number in a grid, then you can just power through it until you find it.

grid = [[[9,3], [], [4]], 
        [[10, 1, 2], [], [11,5]],
        [[8], [7, 6], []]]

locations = {n: (i, j, k)
    for i in range(len(grid))
    for j in range(len(grid[0]))
    for k, n in enumerate(grid[i][j])
}

print(locations)
# {
#   1: (1, 0, 1), 
#   2: (1, 0, 2), 
#   3: (0, 0, 1), 
#   4: (0, 2, 0), 
#   5: (1, 2, 1), 
#   6: (2, 1, 1), 
#   7: (2, 1, 0), 
#   8: (2, 0, 0), 
#   9: (0, 0, 0), 
#   10: (1, 0, 0), 
#   11: (1, 2, 0)
# }

rand_int = random.choice(locations.keys())
print(rand_int, locations[rand_int])
# (10, (1, 0, 0))

Answer 2

You can create dict that will map your array of arrays like this

arrays_map = {9:'1,1,1', 3: '1,1,2'...}
n = len(arrays_map.values())
random_number = arrays_map[radom.randint(0, n)]

Answer 3

If you have variable depth of nested list of numbers, you can do the following, the code is not perfect, just to demonstrate the idea

import random

grid = [[[9,3], [], [4]], 
        [[10, 1, 2], [], [11,5]],
        [[8], [7, 6], []]]


number_index_map = dict()
def create_map(grid, index_string): # you could other useful datastructure like list or tuple for storing the index_string
    for i, val in enumerate(grid):
        if isinstance(grid[i], list):
            next_index_string = "%s,%d"%(index_string, i) if len(index_string) else "%d"%(i)
            create_map(grid[i], next_index_string)
        else:
            key = "%s,%d"%(index_string, i) if len(index_string) else "%d"%(i)
            number_index_map[val] = key

create_map(grid, "")
print(number_index_map)


#test
n = 11
random_number = random.randint(1, n)
print("random number %d " % random_number)
random_number_index = number_index_map[random_number]
print("random number index %s"%random_number_index)

# to get back the number from the index string
temp = grid
list_index = random_number_index.split(",")
print("list index ", list_index)
for i in list_index:
    temp=temp[int(i)]
print(temp)

Answer 4

If I am understanding the question well, I suggest that we can use recursion to search various dimensions and lengths in the list and locate a number and it's position:

import random

grid = [[[9,3], [], [4]], 
        [[10, 1, 2], [], [11,5]],
        [[8], [7, 6], []]]

def lookfor(num, grid, pos=[]):

    for i in range(len(grid)):

        if isinstance(grid[i], list):
            pos.append(i)
            pos2 = lookfor(num, grid[i], pos[:])
            if pos2 != pos:
                return pos2
            else:
                pos.pop()

        elif grid[i] == num:
            pos.append(i)
            return pos

    return pos

num = random.randint(1, 11)

print(num, '>', lookfor(num, grid))