Next() skips the actual and next item in list, when it should only skip the actual item

Question

I'm writing a program that, giving a list of integers, identify the minimum value and then remove the minimum with the minor index of the list.

Ex: list = [3, 6, 15, 2, 4, 2] should return [3, 6, 15, 4, 2] Notice the first 2 removed because of the minor index on the list.

This is my entire code:

def remove_smallest(numbers):
    mylist = []
    if not numbers:
        return mylist 
    minimo = min(numbers)
    if numbers.count(minimo) > 1:
        numbers = numbers[::-1] #My solution to the minor index is to reverse the list and loop. Then reverse again.

        #mylist = [item for item in numbers if item != minimo and item not in mylist]  #I tried to use a list comprehension, with awful results.

        it = iter(numbers)
        for item in it:
            if item == minimo and item in mylist:
                next(it, None)
                continue
            mylist.append(item)

    print(mylist[::-1])

remove_smallest([2, 4, 5, 1, 2, 1])

First two items will get appended to "mylist" (1, 2). Then, because 1 is on mylist, it will skip it and then continue. So far so good, however when it should select the 5, it does not, instead goes straight to the 4 and then 2, resulting in an array that looks like this at the end of the program: [2, 4, 2, 1] when it should return [2, 4, 5, 2, 1]

Thanks

To clarify *why* that is - `for item in it:` advances the iterator directly, you don't need to do it manually with `next()`. Unrelated suggestion: `numbers.remove(min(numbers))` is a one-liner that solves this use case — Green Cloak Guy, Jul 16 '19 at 17:08
The `for` loop itself is (implicitly) calling `next`. You don't need to do it yourself. — chepner, Jul 16 '19 at 17:08

score 2 · Answer 1 · answered Jul 16 '19 at 17:08

Removing the next statement has the code work in the expected way. The for loop is already calling next on the iterator so no need to manually.

def remove_smallest(numbers):
    mylist = []
    if not numbers:
        return mylist 
    minimo = min(numbers)
    if numbers.count(minimo) > 1:
        numbers = numbers[::-1] #My solution to the minor index is to reverse the list and loop. Then reverse again.

        it = iter(numbers)
        for item in it:
            if item == minimo and item in mylist:
                continue
            mylist.append(item)

    print(mylist[::-1])

remove_smallest([2, 4, 5, 1, 2, 1])

Results in:

[2, 4, 5, 2, 1]

Just a suggestion that using if not numbers is a bad practise in python - https://stackoverflow.com/a/100903/7841468 — shuberman, Jul 16 '19 at 17:15
@mishsx since everything is assuming that `numbers` is a list, then `if not numbers` as a "if it's empty" check seems fine... — Jon Clements, Jul 16 '19 at 17:24

score 2 · Accepted Answer · answered Jul 16 '19 at 17:15

2

A simple statement will remove the smallest value. l.index(min(l)) finds the index of the smallest value.

>>> l = [2,4,5,1,2,1]
>>> del l[l.index(min(l))]
>>> l
[2, 4, 5, 2, 1]

answered Jul 16 '19 at 17:15

Deepstop

3,627
2
8
21

Not only did you solved my question, but the entire purpose of the exercise. – WhiteHeadbanger Jul 16 '19 at 18:20

Austin · Answer 3 · 2019-07-16T17:17:36.073

1

I will devise a new approach, as I find yours is too much code:

def remove_smallest(lst):
    mini = min(lst)
    indx = next((i for i, x in enumerate(lst) if x == mini), -1)
    del lst[indx]
    return lst

which safely removes first occurance of the minimum element in the list.

Usage:

>>> remove_smallest([2, 4, 5, 1, 2, 1])
[2, 4, 5, 2, 1]

edited Jul 16 '19 at 17:17

answered Jul 16 '19 at 17:10

Austin

25,759
4
25
48

OK, but that will calculate `min(lst)` N times, where N is list length. Why not just `indx = lst.index(min(lst))`? – zvone Jul 16 '19 at 17:13
@zvone, oops! my bad. Overlooked that point. Corrected the computation of `min(lst)` and probably this will help someone understand how `next` works. – Austin Jul 16 '19 at 17:15

Dalvenjia · Answer 4 · 2019-07-16T17:23:40.760

this function will remove the first occurrence of the smallest number in a list and return that number, the list is modified in-place so no need to return it:

def pop_smallest(lst):
    smallest = lst.index(min(lst))
    return lst.pop(smallest)

l = [2, 4, 5, 1, 2, 1]
pop_smallest(l)
>>> 1

l
>>> [2, 4, 5, 2, 1]

but if you don't want to modify the original list then you need to copy the list and return the new list

def pop_smallest(lst):
    new_lst = lst.copy()
    smallest = new_lst.index(min(lst))
    new_lst.pop(smallest)
    return new_lst

l = [2, 4, 5, 1, 2, 1]
new_l = pop_smallest(l)

l
>>> [2, 4, 5, 1, 2, 1]
new_l
>>> [2, 4, 5, 2, 1]

Next() skips the actual and next item in list, when it should only skip the actual item

4 Answers4