Swift 从两个非'；两者并不相同

下面的代码可以工作，但我想知道是否有一种方法可以优化它。if..else语句有冗余代码。我对array.reduce/array.map{}还不够熟悉

我有两个包含字符的数组。我想计算其中一个/两个数组中所需的删除次数，以便它们包含相同的字符。 [“a”、“b”] [“a”、“b”、“c”、“d”、“e”] 需要删除3次

        var aArray = ["a", "b", "c"]
        var bArray = ["a", "b", "c", "d", "e", "f", "g", "h"]
        var newArray = [String]()

        if aArray.count >= bArray.count {
            for i in 0..<aArray.count {
                if (bArray.contains(aArray[i])) {

                    newArray.append(aArray[i])
                }
            }
        } else {
                for i in 0..<bArray.count {
                    if (aArray.contains(bArray[i])) {

                        newArray.append(bArray[i])
                    }
                }
        }
        print(newArray) // ["a", "b", "c"]
        let count = (aArray.count + bArray.count) - (newArray.count * 2)
        print(count) // 5

var aArray=[“a”、“b”、“c”]
变量bArray=[“a”、“b”、“c”、“d”、“e”、“f”、“g”、“h”]
var newArray=[String]（）
如果aArray.count>=bArray.count{
对于0..中的i，使用
Set
s的幂，您可以轻松解决此任务：

let aArray = ["a", "b", "c"]
let bArray = ["a", "b", "c", "d", "e", "f", "g", "h"]

// first, get unique items of aArray
let aSet = Set(aArray)

// second, get unique items of bArray
let bSet = Set(bArray)

// now the cool part: find those elements, that are present only either in aSet or in bSet but not in both
let exclusive = aSet.symmetricDifference(bSet)

// count how many items in the arrays are in the `exclusive` set
let deletions = aArray.filter { exclusive.contains($0) }.count + bArray.filter { exclusive.contains($0) }.count
print(deletions)

或者，您可以内联初始化集合，使代码更短（可能可读性更低）：

使用
Set
s的功能，您可以轻松解决此任务：

let aArray = ["a", "b", "c"]
let bArray = ["a", "b", "c", "d", "e", "f", "g", "h"]

// first, get unique items of aArray
let aSet = Set(aArray)

// second, get unique items of bArray
let bSet = Set(bArray)

// now the cool part: find those elements, that are present only either in aSet or in bSet but not in both
let exclusive = aSet.symmetricDifference(bSet)

// count how many items in the arrays are in the `exclusive` set
let deletions = aArray.filter { exclusive.contains($0) }.count + bArray.filter { exclusive.contains($0) }.count
print(deletions)

或者，您可以内联初始化集合，使代码更短（可能可读性更低）：

如果优化性能与其说是为了简洁，不如说是为了简洁，那么这种方法可能会简明扼要地表达您的需求：

对于
String
s
xs
的任何数组，我们可以将其减少为
Int
值，该值表示另一个数组
ys
中不存在的元素数，如下所示：

xs.reduce(0){ $0 + (ys.contains($1) ? 0 : 1) }

var aArray = ["a", "b", "c"]
var bArray = ["a", "b", "c", "d", "e", "f", "g", "h"]
let totalDeletions = aArray.reduce(0, incrementIfNotIn(bArray)) + bArray.reduce(0, incrementIfNotIn(aArray))
print(totalDeletions) //5

let aArray = [1, 3, 5, 6, 7]
let bArray = [1, 2, 4, 6, 9, 12, 13]
let totalDeletions = aArray.reduce(0, incrementIfNotIn(bArray)) + bArray.reduce(0, incrementIfNotIn(aArray))
print(totalDeletions) //8

这样做的目的是将初始缩减值设置为0（传递到上述
reduce
方法的第一个参数）

然后，对于
xs
中的每个元素，是否正在运行接受当前聚合/减少值（也是传递到闭包中的第一个参数，
$0
）的闭包，并且如果正在检查
xs
的当前元素（
$1
）包含在另一个数组
ys
中，然后将0添加到值中（保持不变）。否则，该元素不包含在另一个
ys
数组中，且聚合值/缩减值递增1。在运行此
reduce
方法结束时，它将返回一个表示起始值0的值，每次
xs
中的元素不包含在
ys
中时递增1

要获得所需的总删除量，您只需运行与
reduce
方法相同的
ys
相对
xs
方法，并将每个reduce的结果相加

因此，对于您的示例代码：

var aArray = ["a", "b", "c"]
var bArray = ["a", "b", "c", "d", "e", "f", "g", "h"]
let totalDeletions = aArray.reduce(0){ $0 + (bArray.contains($1) ? 0 : 1) } + bArray.reduce(0){ $0 + (aArray.contains($1) ? 0 : 1) }
print(totalDeletions) //5


进一步
如果您创建一个通用函数，为任何上下文生成正确的
reduce
闭包（包括除了
String
s之外还包含其他可等式值的任何数组），则可以在调用站点使事情变得更可重用和更清晰，例如：

或者像这样使用
Int
s数组：

xs.reduce(0){ $0 + (ys.contains($1) ? 0 : 1) }

var aArray = ["a", "b", "c"]
var bArray = ["a", "b", "c", "d", "e", "f", "g", "h"]
let totalDeletions = aArray.reduce(0, incrementIfNotIn(bArray)) + bArray.reduce(0, incrementIfNotIn(aArray))
print(totalDeletions) //5

let aArray = [1, 3, 5, 6, 7]
let bArray = [1, 2, 4, 6, 9, 12, 13]
let totalDeletions = aArray.reduce(0, incrementIfNotIn(bArray)) + bArray.reduce(0, incrementIfNotIn(aArray))
print(totalDeletions) //8

我认为，如果优化性能不是你的目标，而是简洁，那么这种方法可能会简洁地表达你想要的：

对于
String
s
xs
的任何数组，我们可以将其减少为
Int
值，该值表示另一个数组
ys
中不存在的元素数，如下所示：

xs.reduce(0){ $0 + (ys.contains($1) ? 0 : 1) }

var aArray = ["a", "b", "c"]
var bArray = ["a", "b", "c", "d", "e", "f", "g", "h"]
let totalDeletions = aArray.reduce(0, incrementIfNotIn(bArray)) + bArray.reduce(0, incrementIfNotIn(aArray))
print(totalDeletions) //5

let aArray = [1, 3, 5, 6, 7]
let bArray = [1, 2, 4, 6, 9, 12, 13]
let totalDeletions = aArray.reduce(0, incrementIfNotIn(bArray)) + bArray.reduce(0, incrementIfNotIn(aArray))
print(totalDeletions) //8

这样做的目的是将初始缩减值设置为0（传递到上述
reduce
方法的第一个参数）

然后，对于
xs
中的每个元素，是否正在运行接受当前聚合/减少值（也是传递到闭包中的第一个参数，
$0
）的闭包，并且如果正在检查
xs
的当前元素（
$1
）包含在另一个数组
ys
中，然后将0添加到值中（保持不变）。否则，该元素不包含在另一个
ys
数组中，且聚合值/缩减值递增1。在运行此
reduce
方法结束时，它将返回一个表示起始值0的值，每次
xs
中的元素不包含在
ys
中时递增1

要获得所需的总删除量，您只需运行与
reduce
方法相同的
ys
相对
xs
方法，并将每个reduce的结果相加

因此，对于您的示例代码：

var aArray = ["a", "b", "c"]
var bArray = ["a", "b", "c", "d", "e", "f", "g", "h"]
let totalDeletions = aArray.reduce(0){ $0 + (bArray.contains($1) ? 0 : 1) } + bArray.reduce(0){ $0 + (aArray.contains($1) ? 0 : 1) }
print(totalDeletions) //5


进一步
如果您创建一个通用函数，为任何上下文生成正确的
reduce
闭包（包括除了
String
s之外还包含其他可等式值的任何数组），则可以在调用站点使事情变得更可重用和更清晰，例如：

或者像这样使用
Int
s数组：

xs.reduce(0){ $0 + (ys.contains($1) ? 0 : 1) }

var aArray = ["a", "b", "c"]
var bArray = ["a", "b", "c", "d", "e", "f", "g", "h"]
let totalDeletions = aArray.reduce(0, incrementIfNotIn(bArray)) + bArray.reduce(0, incrementIfNotIn(aArray))
print(totalDeletions) //5

let aArray = [1, 3, 5, 6, 7]
let bArray = [1, 2, 4, 6, 9, 12, 13]
let totalDeletions = aArray.reduce(0, incrementIfNotIn(bArray)) + bArray.reduce(0, incrementIfNotIn(aArray))
print(totalDeletions) //8

它读起来更具表现力，我想
通过优化，你的意思是让它更快、更简洁、更短，还是以上所有内容？看一下。它接受两个序列作为输入，并允许你指定一个谓词。我从未使用过它，但它看起来至少在你尝试的内容附近。你的数组排序了吗？项目排序了吗r删除后是否重要？不，顺序一点也不重要。谢谢。@MartinMuldoon重复项怎么办？优化是指使其更快、更简洁、更短，还是上述所有内容？请看。它接受两个序列作为输入，并允许您指定一个谓词。我从未使用过它，但它看起来至少在wha附近你在尝试。你的数组排序了吗？删除后项目顺序重要吗？不，顺序一点都不重要。谢谢。@MartinMuldoon重复的呢？