递归删除数组中的元素答案

【问题标题】：recursive removal of elements in array递归删除数组中的元素
【发布时间】：2011-04-01 19:02:22
【问题描述】：

给定一个包含 n 个元素的数组，删除任何相邻的相等元素对。重复此操作，直到没有更多的相邻对要移除；这将是最终的数组。

例如 1 2 2 3 4 应该返回数组 1 3 4. 请注意数组不需要排序。

还要检查这个测试用例：1,2,2,3,4,4,3,5 o/p 应该是 1,5。 (2,2) 和 (4,4) 被移除，然后 (3,3) 在移除 (4,4) 后变得相邻

【问题讨论】：

数组总是排序的？ 1 2 2 2 3 4(三 2) 将返回 1 3 4 或 1 2 3 4 ?
@prp，关于编辑，所以你想在第一次迭代和删除之后，删除现在出现的新的相邻对吗？并继续直到没有相邻对？
我现在不关注你了。请精确定义相邻。
在1,2,2,3,4,4,3,5的例子中为什么要删除3？在删除4,4 之前它不相邻。您需要在定义中声明这是我认为的递归删除。
你的问题很混乱。

标签： algorithm

【解决方案1】：

每当您删除一对元素时，您还需要查看是否生成了另一对要删除的元素。

算法应该自然地遵循观察结果。

【讨论】：

遵循同样的想法，我认为你也可以使用堆栈来解决这个问题。每次要压入栈的元素等于栈顶，就弹出。
@another，没错！（实际上我没有意识到这一点。）

【解决方案2】：

在 Python 中：

>>> l=[1,2,2,3,4,4,3,5]
>>> [x for x in l if not l.count(x) > 1]
[1, 5]

这将删除列表中多次出现的所有整数。这是一个正确的结果你的例子，但我认为你真的试图陈述不同的东西。我想你是在说：

list:=(an unsorted list of integers)
while adjacent_pairs(list) is True:
    remove_adjacent_pairs(list)

再次，在 Python 中：

#!/usr/bin/env python

def dedupe_adjacent(l):
    for i in xrange(len(l) - 1, 0, -1):
        if l[i] == l[i-1]:
            del l[i-1:i+1]
            return True

    return False

def process_list(l):
    print "input list: ",l
    i=1
    while(dedupe_adjacent(l)):
        print "   loop ",i,":",l
        i+=1

    print "processed list=",l    
    print 

process_list([1,2,2,3,4,4,3,5])
process_list([1,2,2,3,4,4,6,3,5])

输出：

input list:  [1, 2, 2, 3, 4, 4, 3, 5]
   loop  1 : [1, 2, 2, 3, 3, 5]
   loop  2 : [1, 2, 2, 5]
   loop  3 : [1, 5]
processed list= [1, 5]

input list:  [1, 2, 2, 3, 4, 4, 6, 3, 5]
   loop  1 : [1, 2, 2, 3, 6, 3, 5]
   loop  2 : [1, 3, 6, 3, 5]
processed list= [1, 3, 6, 3, 5]

【讨论】：

在我的问题中，所有相邻的对都被删除了。很多人对为什么在我的测试用例中删除 3 感到困惑，因为在删除一对 4 时，3 会生成一对，所以它也会被删除。所以我认为我们 csn 使用堆栈来做到这一点。
这可以正确处理删除一对 4 后删除一对 3 我不明白评论？

【解决方案3】：

以下内容：

function compress(arr) {
    var prev, res = [];
    for (var i in arr) {
        if (i == 0 || (arr[i] != arr[i - 1]))
            res.push(arr[i]);
    }
    return res;
}
compress([1, 2, 2, 3, 3, 3, 3, 4, 3, 3, 5, 6, 7, 8, 8]);

返回：

[1, 2, 3, 4, 3, 5, 6, 7, 8]

还有（JavaScript 1.6 解决方案）：

[1, 2, 2, 3, 3, 3, 3, 4, 3, 3, 5, 6, 7, 8, 8].filter(function(el, i, arr) {
    return i == 0 || (el != arr[i - 1]);
})

编辑：删除多次出现在数组中的任何项目需要不同的解决方案：

function dedup(arr) {
    var res = [], seen = {};
    for (var i in arr)
        seen[arr[i]] = seen[arr[i]] ? ++seen[arr[i]] : 1;
    for (var j in arr) {
        if (seen[arr[j]] == 1)
            res.push(arr[j]);
    }
    return res;
}

以下内容：

dedup([1, 2, 2, 3, 4, 4, 3, 5]);

生产：

[1, 5]

【讨论】：

我没有编辑过问题，我已经给出了另一个测试用例以使其更清楚..

