Python find indices in an array based on conditions

Question

I have a list/array(can make them arrays, doesn't matter):

array = [1,2,1,1,2,3,1,2,1,2,3,1,2,3,4,5]

I would like to create a new_array FROM array which looks like this:

new_array = [[1,2],[1],[1,2,3],[1,2],[1,2,3],[1,2,3,4,5]]

The logic I came up with was to start with a=0,b=1 and loop through array, when the value of array[a] < array[b], then a+=1,b+=1, but if the value of array[a]>=array[b], then append the value of b: Here is what I tried:

index_1 = [] # This will be the list which will have the FIRST index 
index_2 = [] # This will be the list which will have the SECOND index
a = 0
b = 1
for i in array:
    if i[a] < i[b]:
        a = a+1
        b = b+1
    elif i[a] >= i[b]:
        index_2.append(b)
        index_1.append(a)

So index_1 will have the first index and index_2 will have the second index and then, we can create the new_array by:

new_array = [(array[start:end]) for start,end in zip(index_1,index_2)]

Unfortunately, even though my idea is correct, the loop stops in if i[a]<i[b] because of IndexError: invalid index to scalar variable..

@juanpa.arrivillaga: doesn't matter, I can make them `numpy arrays` or let them be `lists`. — Srivatsan, Nov 08 '17 at 01:28
You can just try to `print(i)`, what do you get? So actually, what you need is `for _ in range(len(array))`, `array[a]` and `array[b]`. `i` is already an item inside `array`. — Sraw, Nov 08 '17 at 01:30
Of course it matters. Not only are the performance characterstics different, you can't really have staggered arrays in `numpy`, as your `new_array` implies — juanpa.arrivillaga, Nov 08 '17 at 01:31
@Sraw: so you mean I have to modify my `for` loop ? If so how ? Is everything else correct ? — Srivatsan, Nov 08 '17 at 01:32
I think you can simply have a loop that starts over when a 1 is approached. — , Nov 08 '17 at 01:43

MaximTitarenko · Accepted Answer · 2017-11-08T03:40:32.643

3

We can go through the array directly by the elements (more precisely by a pair of neighboring elements) simultaneously forming the result.

We initialize our result with a sublist of the 1st element of the array and then:

if the next element is greater than the previous one, we add it to the last sublist

otherwise - we add a new sublist with this element to the result.

array = [1,2,1,1,2,3,1,2,1,2,3,1,2,3,4,5]

new_array = [[array[0]]] # assume the array is not empty
for a,b in zip(array, array[1:]):
    if a<b:
        new_array[-1].append(b)
    else:
        new_array.append([b])

print(new_array)
# [[1, 2], [1], [1, 2, 3], [1, 2], [1, 2, 3], [1, 2, 3, 4, 5]]

UPD.

Alternatively, we can implement it with indices.
(based on this answer by @fortran)

First, prepare indices to split the array:

idxs_to_split = [idx for idx in range(1, len(array)) if not array[idx-1] < array[idx]]
pairs = zip([0] + idxs_to_split, idxs_to_split + [None])

Second, implement the splitting itself:

new_array = [array[i:j] for i,j in pairs]

print(new_array)
# [[1, 2], [1], [1, 2, 3], [1, 2], [1, 2, 3], [1, 2, 3, 4, 5]]

edited Nov 08 '17 at 03:40

answered Nov 08 '17 at 01:34

MaximTitarenko

886
4
8

Can you explain ? – Srivatsan Nov 08 '17 at 01:35
What does `new_array[-1].append(b)` do? I can understand `new_array.append([b])` – Srivatsan Nov 08 '17 at 01:47
1

`list[-1]` refers to the last element in a list, in this case it is another list, to which we append – 0TTT0 Nov 08 '17 at 01:49
1

@ThePredator, `new_array[-1]` is the current last sub-list of the result. In the above expression, we append `b` to it – MaximTitarenko Nov 08 '17 at 01:50
When we are zipping, where are we using `a` ? I only see that we append `b`. – Srivatsan Nov 08 '17 at 01:56
1

@ThePredator, `a` is needed for the comparison, which determines how exactly we will add `b` to the result – MaximTitarenko Nov 08 '17 at 01:58

score 2 · Answer 2 · answered Nov 08 '17 at 01:37

Here's a simple approach, just keep track of the previous, and check if it is smaller. If it is, append to sub. If it isnt, append sub to the new list, then create a new sub. Always append sub at the end.

>>> new_array = []
>>> array = [1,2,1,1,2,3,1,2,1,2,3,1,2,3,4,5]
>>> sub = []
>>> prev = float('-inf')
>>> for x in array:
...     if prev < x:
...         sub.append(x)
...     else:
...         new_array.append(sub)
...         sub = [x]
...     prev = x
...
>>> new_array.append(sub)
>>> new_array
[[1, 2], [1], [1, 2, 3], [1, 2], [1, 2, 3], [1, 2, 3, 4, 5]]

score 2 · Answer 3 · answered Nov 08 '17 at 01:39

def g(l):
    acc = []
    for i in l:
        if not acc:
            acc.append(i)
        else:
            if acc[-1] < i:
                acc.append(i)
            else:
                yield acc
                acc = [i]
    yield acc

Here's a generator version that should work for all iterables. Usage would be something like

list(g(array))

And gives the desired

[[1, 2], [1], [1, 2, 3], [1, 2], [1, 2, 3], [1, 2, 3, 4, 5]]

score 0 · Answer 4 · answered Nov 08 '17 at 01:53

0

I simply checked for two conditions, 1. If next element == 1 and 2. If j is at last element of the list.

array = [1,2,1,1,2,3,1,2,1,2,3,1,2,3,4,5]
newList = []

j = 0
k = 0
while j < len(array)-1:
    if array[j+1] ==1:
        newList.append(array[k:j+1])
        k = j+1
    if  j+2==len(array):
        newList.append(array[k:j+2])
        k = j + 1
   j +=1
print newList

answered Nov 08 '17 at 01:53

Bhushan Pant

1,445
2
13
29

The above was just a minimal example. I have different floating values in my original list. So I cannot use the condition of `==1`. Thanks for your effort anyway. – Srivatsan Nov 08 '17 at 01:57
Okay. I hope you get the answer. Happy solving :) – Bhushan Pant Nov 08 '17 at 01:59

Python find indices in an array based on conditions

4 Answers4

UPD.