计算包含相同两个值的数组的数量

Question

给定一个Dictionary<String, Arrary<Int>>，在Array<Int> 的第一个5 条目中找出有多少条目具有相同的两个指定值。

例如：

给定：

let numberSeries = [

    "20022016": [07,14,36,47,50,02,05],
    "13022016": [16,07,32,36,41,07,09],
    "27022016": [14,18,19,31,36,04,05],

]

值：7 和 36，结果应该是 2，因为第一个和第二个条目在条目数组的前 5 个条目中同时具有值​​ 7 和 36。

我尝试了很多方法来完成这件事，但我无法让它发挥作用。

这是我目前的尝试：

//created a dictionary with (key, values)

let numberSeries = [

"20022016": [07,14,36,47,50,02,05],
"13022016": [16,07,32,36,41,07,09],
"27022016": [14,18,19,31,36,04,05],

]

var a = 07  //number to look for
var b = 36  // number to look for

// SearchForPairAB // search for pair // Doesn't Work.                                  

var ab = [a,b] // pair to look for
var abPairApearedCount = 0

for (kind, numbers) in numberSeries {
    for number in numbers[0...4] {
         if number == ab {           //err: Cannot invoke '==' with argument listof type Int, @Value [Int]
             abPairApearedCount++
         }
     }
 }

这给出了错误：Cannot invoke '==' with argument listof type Int, @Value [Int]就行了：if number == ab

Answer 1

您不能使用== 来比较Int 和Array<Int>，从比较的角度来看这没有任何意义。不过，有很多不同的方法可以实现你想要做的事情。在这种情况下，我可能会使用map/reduce 来计算您的配对。

这个想法是将mapab 数组中的值转换为Bool 值，这取决于该值是否在numbers 数组中。然后，reduce 将Bools 映射到单个值：true，如果它们都是true，或false。如果 reduced 的值是 true，那么我们找到了这对，所以我们增加了计数。

var ab = [a,b] // pair to look for
var abPairApearedCount = 0

for (kind, numbers) in numberSeries {
    let found = ab.map({ number in
        // find is a built-in function that returns the index of the value
        // in the array, or nil if it's not found
        return find(numbers[0...4], number) != nil
    }).reduce(true) { (result, value: Bool) in
        return result && value
    }
    if found {
        abPairApearedCount++
    }
}

这实际上可以通过使用一些 Swift 更简洁的语法来压缩：

var ab = [a,b] // pair to look for
var abPairApearedCount = 0

for (kind, numbers) in numberSeries {
    let found = ab.map({ find(numbers[0...4], $0) != nil }).reduce(true) { $0 && $1 }
    if found {
        abPairApearedCount++
    }
}

而且，为了好玩，可以通过使用reduce 而不是for-in 循环进一步压缩：

var ab = [a,b] // pair to look for
var abPairApearedCount = reduce(numberSeries, 0) { result, series in
    result + (ab.map({ find(series.1[0...4], $0) != nil }).reduce(true) { $0 && $1 } ? 1 : 0)
}

虽然这变得相当难以理解，所以我可能会扩展其中的一些内容。

Answer 2

这是我的 FP 解决方案，旨在将问题分解为易于消化和可重复使用的小块：

首先，我们定义一个将数组修剪为给定长度的函子：

func trimLength<T>(length: Int) -> ([T]) -> [T] {
    return { return Array($0[0...length]) }
}

使用这个我们可以使用map(array, trimLength(5))修剪所有元素

现在，我们需要一个谓词来确定一个数组的所有元素是否都在目标数组中：

func containsAll<T:Equatable>(check:[T]) -> ([T]) -> Bool {
    return { target in
        return reduce(check, true, { acc, elem in return acc && contains(target, elem) })
    }
}

这是这里最难看的代码，但本质上它只是迭代检查并确保每个元素都在目标数组中。一旦我们得到这个，我们就可以使用filter(array, containsAll([7, 26])) 来消除数组中不包含我们所有目标值的所有元素。

此时，我们可以将整个事情粘合在一起：

filter(map(numberSeries.values, trimLength(5)), containsAll([7, 36])).count

但是长行的嵌套函数很难阅读，让我们定义几个辅助函数和一个自定义运算符：

func rmap<S:SequenceType, T>(transform:(S.Generator.Element)->T) -> (S) -> [T] {
    return { return map($0, transform) }
}

func rfilter<S:SequenceType>(predicate:(S.Generator.Element)->Bool) -> (S) -> [S.Generator.Element] {
    return { sequence in return filter(sequence, predicate) }
}

infix operator <^> { associativity left }
func <^> <S, T>(left:S, right:(S)->T) -> T {
    return right(left)
}

还有一个方便的函数来计算它的输入：

func count<T>(array:[T]) -> Int {
    return array.count
}

现在我们可以将整个事情浓缩为：

numberSeries.values <^> rmap(trimLength(5)) <^> rfilter(containsAll([7, 36])) <^> count