【解决方案4】：

我在 Java 中有一个解决方案。您需要在 Java 的 String 类中使用 replaceAll 方法。您可以使用正则表达式来删除这些相邻的冗余字符：

public class MyString {
  public static void main(String[] args) {

    String str = "12234435";

    while(!str.replaceAll("(\\w)\\1+", "").equalsIgnoreCase(str))
      str = str.replaceAll("(\\w)\\1+", "");

    System.out.println(str);
  }
}

您可以找到如何给出正则表达式here

【讨论】：

【解决方案5】：

我愿意：

对数组进行排序。
从数组的开始，直到您到达数组的最后一个元素：
1. `count` = 计算数组[i] 元素的数量。
2. 如果 `count` > 1，则删除数组的第一个 `count` 元素。

【讨论】：

这不起作用。 1,3,1,1 呢？排序到 1,1,1,3 三个 1 被删除，留下 3。不是指定的（如果我理解写得不好的问题......）删除应该是成对重复......
根据问题：“还要检查这个测试用例：1,2,2,3,4,4,3,5 o/p 应该是 1,5。”请注意，在这种情况下删除了 3。 OP 给出的测试用例似乎指向“如果该数字出现不止一次，则删除该数字的所有出现。”
但也声明remove any adjacent pair of elements which are equal such that the resultant array also doesn't contain any adjacent duplicate elements. 删除了两个三点，因为在删除两个四点后它们是成对的。当然，该示例是通过简单地删除所有重复元素正确生成的；但如果你阅读他的文字，我不认为这就是他所追求的......

【解决方案6】：

以下 Python 3 代码将从列表（数组）中删除重复项。它通过从头到尾扫描数组并将目标元素与更大的元素进行比较来做到这一点。如果它们相同，它们将被删除。如果元素指针不指向 0，则将其减 1 以捕获嵌套对。如果两个比较元素不同，则指针递增。

我确信有一种更 Pythonic 的方法可以从列表中删除两个相邻的元素，但我是 Python 新手，还没有弄清楚这一点。此外，您还需要删除 print(indx, SampleArray) 语句——我将其保留在其中，以便您跟踪下面输出列表中的进度。

# Algorithm to remove duplicates in a semi-sorted list

def CompressArray(SampleArray):
    indx=0

    while(indx < len(SampleArray)-1):
        print(indx, SampleArray)
        if(SampleArray[indx]==SampleArray[indx+1]):
            del(SampleArray[indx])
            del(SampleArray[indx])
            if(indx>0):
                indx-=1
        else:
            indx+=1
    return SampleArray

以下是运行示例：

[1、2、2、3、4]
[1, 2, 2, 3, 4, 4, 3, 5]
[1、2、2、3、3、3、3、4、3、3、5、6、7、8、8]
[1, 2, 2, 3, 4, 6, 7, 7, 6, 4, 3, 8, 8, 5, 9, 10, 10, 9, 11]
[1, 1, 2, 3, 3, 2, 4, 5, 6, 6, 5, 7, 8, 8, 7, 4, 9]


