Ios 如何删除多个并行阵列中的重复数据

我试图删除swift中具有多个相同值的相同顺序的某些数组元素 即

假设现在我有3个数组

array1 = [a,b,c,d,d,c,d]
array2 = [1,2,3,4,4,3,4]
array3 = [aa,bb,cc,dd,dd,cc,dd]

问题是：我需要从数组中删除所有3个重复值的元素

这意味着，我需要从数组1、2和3中去掉索引为[4]、[5]、[6]的元素

ps.3数组必须位于单独的数组中，并且不能重新排列其顺序，因为它们具有一些相互关联的关键信息

---

如果您有任何建议，我们将不胜感激。

您可以将数组放入一个集合（该集合本身不包含重复项），然后将其传输回数组

e、 g

var array2:[Int]=[1,2,3,4,4,3,4]
设set2=Set（array2）
array2=数组（set2）.sorted（）

---

如果还需要对其他数组执行设置逻辑，可以执行类似于

set2.subtract（otherSequence）

的操作。您可以将数组放入一个集合（该集合本身不包含重复项），然后将其传输回一个数组

e、 g

var array2:[Int]=[1,2,3,4,4,3,4]
设set2=Set（array2）
array2=数组（set2）.sorted（）

---

如果您还需要针对其他数组设置逻辑，您可以执行类似于

set2.subtract（otherSequence）

的操作，元组是

相等的（假设它们的元素是
相等的
），直到arity 6，我们可以在这里使用它将三个数组压缩成一个3元组的序列，识别重复的3元组元素，并从原始三个数组中删除与这些元组关联的索引。然而，元组不是可散列的，因此我们可以使用实用工具
散列的类型来存储这三个值，而不是使用3元组（3元组是匿名输入的）

实用程序类型：

struct ZippedElement: Hashable {
    let a: String
    let b: Int
    let c: String

    init(_ a: String, _ b: Int, _ c: String) {
        self.a = a
        self.b = b
        self.c = c
    }

    // Use a very simple common hashValue calculation, simply
    // falling back on the hashValue of the Int member.
    var hashValue: Int { return b.hashValue }

    static func ==(lhs: ZippedElement, rhs: ZippedElement) -> Bool {
        return lhs.a == rhs.a && lhs.b == rhs.b && lhs.c == rhs.c
    }
}

这允许我们通过
array3
对
array1
执行过滤/变异操作，如下所示：

var seen = Set<ZippedElement>()
zip(zip(array1, array2), array3)
    .map { ZippedElement($0.0, $0.1, $1) }
    .enumerated().filter { !seen.insert($1).inserted }
    .map { $0.offset }.reversed()
    .forEach {
        array1.remove(at: $0)
        array2.remove(at: $0)
        array3.remove(at: $0)
    }


但是，您的示例数据设置不会对此处的不同解决方案带来太多挑战，因此@dasblinkenlight提出了一个好问题：

如果我用
“dx”
替换
阵列3
的最后一个
“dd”
，它会改变期望的结果吗

在这种情况下，我相信我们大多数人都认为应该保留所有原始数组中的第7个元素，因为第7个元素（/列）在所有三个数组上的“垂直”zip组合是唯一的

将与上述相同的方法应用于此类修改示例：

var array1 = ["a",  "b",  "c",  "d",  "d",  "c",  "d"]
var array2 = [ 1,    2,    3,    4,    4,    3,    4]
var array3 = ["aa", "bb", "cc", "dd", "dd", "cc", "dx"]
                                               /*  ^^ obs */

var seen = Set<ZippedElement>()
zip(zip(array1, array2), array3)
    .map { ZippedElement($0.0, $0.1, $1) }
    .enumerated().filter { !seen.insert($1).inserted }
    .map { $0.offset }.reversed()
    .forEach {
        print($0)
        array1.remove(at: $0)
        array2.remove(at: $0)
        array3.remove(at: $0)
    }

print(array1) // ["a", "b", "c", "d", "d"]
print(array2) // [1, 2, 3, 4, 4]
print(array3) // ["aa", "bb", "cc", "dx"]
                                  /* ^^ ok */

var array1=[“a”、“b”、“c”、“d”、“d”、“c”、“d”]
var array2=[1,2,3,4,4,3,4]
变量数组3=[“aa”、“bb”、“cc”、“dd”、“dd”、“cc”、“dx”]
/*^^obs*/
var seen=Set（）
拉链（拉链（1排，2排，3排）
.map{ZippedElement（$0.0，$0.1，$1）}
.enumerated（）.filter{！seen.insert（$1.inserted}
.map{$0.offset}.reversed（）
弗雷奇先生{
印刷品（0美元）
阵列1.移除（at:$0）
阵列2.移除（at:$0）
阵列3.移除（at:$0）
}
打印（阵列1）/[“a”、“b”、“c”、“d”、“d”]
打印（阵列2）/[1,2,3,4,4]
打印（阵列3）/[“aa”、“bb”、“cc”、“dx”]
/*^^好的*/


@SteveKuo对您的问题提出了另一个评论，说明了我们大多数人对所有问题（索引跟踪单独数组…）的想法（超过了一个有趣的算法练习）：

似乎更合适的数据结构是创建数组1/2/3属性的struct/class/tuple

我相信这是你在这里应该得到的核心答案，所以即使你明确地说

