Python 从分区域列表中混淆覆盖区域

我有一长串值x和y，按x值排序。我想输出x和y值的最长连续跨度列表。这有点难以用语言表达，但希望通过以下示例可以清楚地表达出来：

0, 148
0, 145
0, 186
0, 5768
600, 2374
2376, 2415
3000, 4315
6000, 6616
6000, 6799
6000, 7262

由于5768和6000之间的区域不包含在任何条目中，因此上述应输出：

0, 5768
6000, 7262

在我看来，这应该是一个简单的问题，但我一直在研究它一段时间没有解决方案。我已经在下面发布了我的代码。 我当前工作的问题是，当对x值进行排序时，k行的x值可能超过k-1行的y值，但不标记新连续字符串的开始

lines = [line.strip('\n') for line in open('test')]
myarray=[]
for line in lines:
    myarray.append(line.split(', '))

def findCoveredRegions(regionArray):
    resultsContigs = []
    j = regionArray[0][1]
    i = regionArray[0][0]
    for line in regionArray:
        last_i = i
        i = line[0]
        if i <= j:
            if line[1] > j:
                j = line[1]
        else:
            resultsContigs.append([last_i,j])
    resultsContigs.append([i,regionArray[len(regionArray)-1][1]])

    return resultsContigs

print findCoveredRegions(myarray)

lines=[line.strip（'\n'）用于打开的行（'test'）]
myarray=[]
对于行中的行：
myarray.append（line.split（'，'））
def Find覆盖区域（区域阵列）：
resultsContigs=[]
j=区域阵列[0][1]
i=区域阵列[0][0]
对于区域阵列中的行：
最后的i=i
i=第[0]行
如果i j：
j=第[1]行
其他：
resultcontigs.append（[last_i，j]）
结果contigs.append（[i，regionArray[len（regionArray）-1][1]]
返回结果CONTIGS
打印FindOveredRegions（myarray）

这里有一个简单的解决方案

myarray = np.asanyarray(myarray)
order = np.argsort(myarray.ravel())
coverage = np.add.accumulate(1 - 2*(order%2))
gaps = np.where(coverage==0)[0]
left = order[np.r_[0, gaps[:-1] + 1]]
right = order[gaps]
result = myarray.ravel()[np.c_[left, right]]

---

它汇集和排序所有边界。然后从左到右计算它遇到了多少左（+1）和右（-1）边界。这个数字永远不会是负数，只有在有差距的地方才会降到零。从间隙位置重建覆盖层段。

这里是一个简单的解决方案

myarray = np.asanyarray(myarray)
order = np.argsort(myarray.ravel())
coverage = np.add.accumulate(1 - 2*(order%2))
gaps = np.where(coverage==0)[0]
left = order[np.r_[0, gaps[:-1] + 1]]
right = order[gaps]
result = myarray.ravel()[np.c_[left, right]]

---

它汇集和排序所有边界。然后从左到右计算它遇到了多少左（+1）和右（-1）边界。这个数字永远不会是负数，只有在有差距的地方才会降到零。从缝隙的位置重建覆盖的层段。

这不会特别快，但我认为它很有吸引力和可读性。它不需要或使用已排序的间隔列表

intervals = [(0, 148),
 (0, 145),
 (0, 186),
 (0, 5768),
 (600, 2374),
 (2376, 2415),
 (3000, 4315),
 (6000, 6616),
 (6000, 6799),
 (6000, 7262)]


def intersect(interval_a, interval_b):
    """Return whether two intervals intersect"""
    (a_bottom, a_top), (b_bottom, b_top) = interval_a, interval_b
    return a_bottom <= b_top and b_bottom <= a_top


def union_one_one(interval_a, interval_b):
    """Return the union of two intervals"""
    (a_bottom, a_top), (b_bottom, b_top) = interval_a, interval_b
    return min(a_bottom, b_bottom), max(a_top, b_top)


def union_many_one(old_intervals, new_interval):
    """Return the union of a new interval with several old intervals."""
    result = []
    for old_interval in old_intervals:
        # If an old interval intersects with the new interval, merge the old interval into the new one.
        if intersect(old_interval, new_interval):
            new_interval = union_one_one(old_interval, new_interval)    
        # Otherwise, leave the old interval alone.
        else:
            result.append(old_interval)
    result.append(new_interval)
    return result


def union_all(intervals):
    """Return the union of a collection of intervals"""
    result = []
    for interval in intervals:
        result = union_many_one(result, interval)
    return result            


print(union_all(intervals))

