निम्नलिखित 2D सरणी पर विचार करें:

let array = [
                [11, 2, 4],
                [4, 5, 6],
                [10, 8, -12]
            ]

मैं जो प्राप्त करना चाहता हूं वह विकर्णों का योग है:

  • जैसे firstDiagnal: 11 + 5 + (-12) = 4
  • secondDiagnal के रूप में: 4 + 5 + 10 = 19

मैं इसे एक मानक for-in लूप का उपयोग करके प्राप्त कर सकता हूं:

var firstDiagnal = 0
var secondDiagnal = 0

for i in 0..<array.count {
    firstDiagnal += array[i][i]
    secondDiagnal += array[i][array[i].count - 1 - i]
}

print(firstDiagnal)
print(secondDiagnal)

हालांकि, यह क्या हो सकता है यदि हम उच्च-क्रम फ़ंक्शन का उपयोग करने का प्रयास करें? जैसे map और reduce?

8
Ahmad F 4 अक्टूबर 2018, 15:35

2 जवाब

सबसे बढ़िया उत्तर

पहली राशि प्राप्त करने के लिए, आप i'th पंक्ति का i'th तत्व चाहते हैं:

let firstDiag = array.enumerated().map { $1[$0] }.reduce(0, +)

दूसरी राशि प्राप्त करने के लिए, आप वही चीज़ चाहते हैं, लेकिन कॉलम उलट गए हैं:

let secondDiag = array.enumerated().map { $1.reversed()[$0] }.reduce(0, +)
9
Rob Napier 4 अक्टूबर 2018, 15:54

आरंभ करने के लिए, आप नेस्टेड सरणी से विकर्ण प्राप्त करने के लिए एक साफ विस्तार लिख सकते हैं:

extension Array {

    func diagonal<T>(order: Int) -> [T] where Element == [T] {

        var order = order
        return self.compactMap {
            guard order >= 0, $0.count > order else {
                order -= 1
                return nil
            }
            let output = $0[order]
            order -= 1
            return output
        }
    }
}

let array = [[1, 2, 3],
             [4, 5, 6],
             [7, 8, 9]]

print(array.diagonal(order: 0)) // [1]
print(array.diagonal(order: 1)) // [2, 4]
print(array.diagonal(order: 2)) // [3, 5 ,7]
print(array.diagonal(order: 3)) // [6, 8]

यह तो बस दलदल-मानक कम करने और योग का मामला है:

let fristDiagonal = array.diagonal(order: 0).reduce(0, +)
let secondDiagonal = array.diagonal(order: 1).reduce(0, +)
0
XmasRights 8 अक्टूबर 2018, 11:52