。。。ps.3阵列必须在单独的阵列中

您可能需要一个自定义类型的单个数组。
元组可以
相等
（假设它们的元素可以
相等
）直到arity 6，我们可以在这里利用它将三个数组压缩成一个3元组序列，识别重复的3元组元素，以及从原始的三个数组中删除与这些元组关联的索引。然而，元组不是可散列的，因此我们可以使用实用工具
散列的类型来存储这三个值，而不是使用3元组（3元组是匿名输入的）

实用程序类型：

struct ZippedElement: Hashable {
    let a: String
    let b: Int
    let c: String

    init(_ a: String, _ b: Int, _ c: String) {
        self.a = a
        self.b = b
        self.c = c
    }

    // Use a very simple common hashValue calculation, simply
    // falling back on the hashValue of the Int member.
    var hashValue: Int { return b.hashValue }

    static func ==(lhs: ZippedElement, rhs: ZippedElement) -> Bool {
        return lhs.a == rhs.a && lhs.b == rhs.b && lhs.c == rhs.c
    }
}

这允许我们通过
array3
对
array1
执行过滤/变异操作，如下所示：

var seen = Set<ZippedElement>()
zip(zip(array1, array2), array3)
    .map { ZippedElement($0.0, $0.1, $1) }
    .enumerated().filter { !seen.insert($1).inserted }
    .map { $0.offset }.reversed()
    .forEach {
        array1.remove(at: $0)
        array2.remove(at: $0)
        array3.remove(at: $0)
    }


但是，您的示例数据设置不会对此处的不同解决方案带来太多挑战，因此@dasblinkenlight提出了一个好问题：

如果我用
“dx”
替换
阵列3
的最后一个
“dd”
，它会改变期望的结果吗

在这种情况下，我相信我们大多数人都认为应该保留所有原始数组中的第7个元素，因为第7个元素（/列）在所有三个数组上的“垂直”zip组合是唯一的

将与上述相同的方法应用于此类修改示例：

var array1 = ["a",  "b",  "c",  "d",  "d",  "c",  "d"]
var array2 = [ 1,    2,    3,    4,    4,    3,    4]
var array3 = ["aa", "bb", "cc", "dd", "dd", "cc", "dx"]
                                               /*  ^^ obs */

var seen = Set<ZippedElement>()
zip(zip(array1, array2), array3)
    .map { ZippedElement($0.0, $0.1, $1) }
    .enumerated().filter { !seen.insert($1).inserted }
    .map { $0.offset }.reversed()
    .forEach {
        print($0)
        array1.remove(at: $0)
        array2.remove(at: $0)
        array3.remove(at: $0)
    }

print(array1) // ["a", "b", "c", "d", "d"]
print(array2) // [1, 2, 3, 4, 4]
print(array3) // ["aa", "bb", "cc", "dx"]
                                  /* ^^ ok */

var array1=[“a”、“b”、“c”、“d”、“d”、“c”、“d”]
var array2=[1,2,3,4,4,3,4]
变量数组3=[“aa”、“bb”、“cc”、“dd”、“dd”、“cc”、“dx”]
/*^^obs*/
var seen=Set（）
拉链（拉链（1排，2排，3排）
.map{ZippedElement（$0.0，$0.1，$1）}
.enumerated（）.filter{！seen.insert（$1.inserted}
.map{$0.offset}.reversed（）
弗雷奇先生{
印刷品（0美元）
阵列1.移除（at:$0）
阵列2.移除（at:$0）
阵列3.移除（at:$0）
}
打印（阵列1）/[“a”、“b”、“c”、“d”、“d”]
打印（阵列2）/[1,2,3,4,4]
打印（阵列3）/[“aa”、“bb”、“cc”、“dx”]
/*^^好的*/


@SteveKuo对您的问题提出了另一个评论，说明了我们大多数人的想法（过度的）
var array1 = ["a",  "b",  "c",  "d",  "d",  "c",  "d"]
var array2 = [ 1,    2,    3,    4,    4,    3,    4]
var array3 = ["aa", "bb", "cc", "dd", "dd", "cc", "dx"]
                                               /*  ^^ obs */

var seen = Set<ZippedElement>()
zip(zip(array1, array2), array3)
    .map { ZippedElement($0.0, $0.1, $1) }
    .enumerated().filter { !seen.insert($1).inserted }
    .map { $0.offset }.reversed()
    .forEach {
        print($0)
        array1.remove(at: $0)
        array2.remove(at: $0)
        array3.remove(at: $0)
    }

print(array1) // ["a", "b", "c", "d", "d"]
print(array2) // [1, 2, 3, 4, 4]
print(array3) // ["aa", "bb", "cc", "dx"]
                                  /* ^^ ok */

var array1 = ["a","b","c","d","d","c","d"]
var array2 = [1,2,3,4,4,3,4]
var array3 = ["aa","bb","cc","dd","dd","cc","dd"]

var set: Set<Int> = []

var lastIndex = 0
for index in array2.indices
{
    if set.insert(array2[index]).inserted
    {
        array1.swapAt(index, lastIndex)
        array2.swapAt(index, lastIndex)
        array3.swapAt(index, lastIndex)
        lastIndex += 1
    }
}

let numToRemove = array1.count - lastIndex
array1.removeLast(numToRemove)
array2.removeLast(numToRemove)
array3.removeLast(numToRemove)