interval=[（0148），
(0, 145),
(0, 186),
(0, 5768),
(600, 2374),
(2376, 2415),
(3000, 4315),
(6000, 6616),
(6000, 6799),
(6000, 7262)]
def intersect（间隔_a，间隔_b）：
“”“返回两个间隔是否相交”“”
（a_-bottom，a_-top），（b_-bottom，b_-top）=间隔a，间隔b
返回a_-bottom这不会特别快，但我认为它很有python风格，可读性很强。它不需要或使用已排序的间隔列表

intervals = [(0, 148),
 (0, 145),
 (0, 186),
 (0, 5768),
 (600, 2374),
 (2376, 2415),
 (3000, 4315),
 (6000, 6616),
 (6000, 6799),
 (6000, 7262)]


def intersect(interval_a, interval_b):
    """Return whether two intervals intersect"""
    (a_bottom, a_top), (b_bottom, b_top) = interval_a, interval_b
    return a_bottom <= b_top and b_bottom <= a_top


def union_one_one(interval_a, interval_b):
    """Return the union of two intervals"""
    (a_bottom, a_top), (b_bottom, b_top) = interval_a, interval_b
    return min(a_bottom, b_bottom), max(a_top, b_top)


def union_many_one(old_intervals, new_interval):
    """Return the union of a new interval with several old intervals."""
    result = []
    for old_interval in old_intervals:
        # If an old interval intersects with the new interval, merge the old interval into the new one.
        if intersect(old_interval, new_interval):
            new_interval = union_one_one(old_interval, new_interval)    
        # Otherwise, leave the old interval alone.
        else:
            result.append(old_interval)
    result.append(new_interval)
    return result


def union_all(intervals):
    """Return the union of a collection of intervals"""
    result = []
    for interval in intervals:
        result = union_many_one(result, interval)
    return result            


print(union_all(intervals))

interval=[（0148），
(0, 145),
(0, 186),
(0, 5768),
(600, 2374),
(2376, 2415),
(3000, 4315),
(6000, 6616),
(6000, 6799),
(6000, 7262)]
def intersect（间隔_a，间隔_b）：
“”“返回两个间隔是否相交”“”
（a_-bottom，a_-top），（b_-bottom，b_-top）=间隔a，间隔b
返回一个_底部对不起，我不理解这个问题，即使有例子。如果你发现很难用文字表达，那么你几乎肯定会发现很难用代码表达。你能详细说明一下你的意思吗：1）“x和y值的最长连续跨度”2）“5768和6000之间的区域没有覆盖”想象一下你有一个连续序列中所有0和7262之间的数字。我们可以将我的示例中的每一行看作是一个由0到148、0到145等之间的所有数字组成的字符串。我想要生成的是一个0到7262之间的区域列表，其中的数字至少会出现一次，因为我知道有些数字根本不会出现。5768和6000之间的数字不是任何子序列的一部分，但是0和5768以及6000和7262之间的所有数字都被至少一个区域“覆盖”。这有意义吗？用数学术语来说，你基本上要求一组区间的并集，表示为严格递增的区间集。换句话说，尽可能少的间隔。对吗？有趣的问题，我会试试。对不起，我不理解这个问题，即使是这个例子。如果你发现很难用文字表达，那么你几乎肯定会发现很难用代码表达。你能详细说明一下你的意思吗：1）“x和y值的最长连续跨度”2）“5768和6000之间的区域没有覆盖”想象一下你有一个连续序列中所有0和7262之间的数字。我们可以将我的示例中的每一行看作是一个由0到148、0到145等之间的所有数字组成的字符串。我想要生成的是一个0到7262之间的区域列表，其中的数字至少会出现一次，因为我知道有些数字根本不会出现。5768和6000之间的数字不是任何子序列的一部分，但是0和5768以及6000和7262之间的所有数字都被至少一个区域“覆盖”。这有意义吗？用数学术语来说，你基本上要求一组区间的并集，表示为严格递增的区间集。换句话说，尽可能少的间隔。对吗？有趣的问题，我将尝试它。这似乎并没有为我提供的测试用例提供正确的解决方案。我得到以下输出：['0''2374']['2376''2415']['3000''4315']['5768''600']['6000''7262']]实际上，它检查相邻的间隔，但它必须检查最后一个覆盖的间隔，它可能完全包含它后面的一些间隔。@Sigurgeir如果我将字符串转换为整数，我确实得到了正确的结果。它不适用于您，因为“600”>“5768”是字符串等，当然，这完全会使算法出错。@9000不，排序会处理所有这些。@PaulPanzer:酷！（而您的解决方案，虽然精神上是APL，但可读性更高。）这似乎并没有为我提供的测试用例提供正确的解决方案。我得到以下输出：['0''2374']['2376''2415']['3000''4315']['5768''600']['6000''7262']]实际上，它检查了广告