Swift - 如何减少矩阵

Question

我有一个 3 维数组（array[x][y][z]，x y z 可以灵活）

var array = [ [[1,1,1],[0,0,0],[1,1,1]],
              [[1,0,1],[1,0,1],[1,0,1]],
              [[1,1,1],[0,0,0],[1,1,1]]
            ]

如何将 3D 缩减为 2D 为：array[z][y]

[3,1,3],[2,0,2],[3,1,3]

我阅读了here 的说明，但不知道如何申请我的。

更新： 这是逻辑

Answer 1

让我们首先形成一个实用函数作为矩阵式数组的扩展（“cw”表示按列）：

extension Array where Element == [[Int]] {
    func cwsum(_ ix1:Int, _ ix2:Int) -> Int {
        return reduce(0) {$0 + $1[ix1][ix2]}
    }
}

那么如果数组是：

let array = [[[1,1,1],[0,0,0],[1,1,1]],
             [[1,0,1],[1,0,1],[1,0,1]],
             [[1,1,1],[0,0,0],[1,1,1]]]

...那么答案是：

[[array.cwsum(0,0), array.cwsum(1,0), array.cwsum(2,0)],
 [array.cwsum(0,1), array.cwsum(1,1), array.cwsum(2,1)],
 [array.cwsum(0,2), array.cwsum(1,2), array.cwsum(2,2)]] 
// [[3, 1, 3], [2, 0, 2], [3, 1, 3]]

但是等等——我想我在这里看到了一个模式！我们可以在不对索引进行硬编码的情况下将其重写为：

var result = [[Int]]()
for j in 0..<3 {
    var r1 = [Int]()
    for i in 0..<3 {
        r1.append(array.cwsum(i,j))
    }
    result.append(r1)
} // result is now [[3, 1, 3], [2, 0, 2], [3, 1, 3]]

好的，但是我们可以循环使用append，我们可以改为map，从而将i 转换为map 变量：

var result = [[Int]]()
for j in 0..<3 {
    result.append((0..<3).map{i in array.cwsum(i,j)})
}

但是我们也可以为j 这样做——因此它变成了一行：

result = (0..<3).map{j in (0..<3).map{i in array.cwsum(i,j)}}

Answer 2

因为听起来您正在寻找函数式编程单线，所以这是您的答案：

array.indices.map{ j in array.indices.map{ i in array.map{ $0[i][j] }.reduce(0, +) } }

它与这段代码基本相同，虽然它更长，但我认为更容易阅读，并且让我减少推理的麻烦。

func flatten2(_ array:[[[Int]]]) -> [[Int]]
{
    var result:[[Int]] = []
    for j in 0..<array.count
    {
        var row:[Int] = []
        for i in 0..<array.count
        {
            row.append(array.map{ $0[i][j] }.reduce(0, +))
        }
        result.append(row)
    }
    return result
}

请记住，单行编译器的编译时间会多出两个数量级，因为 Swift 编译器对函数式和闭包式编程并不是很优化，因此它必须构造巨大的重载树来解析该表达式。由于我怀疑这是 CS 期末考试练习考试中的问题，请，请让你可怜的助教的生活更轻松，并使用多线。

Answer 3

鉴于此

let matrix = [
    [[1,1,1],[0,0,0],[1,1,1]],
    [[1,0,1],[1,0,1],[1,0,1]],
    [[1,1,1],[0,0,0],[1,1,1]]
]

让我们计算这些

let all = matrix.joined().enumerated()

let a = all.filter { $0.offset % 3 == 0 }.map { $0.element[0] }.reduce(0, +)
let b = all.filter { $0.offset % 3 == 1 }.map { $0.element[0] }.reduce(0, +)
let c = all.filter { $0.offset % 3 == 2 }.map { $0.element[0] }.reduce(0, +)

let d = all.filter { $0.offset % 3 == 0 }.map { $0.element[1] }.reduce(0, +)
let e = all.filter { $0.offset % 3 == 1 }.map { $0.element[1] }.reduce(0, +)
let f = all.filter { $0.offset % 3 == 2 }.map { $0.element[1] }.reduce(0, +)

let g = all.filter { $0.offset % 3 == 0 }.map { $0.element[2] }.reduce(0, +)
let h = all.filter { $0.offset % 3 == 1 }.map { $0.element[2] }.reduce(0, +)
let i = all.filter { $0.offset % 3 == 2 }.map { $0.element[2] }.reduce(0, +)

最后让我们把值放在一起

let res = [[a, b, c], [d, e, f], [g, h, i]]

Answer 4

经过数小时的尝试。这是我的输出，非常简单，与reduce 无关。 3d数组的输入很灵活x,y,z

    let x = array.count
    let y = array[0].count
    let z = array[0][0].count

    var final = Array(repeating: Array(repeating: 0, count: y), count: z)
    for i in 0..<z {
        for ii in 0..<y {
            var sum = 0
            for iii in 0..<x {
                sum = sum + array[iii][ii][i]
            }
            final[i][ii] = sum
        }

    }