[Swift]LeetCode957. N天后的牢房 | Prison Cells After N Days

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10126178.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

There are 8 prison cells in a row, and each cell is either occupied or vacant.

Each day, whether the cell is occupied or vacant changes according to the following rules:

• If a cell has two adjacent neighbors that are both occupied or both vacant, then the cell becomes occupied.
• Otherwise, it becomes vacant.

(Note that because the prison is a row, the first and the last cells in the row can't have two adjacent neighbors.)

We describe the current state of the prison in the following way: cells[i] == 1 if the i-th cell is occupied, else cells[i] == 0.

Given the initial state of the prison, return the state of the prison after N days (and N such changes described above.)

Example 1:

Input: cells = [0,1,0,1,1,0,0,1], N = 7
Output: [0,0,1,1,0,0,0,0]
Explanation: 
The following table summarizes the state of the prison on each day:
Day 0: [0, 1, 0, 1, 1, 0, 0, 1]
Day 1: [0, 1, 1, 0, 0, 0, 0, 0]
Day 2: [0, 0, 0, 0, 1, 1, 1, 0]
Day 3: [0, 1, 1, 0, 0, 1, 0, 0]
Day 4: [0, 0, 0, 0, 0, 1, 0, 0]
Day 5: [0, 1, 1, 1, 0, 1, 0, 0]
Day 6: [0, 0, 1, 0, 1, 1, 0, 0]
Day 7: [0, 0, 1, 1, 0, 0, 0, 0]

Example 2:

Input: cells = [1,0,0,1,0,0,1,0], N = 1000000000
Output: [0,0,1,1,1,1,1,0]

Note:

1. cells.length == 8
2. cells[i] is in {0, 1}
3. 1 <= N <= 10^9

---

8 间牢房排成一排，每间牢房不是有人住就是空着。

每天，无论牢房是被占用或空置，都会根据以下规则进行更改：

• 如果一间牢房的两个相邻的房间都被占用或都是空的，那么该牢房就会被占用。
• 否则，它就会被空置。

（请注意，由于监狱中的牢房排成一行，所以行中的第一个和最后一个房间无法有两个相邻的房间。）

我们用以下方式描述监狱的当前状态：如果第 i 间牢房被占用，则 cell[i]==1，否则 cell[i]==0。

根据监狱的初始状态，在 N 天后返回监狱的状况（和上述 N 种变化）。

示例 1：

输入：cells = [0,1,0,1,1,0,0,1], N = 7
输出：[0,0,1,1,0,0,0,0]
解释：
下表概述了监狱每天的状况：
Day 0: [0, 1, 0, 1, 1, 0, 0, 1]
Day 1: [0, 1, 1, 0, 0, 0, 0, 0]
Day 2: [0, 0, 0, 0, 1, 1, 1, 0]
Day 3: [0, 1, 1, 0, 0, 1, 0, 0]
Day 4: [0, 0, 0, 0, 0, 1, 0, 0]
Day 5: [0, 1, 1, 1, 0, 1, 0, 0]
Day 6: [0, 0, 1, 0, 1, 1, 0, 0]
Day 7: [0, 0, 1, 1, 0, 0, 0, 0]

示例 2：

输入：cells = [1,0,0,1,0,0,1,0], N = 1000000000
输出：[0,0,1,1,1,1,1,0]

提示：

1. cells.length == 8
2. cells[i] 的值为 0 或 1 
3. 1 <= N <= 10^9

---

16ms

class Solution {
    func prisonAfterNDays(_ cells: [Int], _ N: Int) -> [Int] {
        var cells = cells
        var N:Int = N % 14
        if N == 0
        { 
            N = 14
        }
        for i in 0..<N
        {
            var temp:[Int] = [Int](repeating:0,count:cells.count)
            temp[0] = 0
            temp[7] = 0
            for j in 1..<7
            {
                 temp[j] = 1 - cells[j - 1]^cells[j + 1]
            }
            cells = temp
        }
        return cells
    }
}

---

16ms

class Solution {
    func prisonAfterNDays(_ cells: [Int], _ N: Int) -> [Int] {
        var currentDay = processDay(cells)
        let originalCells = currentDay
        var count = 0

        repeat {
            currentDay = processDay(currentDay)
            count += 1
        } while currentDay != originalCells

        let fullCycle = (N-1) % count

        if fullCycle == 0 {
            return currentDay
        } else {
            for _ in 1...fullCycle {
                currentDay = processDay(currentDay)
            }
            return currentDay
        }
    }

    func processDay(_ cells: [Int]) -> [Int] {
        var newCells = [0]

        for i in 1..<cells.count - 1 {
            newCells.append(cells[i-1] == cells[i+1] ? 1 : 0)
        }

        newCells.append(0)

        return newCells
    }
}

---

20ms

class Solution {
    func prisonAfterNDays(_ cells: [Int], _ N: Int) -> [Int] {
        var arr:[Int] = [Int](repeating:0,count:512)
        var pre:[Int] = cells
        var cur:[Int] = [Int]()
        arr[getSum(pre)] = 0
        for i in 1...N
        {
            cur = [Int](repeating:0,count:8)
            for j in 1..<7
            { 
                if pre[j - 1] == pre[j + 1]
                {
                    cur[j] = 1
                }
            }
            if arr[getSum(cur)] == 0
            {
                arr[getSum(cur)] = i
            }
            else
            {
                var p:Int = arr[getSum(cur)]
                var d:Int = (N - i) % (i - p)
                for k in 0..<512
                {
                    if arr[k] == p + d
                    {
                        return getArr(k)
                    }
                }
            }
            pre = cur
        }
        return pre
    }
    
    func getArr(_ n:Int) -> [Int]
    {
        var n = n
        var result:[Int] = [Int](repeating:0,count:8)
        for i in (0...7).reversed()
        {
            let num:Int = Int(pow(2, Double(i)))
            if n >= num
            {
                result[i] = 1
                n -= num
            }
        }
        return result
    }
    
    func getSum(_ arr:[Int])->Int
    {
        var result:Int = 0
        for  i in 0...7
        {
            if arr[i] == 1
            {
                result += Int(pow(2, Double(i)))
            }
        }
        return result
    }
}

---

24ms

class Solution {
    func prisonAfterNDays(_ cells: [Int], _ N: Int) -> [Int] {
        if N == 0 { return cells }
        var cells = cells
        var copy1day: [Int] = []
        var newDays = -1
        for i in 1...N {
            var prev = -1
            for i in 0..<7 {
                if cells[i + 1] == prev {
                    prev = cells[i]
                    cells[i] = 1
                } else {
                    prev = cells[i]
                    cells[i] = 0
                }
            }
            cells[7] = 0
            //print("(i): (cells)")
            if i == 1 {
                copy1day = cells
            } else if copy1day == cells {
                let cycle = i - 1
                newDays = (N - 1) % cycle
                //print(cycle)
                //print(newDays)
                break
            }
        }
        guard newDays >= 0 else { return cells }
        for i in 0..<newDays {
            var prev = -1
            for i in 0..<7 {
                if cells[i + 1] == prev {
                    prev = cells[i]
                    cells[i] = 1
                } else {
                    prev = cells[i]
                    cells[i] = 0
                }
            }
        }
        
        return cells
    }
}

---

36ms

class Solution {
    func prisonAfterNDays(_ cells: [Int], _ N: Int) -> [Int] {
        let seq = sequence(first: cells, next: next)
        return seq.extrapolate(to: N)
    }
}

func next(_ cells: [Int]) -> [Int] {
    var result = Array(repeating: 0, count: cells.count)
    
    for (index, equal) in zip(1..., zip(cells, cells.dropFirst(2)).lazy.map(==)) {
        result[index] = equal ? 1 : 0
    }
    
    return result
}

extension Sequence where Element: Hashable {
    func extrapolate(to targetIndex: Int) -> Element {
        precondition(targetIndex >= 0)
        
        var indices: [Element: Int] = [:]
        var elements: [Element] = []
        
        for (index, element) in enumerated() {
            if index == targetIndex {
                return element
            } else if let previous = elements.lastIndex(of: element) {
                let cycle = index - previous
                let remaining = (targetIndex - index) % cycle
                return elements[previous + remaining]
            } else {
                indices[element] = index
                elements.append(element)
            }
        }
        
        preconditionFailure("sequence terminated too early")
    }
}

---

64ms

class Solution {
    func prisonAfterNDays(_ cells: [Int], _ N: Int) -> [Int] {
        var currentDay = processDay(cells)
        var originalCells = currentDay
        var count = 0

        repeat { 
            currentDay = processDay(currentDay)
            count += 1
        } while currentDay != originalCells
        
        let cyclesToComplete = (N-1)%count
        
        if cyclesToComplete == 0 {
            return currentDay
        } else {
            for _ in 1...cyclesToComplete {
                currentDay = processDay(currentDay)
            }        
        }
        
        return currentDay
    }
    
    func processDay(_ cells: [Int]) -> [Int] {
        var newCells = [Int]()
        newCells.append(0)
        for index in 1..<cells.count-1 {
            newCells.append(cells[index-1] == cells[index+1] ? 1 : 0)
        }
        newCells.append(0)
        print(newCells)
        return newCells
    }
}