CODEWITHSUNDEEP
pythonarraysloopsnumpyfor-loop
Mari
Mari

Reputation: 698

Make my Nested loops Works simpler (Operating Time is Higher)

I am a learner in nested loops in python.

Below I have written my code. I want to make my code simpler, since when I run the code it takes so much time to produce the result.

I have a list which contains 1000 values:

Brake_index_values = [ 44990678,  44990679,  44990680,  44990681,  44990682,  44990683,
             44997076,  44990684,  44997077,  44990685,
            ...
             44960673,   8195083,   8979525, 100107546,  11089058,  43040161,
             43059162, 100100533,  10180192,  10036189]

I am storing the element no 1 in another list

original_top_brake_index = [Brake_index_values[0]]

I created a temporary list called temp and a numpy array for iteration through Loop:

temp =[]
arr = np.arange(0,1000,1)

Loop operation:

for i in range(1, len(Brake_index_values)):
    if top_15_brake <= 15:
        a1 = Brake_index_values[i]
        #a2 = Brake_index_values[j]
        a3 = arr[:i]
        for j in a3:
            a2 = range(Brake_index_values[j] - 30000, Brake_index_values[j] + 30000)
            if a1 in a2:
                pass
            else:
                temp.append(a1)
        if len(temp)== len(a3):
            original_top_brake_index.append(a1)
            top_15_brake += 1
            del temp[:]
        else:
            del temp[:]
            continue

I am comparing the Brake_index_values[1] element available between the range of 30000 before and after Brake_index_values[0] element, that is `range(Brake_index_values[0]-30000, Brake_index_values[0]+30000).

If the Brake_index_values[1] available between the range, I should ignore that element and go for the next element Brake_index_values[2] and follow the same process as before for Brake_index_values[0] & Brake_index_values[1]

If it is available, store the Value, in original_top_brake_index thorough append operation.

In other words :

(Lets take 3 values a,b & c. I am checking whether the value b is in range between (a-30000 to a+30000). Possibility 1: If b is in between (a-30000 to a+30000) , neglect that element (Here I am storing inside a temporary list). Then the same process continues with c (next element) Possibility 2: If b is not in b/w those range put b in another list called original_top_brake_index (this another list is the actual result what i needed)

The result I get:

It is working, but it takes so much time to complete the operation and sometimes it shows MemoryError.

I just want my code to work simpler and efficient with simple operations.

Upvotes: 0

Views: 59

Answers (2)

Tarifazo
Tarifazo

Reputation: 4343

Try this code (with numpy): 

import numpy as np
original_top_brake_index = [Brake_index_values[0]]
top_15_brake = 0
Brake_index_values = np.array(Brake_index_values)
for i, a1 in enumerate(Brake_index_values[0:]):
    if top_15_brake > 15:
        break
    m = (Brake_index_values[:i] - a1)
    if np.logical_or(m > 30000, m < - 30000).all():
        original_top_brake_index.append(a1)
        top_15_brake += 1

Note: you can probably make it even more efficient, but this already should reduce the number of operations significantly (and doesn't change much the logic of your original code)

Upvotes: 1

gold_cy
gold_cy

Reputation: 14216

We can use the bisect module to shorten the elements we actually have to lookup by finding the smallest element that's greater or less than the current value. We will use recipes from here

Let's look at this example:

from bisect import bisect_left, bisect_right

def find_lt(a, x):
    'Find rightmost value less than x'
    i = bisect_left(a, x)
    if i:
        return a[i-1]
    return

def find_gt(a, x):
    'Find leftmost value greater than x'
    i = bisect_right(a, x)
    if i != len(a):
        return a[i]
    return

vals = [44990678,  44990679,  44990680,  44990681,  44990682, 589548954, 493459734, 3948305434, 34939349534]

vals.sort()  # we have to sort the values for bisect to work
passed = []
originals = []

for val in vals:
    passed.append(val)
    l = find_lt(passed, val)
    m = find_gt(passed, val)
    cond1 = (l and l + 30000 >= val)
    cond2 = (m and m - 30000 <= val)
    if not l and not m:
        originals.append(val)
        continue
    elif cond1 or cond2:
        continue
    else:
        originals.append(val)

Which gives us:

print(originals)

[44990678, 493459734, 589548954, 3948305434, 34939349534]

There might be another, more mathematical way to do this, but this should at least simplify your code.

Upvotes: 1

Related Questions