Is there a way to find the proximity in two numbers in a list?

I was trying to write a program that received a list of intengers and return a list with the proximity of each item in the list to the closest number 0.

Ex: [5, 0, 8, 87, 96, 0, 54]
It should return [1, 0, 1, 2, 1, 0, 1]

I tried creating an index to monitor the process and then creating a loop to look through them "while list[index] != 0" but it ended up going out of the list range.

Use a for loop to iterate over the list. The easiest way to make sure you get the distance in both directions is to simply iterate forward and backward:

>>> def zero_proximity(nums):
...     result = [len(nums) for _ in nums]
...     for d in (+1, -1):
...         p = len(nums)
...         for i in range(len(nums))[::d]:
...             if nums[i] == 0:
...                 p = 0
...             else:
...                 p += 1
...             result[i] = min(result[i], p)
...     return result
...
>>> zero_proximity([5, 0, 8, 87, 96, 0, 54])
[1, 0, 1, 2, 1, 0, 1]

I believe this question can be solved with arrays relatively easily:

arr_num = np.array([5, 0, 8, 87, 96, 0, 54])
num_of_0 = np.sum(arr_num == 0)
dist_to_0 = np.empty(len(arr_num),dtype=int)

for i in np.argsort(arr_num):
    dist_to_0[i] = min([abs(i-j) for j in np.argsort(arr_num)[:num_of_0]])

This code uses the function np.argsort to obtain the indices that each element of the array would need to have associated, in order to have the array in ascending order. The zeros appear first in the ordered array, and the rest of the elements have an ordered index that can be related to the ordered index of the zeros. In the example provided, np.argsort(arr_num) is equal to np.array([1, 5, 0, 2, 6, 3, 4]), where the 1 and 5 are the indices of the zero elements and so on.

Now, for each element of arr_num, we need to compute the minimum difference to the zeros, by taking the absolute value of the difference of the corresponding indices, which is done creating a list of these differences with the list comprehension syntax, and then taking the minimum. This value is saved in a new array, dist_to_0. It will necessarily be 0 for the zeros, and the correct distance for the rest.

If your number list includes negative values, you need to replace the np.argsort argument with abs(arr_num).

Let's iterate your list, every time we see a 0, we're gonna remember the index of that zero in the list. When we reach the next 0 in the list, we're gonna make decision about the numbers in between, which is pretty straight forward. From the last_0_seen index to the middle will be closer to the first 0, and from the middle index to the index we are at now (which its value is 0) will be closer to the second 0. The only special cases are the first and the last 0, which the numbers before and after them should be handled.

list = [5, 0, 8, 87, 96, 0, 54]
distance = []  # the result will be in this list

last_0_seen = -1
for index, value in enumerate(list):
    if value == 0 and last_0_seen == -1:  # if it's the first 0
        new_distances = [*range(index + 1)]
        new_distances.reverse()
        distance.extend(new_distances)
        last_0_seen = index
    elif value == 0 and last_0_seen != -1:
        mid_index = (last_0_seen + index) // 2
        first_part_distance = [*range(1, mid_index - last_0_seen + 1)]
        second_part_distance = [*range(0, index - mid_index)]
        second_part_distance.reverse()
        distance.extend(first_part_distance + second_part_distance)
        last_0_seen = index

distance.extend([*range(len(list) - len(distance))])  # handling numbers after the last 0

numbers = [5, 0, 8, 87, 96, 0, 54]
indices = [index for index, num in enumerate(numbers) if num == 0]
distance_lists = [[abs(num - index) for num in range(len(numbers))] for index in indices]

print([min(tpl) for tpl in zip(*distance_lists)])

Output:

[1, 0, 1, 2, 1, 0, 1]

Explanation:
indices is just a list of indices at which a zero was found in numbers:

>>>indices
   [1, 5]
>>>

We found a zero at index 1, and index 5.

distance_lists is a list of lists. Each sub-list represents the "distance" to just one of our zeros:

>>>distance_lists
   [[1, 0, 1, 2, 3, 4, 5], [5, 4, 3, 2, 1, 0, 1]]
>>>

Finally, this list:
[min(tpl) for tpl in zip(*distance_lists)] just compares the values of both distance lists, and picks the smaller value at any given index:

1, 0, 1, 2, 3, 4, 5
5, 4, 3, 2, 1, 0, 1
|  |  |  |  |  |  |
v  v  v  v  v  v  v
1, 0, 1, 2, 1, 0, 1

In my opinion, the easiest way is to get a list of the indexes of each zero in a list and then iterate over that list as well as the original one. You then get the absolute value of the result of subtracting each item being iterated by using abs, and append it to another list. Then get the minimum number from that list by using min. Do that for each item, and you will have your desired list.

The complete algorithm that can be used here is shown below.

'''
1 - Create a function that will accept a list of numbers and return a list of numbers that show the proximity to the nearest zero in the passed in list.
    1.1 - Create an empty list to hold the indexes of each zero passed in the function parameters.
    1.2 - Create an empty list to hold the final list we will return with the function.
    1.3 - Create a for loop that will loop over each number passed in the function parameters.
        1.3.1 - If number equals zero then append its index to the list created in step '1.1'.
    1.4 - Create another for loop that will loop over each number passed in the function parameters.
        1.4.1 - Create a temporary list to hold the distance to each zero in the list created in step '1.1'.
        1.4.2 - Create a loop over each item in the list created in step '1.1'.
            1.4.2.1 - Calculate each number index from loop in step '1.4' minus the number from the loop in step '1.4.2' and append its absolute value to the list created in step '1.4.1'.
        1.4.3 -  Append the minimun value from the list created in step '1.4.1' to the list created in step '1.2'.
    1.5 - Return the list declared in step '1.2'.

2 - Print the result of running the function declared in step '1'.
'''

Check the code below for an example of implementing this using Python.

def get_proximity_to_zero_for_each_item_in_list(numbers: list[int]) -> list[int]:
    zero_indexes = []
    proximity_list = []

    for index in range(len(numbers)):
        if numbers[index] == 0:
            zero_indexes.append(index)

    if len(zero_indexes) != 0:
        for number_index in range(len(numbers)):
            distance_from_each_zero_index = []
            for zero_index in zero_indexes:
                distance_from_each_zero_index.append(abs(number_index - zero_index))    
            proximity_list.append(min(distance_from_each_zero_index))

    return proximity_list


number_list = [5, 0, 8, 87, 96, 0, 54]
proximity_to_zero_list = get_proximity_to_zero_for_each_item_in_list(number_list)
print(proximity_to_zero_list) # should print [1, 0, 1, 2, 1, 0, 1]