Comment trouver rapidement l'index d'un élément dans un tableau multidimensionnel ?

Question

Disons que j'ai ce tableau :

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

Maintenant, je veux quelque chose comme ça :

    public func indicesOf(x: Int, array: [[Int]]) -> (Int, Int) {
        ...
    }

pour que je puisse l'appeler comme ça :

indicesOf(7, array: a) // returns (2, 0)

Bien sûr, je peux utiliser :

for i in 0..<array.count {
    for j in 0..<array[i].count {
        if array[i][j] == x {
            return (i, j)
        }
    }
}

Mais ce n'est même pas proche de swifty !

Je veux un moyen de le faire qui soit rapide. Je pense que je peux utiliser reduce o map ?

Answer 1

Vous pouvez simplifier légèrement votre code avec enumerate() y indexOf() . De plus, la fonction doit retourner un tuple optionnel car l'élément peut ne pas être présent dans la "matrice". Enfin, vous pouvez la rendre générique :

func indicesOf<T: Equatable>(x: T, array: [[T]]) -> (Int, Int)? {
    for (i, row) in array.enumerate() {
        if let j = row.indexOf(x) {
            return (i, j)
        }
    }
    return nil
}

Vous pouvez également en faire une extension d'un modèle imbriqué de Array de Equatable éléments :

extension Array where Element : CollectionType,
    Element.Generator.Element : Equatable, Element.Index == Int {
    func indicesOf(x: Element.Generator.Element) -> (Int, Int)? {
        for (i, row) in self.enumerate() {
            if let j = row.indexOf(x) {
                return (i, j)
            }
        }
        return nil
    }
}

if let (i, j) = a.indicesOf(7) {
    print(i, j)
}

Swift 3 :

extension Array where Element : Collection,
    Element.Iterator.Element : Equatable, Element.Index == Int {

    func indices(of x: Element.Iterator.Element) -> (Int, Int)? {
        for (i, row) in self.enumerated() {
            if let j = row.index(of: x) {
                return (i, j)
            }
        }
        return nil
    }
}

Answer 2

Version acceptant une fermeture, similaire à index(où :) Il est donc utilisable sur un tableau de n'importe quel élément, et pas seulement sur les éléments suivants Equatable

extension Array where Element : Collection, Element.Index == Int {
  func indices(where predicate: (Element.Iterator.Element) -> Bool) -> (Int, Int)? {
    for (i, row) in self.enumerated() {
      if let j = row.index(where: predicate) {
        return (i, j)
      }
    }
    return nil
  }
}

Utilisez comme ça :

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

let testNumber = 6

print(testArray.indices(of: testNumber))
print(testArray.indices{$0 == testNumber})

Optional((1, 2))
Optional((1, 2))

Il peut également être utilisé avec IndexPath :

extension Array where Element : Collection, Element.Index == Int {
  func indexPath(where predicate: (Element.Iterator.Element) -> Bool) -> IndexPath? {
    for (i, row) in self.enumerated() {
      if let j = row.index(where: predicate) {
        return IndexPath(indexes: [i, j])
      }
    }
    return nil
  }
}