Swift-如何简化矩阵

我有一个三维数组（

array[x][y][z]

，

xyz

可以灵活使用）

如何将3D简化为2D到：

array[z][y]

[3,1,3],[2,0,2],[3,1,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]]

---

因为听起来你在寻找一个函数式编程单行程序，下面是你的答案：

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
}

func展平2（u数组：[[Int]]]）->[[Int]]
{
变量结果：[[Int]]=[]
对于0..中的j，让我们首先形成一个实用函数，作为矩阵样式数组的扩展（“cw”表示按列）：

然后，如果阵列为：

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]]

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

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

result=（0..经过数小时的尝试。这是我的输出，非常简单，与
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
        }

    }

设x=array.count
设y=数组[0]。计数
设z=数组[0][0]。计数
var final=Array（重复：Array（重复：0，计数：y），计数：z）
对于0中的i..将第一个数组转换为第二个数组的数学运算是什么？在python中，我使用的是
add.reduce（array，0）
。我知道您在做某种矩阵代数，但在您提供将第一个数组转换为第二个数组的分步说明之前，您无法对其进行编码。这与Swift
reduce
本身无关。请教我将第一个数组转换为第二个数组，然后我将你可以试着教计算机做这件事。除非你分享并解释清楚你的算法，以及解释，否则我们帮不了你。我更新了问题。希望你能理解。最好使用你的数组索引。
array.index.map{j in array.index.map{I in array.map{$0[I][j]}.reduce（0，+）}
嗯，
数组。索引是最外层数组的索引，而不是嵌套数组的索引（甚至可能有不同的维度）因此，使用
array.index
作为迭代第二级或第三级数组的顺序对我来说似乎不合逻辑。@MartinR我认为数组必须是方形的，否则操作将无法定义……我不确定，虽然您只需要在同一级别上使用相同的维度。当然，我不知道OP的确切要求，但是
[[[1,1,1,2]，[0,0,0,2]，[[1,0,1,3]，[1,0,1,4]，[[1,1,1,1]，[0,0,0,0]]].
将是一个操作有意义的数组。@MartinR我的错误是，在这种情况下，我们应该迭代内部数组的索引，不？这正好满足我的问题。但是，你能让它更一般一些吗
当
x，y，z
可以flexible@hoangpx你是一个程序员，你让它更通用！我会很快更新这个。我从一行中学到了很多。谢谢
var result = [[Int]]()
for j in 0..<3 {
    result.append((0..<3).map{i in array.cwsum(i,j)})
}

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

    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
        }

    }