【Swift】map関数の闇を暴き最速コードを創出せよ！〜フラグ組み合わせ生成から導く配列操作の革命〜

struct FeatureFlags {
    var featureA: Bool
    var featureB: Bool
    var featureC: Bool
    var featureD: Bool
}

Copy

func measureExecutionTime(for processName: String = #function, _ processing: @escaping () -> Void) {
    let startTime = CFAbsoluteTimeGetCurrent()
    defer {
        let elapsedTime = CFAbsoluteTimeGetCurrent() - startTime
        if elapsedTime >= 1.0 {
            print("[\(processName)] 実行時間: \(String(format: "%.3f", elapsedTime)) 秒)")
        } else {
            let milliseconds = elapsedTime * 1000
            print("[\(processName)] 実行時間: \(String(format: "%.3f", milliseconds)) ミリ秒")
        }
    }
    processing()
}

Copy

func generateCombinationsUsingLoop(flagCount: Int) -> [[Bool]] {
    var allCombinations: [[Bool]] = [[]]
    for _ in 0..<flagCount {
        allCombinations = allCombinations.flatMap { current in
            [current + [true], current + [false]]
        }
    }
    return allCombinations
}

Copy

func generateCombinationsRecursively(flagCount: Int) -> [[Bool]] {
    if flagCount == 0 { return [[]] }
    let previous = generateCombinationsRecursively(flagCount: flagCount - 1)
    return previous.flatMap { current in
        [current + [true], current + [false]]
    }
}

Copy

func generateCombinationsUsingReduce(flagCount: Int) -> [[Bool]] {
    return (0..<flagCount).reduce([[]]) { accumulatedCombinations, _ in
        accumulatedCombinations.flatMap { current in
            [current + [true], current + [false]]
        }
    }
}

Copy

func generateCombinationsUsingBitManipulation(flagCount: Int) -> [[Bool]] {
    let combinationCount = 1 << flagCount
    return (0..<combinationCount).map { i in
        (0..<flagCount).map { j in
            (i & (1 << (flagCount - 1 - j))) != 0
        }
    }
}

Copy

let flagCount = 20

measureExecutionTime(for: "Loop") {
    let _ = generateCombinationsUsingLoop(flagCount: flagCount)
}

measureExecutionTime(for: "Recursion") {
    let _ = generateCombinationsRecursively(flagCount: flagCount)
}

measureExecutionTime(for: "Reduce") {
    let _ = generateCombinationsUsingReduce(flagCount: flagCount)
}

measureExecutionTime(for: "Bit") {
    let _ = generateCombinationsUsingBitManipulation(flagCount: flagCount)
}

Copy

[Loop] 実行時間: 6.198 秒
[Recursion] 実行時間: 6.115 秒
[Reduce] 実行時間: 6.189 秒
[Bit] 実行時間: 32.405 秒

Copy

let arraySize = 1_000_000

// mapを使った配列生成
func generateArrayUsingMap(size: Int) -> [Int] {
    return (0..<size).map { $0 }
}

// for-inループを使った配列生成
func generateArrayUsingForLoop(size: Int) -> [Int] {
    var array: [Int] = []
    for i in 0..<size {
        array.append(i)
    }
    return array
}

// map 関数と for-in ループの比較
measureExecutionTime(for: "Map Function Array Generation") {
    let _ = generateArrayUsingMap(size: arraySize)
}

measureExecutionTime(for: "For-in Loop Array Generation") {
    let _ = generateArrayUsingForLoop(size: arraySize)
}

Copy

[Map Function Array Generation] 実行時間: 1.399 秒
[For-in Loop Array Generation] 実行時間: 91.282 ミリ秒

Copy

// 事前割り当てなしの配列生成
func generateArrayWithoutPreallocation(size: Int) -> [Int] {
    var array: [Int] = []
    for i in 0..<size {
        array.append(i)
    }
    return array
}

// 事前割り当てありの配列生成
func generateArrayWithPreallocation(size: Int) -> [Int] {
    var array: [Int] = Array(repeating: 0, count: size)
    for i in 0..<size {
        array[i] = i
    }
    return array
}

// 事前割り当ての有無の比較
measureExecutionTime(for: "Array Generation Without Preallocation") {
    let _ = generateArrayWithoutPreallocation(size: arraySize)
}

measureExecutionTime(for: "Array Generation With Preallocation") {
    let _ = generateArrayWithPreallocation(size: arraySize)
}

Copy

[Array Generation Without Preallocation] 実行時間: 92.173 ミリ秒
[Array Generation With Preallocation] 実行時間: 10.299 ミリ秒

Copy

// bit optimized
func generateCombinationsUsingBitManipulationOptimized(flagCount: Int) -> [[Bool]] {
    let combinationCount = 1 << flagCount
    var combinations: [[Bool]] = Array(repeating: Array(repeating: false, count: flagCount), count: combinationCount)

    for combinationValue in 0..<combinationCount {
        for bitIndex in 0..<flagCount {
            let bitPosition = flagCount - 1 - bitIndex
            combinations[combinationValue][bitIndex] = (combinationValue & (1 << bitPosition)) == 1
        }
    }
    return combinations
}

measureExecutionTime(for: "BitOptimized") {
    let _ = generateCombinationsUsingBitManipulationOptimized(flagCount: flagCount)
}

Copy

[BitOptimized] 実行時間: 1.2 秒

Copy

[Loop] 実行時間: 6.198 秒
[Recursion] 実行時間: 6.115 秒
[Reduce] 実行時間: 6.189 秒
[Bit] 実行時間: 32.405 秒

Copy