================================
0 [1, 2, 2, 3, 4]
1 [1, 2, 2, 3, 4]
0 [1, 3, 4]
1 [1, 3, 4]
[1, 3, 4]
================================
0 [1, 2, 2, 3, 4, 4, 3, 5]
1 [1, 2, 2, 3, 4, 4, 3, 5]
0 [1, 3, 4, 4, 3, 5]
1 [1, 3, 4, 4, 3, 5]
2 [1, 3, 4, 4, 3, 5]
1 [1, 3, 3, 5]
0 [1, 5]
[1, 5]
================================
0 [1, 2, 2, 3, 3, 3, 3, 4, 3, 3, 5, 6, 7, 8, 8]
1 [1, 2, 2, 3, 3, 3, 3, 4, 3, 3, 5, 6, 7, 8, 8]
0 [1, 3, 3, 3, 3, 4, 3, 3, 5, 6, 7, 8, 8]
1 [1, 3, 3, 3, 3, 4, 3, 3, 5, 6, 7, 8, 8]
0 [1, 3, 3, 4, 3, 3, 5, 6, 7, 8, 8]
1 [1, 3, 3, 4, 3, 3, 5, 6, 7, 8, 8]
0 [1, 4, 3, 3, 5, 6, 7, 8, 8]
1 [1, 4, 3, 3, 5, 6, 7, 8, 8]
2 [1, 4, 3, 3, 5, 6, 7, 8, 8]
1 [1, 4, 5, 6, 7, 8, 8]
2 [1, 4, 5, 6, 7, 8, 8]
3 [1, 4, 5, 6, 7, 8, 8]
4 [1, 4, 5, 6, 7, 8, 8]
5 [1, 4, 5, 6, 7, 8, 8]
[1, 4, 5, 6, 7]
================================
0 [1, 2, 2, 3, 4, 6, 7, 7, 6, 4, 3, 8, 8, 5, 9, 10, 10, 9, 11]
1 [1, 2, 2, 3, 4, 6, 7, 7, 6, 4, 3, 8, 8, 5, 9, 10, 10, 9, 11]
0 [1, 3, 4, 6, 7, 7, 6, 4, 3, 8, 8, 5, 9, 10, 10, 9, 11]
1 [1, 3, 4, 6, 7, 7, 6, 4, 3, 8, 8, 5, 9, 10, 10, 9, 11]
2 [1, 3, 4, 6, 7, 7, 6, 4, 3, 8, 8, 5, 9, 10, 10, 9, 11]
3 [1, 3, 4, 6, 7, 7, 6, 4, 3, 8, 8, 5, 9, 10, 10, 9, 11]
4 [1, 3, 4, 6, 7, 7, 6, 4, 3, 8, 8, 5, 9, 10, 10, 9, 11]
3 [1, 3, 4, 6, 6, 4, 3, 8, 8, 5, 9, 10, 10, 9, 11]
2 [1, 3, 4, 4, 3, 8, 8, 5, 9, 10, 10, 9, 11]
1 [1, 3, 3, 8, 8, 5, 9, 10, 10, 9, 11]
0 [1, 8, 8, 5, 9, 10, 10, 9, 11]
1 [1, 8, 8, 5, 9, 10, 10, 9, 11]
0 [1, 5, 9, 10, 10, 9, 11]
1 [1, 5, 9, 10, 10, 9, 11]
2 [1, 5, 9, 10, 10, 9, 11]
3 [1, 5, 9, 10, 10, 9, 11]
2 [1, 5, 9, 9, 11]
1 [1, 5, 11]
[1, 5, 11]
================================
0 [1, 1, 2, 3, 3, 2, 4, 5, 6, 6, 5, 7, 8, 8, 7, 4, 9]
0 [2, 3, 3, 2, 4, 5, 6, 6, 5, 7, 8, 8, 7, 4, 9]
1 [2, 3, 3, 2, 4, 5, 6, 6, 5, 7, 8, 8, 7, 4, 9]
0 [2, 2, 4, 5, 6, 6, 5, 7, 8, 8, 7, 4, 9]
0 [4, 5, 6, 6, 5, 7, 8, 8, 7, 4, 9]
1 [4, 5, 6, 6, 5, 7, 8, 8, 7, 4, 9]
2 [4, 5, 6, 6, 5, 7, 8, 8, 7, 4, 9]
1 [4, 5, 5, 7, 8, 8, 7, 4, 9]
0 [4, 7, 8, 8, 7, 4, 9]
1 [4, 7, 8, 8, 7, 4, 9]
2 [4, 7, 8, 8, 7, 4, 9]
1 [4, 7, 7, 4, 9]
0 [4, 4, 9]
[9]
================================

【讨论】：

【解决方案7】：

我喜欢 Java，但功能性解决方案应该在这个网站上获得更多时间。
在 Haskell 中，按照问题要求的方式做事：

compress lst = if (length lst == length b) then lst else (compress b) where
    b = helper lst
    helper [] = []
    helper [x] = [x]
    helper (x:y:xs) = if (x == y) then (helper xs) else (x:helper (y:xs))

你可以在 O(n) 时间内解决这个问题，虽然它有点复杂

compress' lst = reverse (helper [] lst) where
    helper xs [] = xs
    helper [] (x:xs) = helper [x] xs
    helper (a:as) (x:xs)
        | a == x = helper as xs
        | otherwise = helper (x:a:as) xs

【讨论】：

【解决方案8】：

我认为我们可以使用堆栈来检查相邻的重复元素。扫描阵列。对于每个新元素，如果它等于堆栈中的顶部元素，则将其删除并从堆栈中弹出顶部元素。否则，将其压入堆栈。

【讨论】：

【解决方案9】：

这是基于已编辑问题的基于堆栈的算法。

// pseudo code, not tested
void RemoveDupp(vector<int> & vin, vector<int> & vout)
{
    int i = 0, int j = -1;
    vout.resize(vin.size());

    while (i < vin.size())
    {
        if (j == -1 || vout[j] != vin[i])
            vout[++j] = vin[i++]; //push
        else
            j--, i++;             //pop
    }
    vout.resize(j + 1);
}

【讨论】：