Как сгруппировать массивы, основываясь на разнице последнего элемента первого массива с первым элементом его последовательного массива?

Question

Я новичок в python, и это то, что я пытаюсь сделать, предположим, у меня есть массив

array([[1.03, 1.1 ],
       [1.12, 1.25],
       [2.02, 2.09],
       [2.15, 3.79],
       [4.73, 4.8 ],
       [4.89, 5.06],
       [5.28, 5.35],
       [5.67, 5.91],
       [6.5 , 6.57],
       [6.68, 9.1 ]])

Я пытаюсь сравнить последний элемент из [1.03, 1.1 ] т. е. «1.1» и первый элемент в [1.12, 1.25], т. е. «1.12», а если разница меньше 0,5, то определите новый массив, принимая первый элемент из [1.03, 1.1], т. е. «1.03» и последний элемент в [1.12 , 1.25] то есть '1.12', за этим новым массивом должны следовать другие элементы определенного массива. Таким образом, в основном я группирую массивы на основе различий в последнем элементе и первом элементе последовательных массивов. Я попытался обобщить свой вопрос наилучшим образом. Как это сделать в python, я пытаюсь сделать это с помощью циклов, но с треском провалился.

Answer 1

Надеюсь, что эта помощь

import numpy as np
arr = np.array([[1.03, 1.1 ],
       [1.12, 1.25],
       [2.02, 2.09],
       [2.15, 3.79],
       [4.73, 4.8 ],
       [4.89, 5.06],
       [5.28, 5.35],
       [5.67, 5.91],
       [6.5 , 6.57],
       [6.68, 9.1 ]])

def process(list_):
    for index in range(len(list_)-1):
        if list_[index+1][0] - list_[index][1] < 0.5: #perform comparison
            element_new = [list_[index][0], list_[index+1][1]] #new list element
            list_[index] = element_new #replace two old elements by the new elements
            list_.remove(list_[index+1])
            process(list_) #recursion
            break
    return list_

list1 = arr.tolist() #it is a good practice to perform remove/append action on list rather than numpy array
list2 = process(list1)
arr2 = np.array(list2)
print(arr2)

Answer 2

Может быть сделано без каких-либо циклов:

import numpy as np
arr = np.array([[1.03, 1.1 ],
       [1.12, 1.25],
       [2.02, 2.09],
       [2.15, 3.79],
       [4.73, 4.8 ],
       [4.89, 5.06],
       [5.28, 5.35],
       [5.67, 5.91],
       [6.5 , 6.57],
       [6.68, 9.1 ]])

toMerge = (arr[1:,0]-arr[:-1,1])<0.5          # flag neighbours to merged
breaks  = np.insert(toMerge==False,0,False)   # lines not merged with previous
starts  = np.insert(np.argwhere(breaks),0,0)  # indexes of start lines
ends    = np.append(starts[1:],breaks.size)-1 # indexes of end lines for merges 
result  = arr[starts]                         # keep only start lines
result[:,1] = arr[ends,1]                     # assign merged end values 

вывод:

print(result)

[[1.03 1.25]
 [2.02 3.79]
 [4.73 5.91]
 [6.5  9.1 ]]

примечание: это исправляет проблемы с моим предыдущим ответом

Если вы не используете numpy, для получения результата можно использовать простой l oop:

result,prevEnd = arr[:1],arr[0][1]
for line in arr[1:]:
    start,end = line
    if start-prevEnd<0.5: result[-1][1] = end
    else:                 result.append(line)
    prevEnd = end

Это будет хорошо работать на Python списках списков, но будет быть очень неэффективным на numpy массивах

Answer 3

это должно дать вам желаемый результат, в основном объединяя интервалы:

def group_intervals(a):
    ans = []

    curr = None
    for x in a:
        # no previous interval under consideration
        if curr == None:
            curr = x
        else:
            # check if we can merge the intervals
            if x[0]-curr[1] < 0.5:
                curr[1] = x[1]
            else:
            # if we cannot merge, push the current element to ans
                ans.append(curr)
                curr = x
    # making sure, the last interval is pushed into final answer
    if curr is not None:
        ans.append(curr)

    return ans