2次元配列からIndexPathの範囲指定でその範囲に含まれるIndexPathを配列として取得する方法はありますか？

Question

いつもお世話になります。

tableView:moveRowAtIndexPath:toIndexPath:のなかで取得した、2つのIndexPathによる範囲指定で2次元配列からIndexPathを取得して配列をつくりたいのですが、簡潔な方法はないでしょうか？(説明が下手で申し訳ないです。)

for-inを使用して
enumurate()やarray.countから取得したIntからIndexPathを生成するしかないでしょうか？

取得した配列[IndexPaht]はreloadRows(at:with:)で範囲指定したセルを更新するか、
セルを取得してから特定の値を書き換える目的で使いたいです。

イメージとしては

let arrayOfArray = [["A", "B", "C", "D"], ["D", "F"], ["G", "H", "I"], ["J", "K"]]

// moveRowAtIndexpath => [0,3] 〜 toIndexPath => [2,1]

// 下記のような配列を取得したい
let IndexArray: [IndexPath] = []   
// 中身が、[[0,3],[1,0],[1,1],[2,0],[2,1]]　となるようにしたい。
 

一応以下のコードで実現できそうですが、もっとスマートな方法があれば教えてください。

let arrayOfArray = [["A", "B", "C", "D"], ["D", "F"], ["G", "H", "I"], ["J", "K"]]

let startIndex: IndexPath = [0, 3] // moveRowAtIndexpathとtoIndexPathの小さい方を代入する
let endIndex: IndexPath = [2, 1] // moveRowAtIndexpathとtoIndexPathの大きい方を代入する

var indexArray: [IndexPath] = []

for (section, array) in arrayOfArray.enumerated() {
    
    for (row, _) in array.enumerated() {
        
        if (section < startIndex.section) ||
           (section <= startIndex.section  && row < startIndex.row) ||
           (section == endIndex.section && row > endIndex.row) ||
           (section > endIndex.section) {
            continue
        }
        
        let tempIndexPath: IndexPath = [section, row]
        
        indexArray.append(tempIndexPath)
    }
}

print("indexArray:",indexArray)

// => indexArray: [[0, 3], [1, 0], [1, 1], [2, 0], [2, 1]]

Answer 1

どっち向きのスマートさを求めているのか分かりませんが、見た目スマート路線で。

for section in startIndex.section...endIndex.section {
    let start = section == startIndex.section ? startIndex.row : 0
    let end = section == endIndex.section ? endIndex.row : arrayOfArray[section].count-1
    for row in start...end {
        indexArray.append(IndexPath(row: row, section: section))
    }
}

Comments

[退会済みユーザー]

回答ありがとうございます。
だいぶ見通しが良く、わかりやすいです。
勉強になります。

Answer 2

あまり元と比べてスマートになった感じがしませんが、一応書いたので。
flatMapを使うことでややこしそうなifを無くしてみました。

func generateRangeIndexPaths(gridArray: [[String]], startIndex: IndexPath, endIndex: IndexPath) -> [IndexPath] {
    
    let flatIndexPaths: [IndexPath] = gridArray.enumerated()
        .map { (section: $0.offset, array: $0.element) }
        .map { secArgs in secArgs.array.enumerated()
            .map { rowArgs in [secArgs.section, rowArgs.offset] } }
        .flatMap { $0 }
    
    let flatStartIndex: Int = gridArray.enumerated().filter { $0.offset < startIndex.section }.reduce(startIndex.row) { $0 + $1.element.count }
    let flatEndIndex: Int = gridArray.enumerated().filter { $0.offset < endIndex.section }.reduce(endIndex.row) { $0 + $1.element.count }
    
    return flatIndexPaths[flatStartIndex...flatEndIndex].map { $0 }
}

print("indexArray:", generateRangeIndexPaths(gridArray: arrayOfArray, startIndex: startIndex, endIndex: endIndex))

// => indexArray: [[0, 3], [1, 0], [1, 1], [2, 0], [2, 1]]

Comments

[退会済みユーザー]

回答ありがとうございます。
勉強になります。