在差小于或等于K的数组中找到所有数字

Question

I want to find two numbers A[i] and A[j] whose difference is less than or equal to K , I need to store index of such numbers in array L (Left) R (Right) and return L & R

def fun(A, k): 
    n = len(A)
    l = 0
    r = n-1
    # traverse the array for the two elements 
    while l<r: 
        if (A[l] - A[r] <= n):
            return A[l],A[r]
        elif (A[l] - A[r] < n): 
            l += 1
        else: 
            r -= 1
    return 0

# Driver code to test above function 
A = [3.5,5,6,12,13] 
k = 1.7
print(fun(A, k))

Expected output:

L[0,0,1,3,3],R[1,2,2,4,4]

Answer 1

You should use itertools.combinations to get all possible combinations, then test their differences and append if needed.

from itertools import combinations

def fun(A, k):
    l, r = [], []
    for (x_idx, x_val), (y_idx, y_val) in combinations(enumerate(A), 2):
        if abs(x_val - y_val) <= k:
            l.append(x_idx)
            r.append(y_idx)
    return l, r

Test:

A = [3.5,5,6,12,13] 
k = 1.7
print(fun(A, k))
# ([0, 1, 3], [1, 2, 4])

Though it's not your expected output, I feel like your expected output may have a few errors according to your logic.

Answer 2

An O(n log n) solution that exploits the ordering in your example A (if it's not ordered, you can always pay O(n log n) a second time to sort it, though preserving the original indices would likely make it not worth the complexity):

from bisect import bisect

def fun(A, k):
    # Add A.sort() if A not guaranteed to be sorted
    for l, x in enumerate(A):
        for r in range(l+1, bisect(A, x+k, l+1)):
            yield l, r

This uses the bisect.bisect function to find the end point for each start point in O(log n) time, making the overall cost O(n log n) . It doesn't even need to directly test most values against k , since bisect finds the end of the indices which meet the different criteria, and all values in between definitely meet it.

Rather than building the list manually, I've made this a generator function that can be converted to the L and R values with zip and unpacking:

>>> A = [3.5,5,6,12,13] 
>>> k = 1.7
>>> L, R = zip(*fun(A, k))
>>> print(L, R)
(0, 1, 3), (1, 2, 4)

You could do it with list s explicitly:

def fun(A, k):
    L, R = [], []
    for l, x in enumerate(A):
        newr = range(l+1, bisect(A, x+k, l+1))
        L += [l] * len(newr)
        R.extend(newr)
    return L, R

but I kind of like the generator->zip->unpack approach for letting Python do most of the work. Either way, the theoretical cost of O(n log n) is better than O(n * (n - 1) / 2) (roughly O(n ** 2) ).