[Swift]LeetCode969.煎饼排序 | Pancake Sorting

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

Given an array A, we can perform a pancake flip: We choose some positive integer k <= A.length, then reverse the order of the first k elements of A.  We want to perform zero or more pancake flips (doing them one after another in succession) to sort the array A.

Return the k-values corresponding to a sequence of pancake flips that sort A.  Any valid answer that sorts the array within 10 * A.length flips will be judged as correct.

Example 1:

Input: [3,2,4,1]
Output: [4,2,4,3]
Explanation: 
We perform 4 pancake flips, with k values 4, 2, 4, and 3.
Starting state: A = [3, 2, 4, 1]
After 1st flip (k=4): A = [1, 4, 2, 3]
After 2nd flip (k=2): A = [4, 1, 2, 3]
After 3rd flip (k=4): A = [3, 2, 1, 4]
After 4th flip (k=3): A = [1, 2, 3, 4], which is sorted. 

Example 2:

Input: [1,2,3]
Output: []
Explanation: The input is already sorted, so there is no need to flip anything.
Note that other answers, such as [3, 3], would also be accepted.

Note:

1. 1 <= A.length <= 100
2. A[i] is a permutation of [1, 2, ..., A.length]

---

给定数组 A，我们可以对其进行煎饼翻转：我们选择一些正整数 k <= A.length，然后反转 A 的前 k 个元素的顺序。我们要执行零次或多次煎饼翻转（按顺序一次接一次地进行）以完成对数组 A 的排序。

返回能使 A 排序的煎饼翻转操作所对应的 k 值序列。任何将数组排序且翻转次数在 10 * A.length 范围内的有效答案都将被判断为正确。

示例 1：

输入：[3,2,4,1]
输出：[4,2,4,3]
解释：
我们执行 4 次煎饼翻转，k 值分别为 4，2，4，和 3。
初始状态 A = [3, 2, 4, 1]
第一次翻转后 (k=4): A = [1, 4, 2, 3]
第二次翻转后 (k=2): A = [4, 1, 2, 3]
第三次翻转后 (k=4): A = [3, 2, 1, 4]
第四次翻转后 (k=3): A = [1, 2, 3, 4]，此时已完成排序。 

示例 2：

输入：[1,2,3]
输出：[]
解释：
输入已经排序，因此不需要翻转任何内容。
请注意，其他可能的答案，如[3，3]，也将被接受。

提示：

1. 1 <= A.length <= 100
2. A[i] 是 [1, 2, ..., A.length] 的排列

---

16ms

class Solution {
    func pancakeSort(_ A: [Int]) -> [Int] {
        var aCopy = A
        var result = [Int]()
        var valueToBeSort = A.count
        
        while valueToBeSort != 1 {
            if valueToBeSort == aCopy[valueToBeSort - 1] {
                valueToBeSort -= 1
            } else {
                let index = aCopy.firstIndex(of: valueToBeSort)!
                if index != 0 {
                    result.append(index + 1)
                    for i in 0...index / 2 {
                        aCopy.swapAt(i, index - i)
                    }
                }
                result.append(valueToBeSort)
                for i in 0...(valueToBeSort - 1) / 2 {
                    aCopy.swapAt(i, valueToBeSort - 1 - i)
                }
            }
        }

        return result
    }
}

---

24ms

class Solution {
    func pancakeSort(_ A: [Int]) -> [Int] {
        var A = A
        var ans = [Int]()
        var i = A.count
        while i>0 {
            var j=0
            for k in 0..<A.count {
                if A[k] == i {
                    j = k
                    break
                }
            }
            flip(&A, &ans, j);
            flip(&A, &ans, i-1);
            i -= 1
        }
        return ans
    }

    func flip(_ A: inout [Int], _ ans: inout [Int], _ pos: Int) -> Void {
        var s = 0, e = pos
        while s<e {
            let temp=A[s]
            A[s]=A[e]
            A[e]=temp
            s += 1
            e -= 1
        }
        ans.append(pos+1)
    }
}

---

32ms

class Solution {
    func pancakeSort(_ A: [Int]) -> [Int] {
        var B = A
        var n = A.count
        var ret = [Int]()
        while n >= 1 {
            let i = B.firstIndex(of: n)!
            B[0...i].reverse()
            ret.append(i+1)
            B[0..<n].reverse()
            ret.append(n)
            n -= 1
        }
        return ret
    }
}

---

36ms

class Solution {
    func pancakeSort(_ A: [Int]) -> [Int] {
        let sorted = A.sorted()
        guard A != sorted else { return [] }
        var ar = A
        var lastSorted = sorted.count - 1
        var res: [Int] = []
        while lastSorted >= 0 {
            let max = sorted[lastSorted]
            let ind = ar.index(of: max)!
            if ind == lastSorted {  
            } else {
                res.append(ind + 1)
                res.append(lastSorted + 1)
                var ar1 = ar
                if ind != 0 {
                  ar1 = Array(Array(ar[0...ind]).reversed()) + Array(ar[ind+1..<ar.count])
                }
                if lastSorted == ar1.count - 1 {
                   ar = Array(ar1.reversed())
                } else {
                    ar = Array(Array(ar1[0...lastSorted]).reversed()) + Array(ar1[lastSorted+1..<ar1.count])
                }
            }
            lastSorted -= 1
        }
        
        return res        
    }    
}

---

40ms

class Solution {
    func pancakeSort(_ A: [Int]) -> [Int] {
        var A = A
        var n:Int = A.count
        var ans:[Int] = [Int]()
        for i in (0...(n - 1)).reversed()
        {
            var j:Int = 0
            while(A[j] != i+1)
            {
                j += 1
            }
            ans.append(j + 1)
            ans.append(i + 1)
            var newA:[Int] = [Int](repeating:0,count:n)
            for k in 0..<n
            {
                newA[k] = A[k]
            }
            for k in 0...j
            {
                newA[k] = A[j-k]
            }
            A = newA
            newA = [Int](repeating:0,count:n)
            for k in 0..<n
            {
                newA[k] = A[k]
            }
            for k in 0...i
            {
                newA[k] = A[i-k]
            }
            A = newA
        }
        return ans
    }
}

---

80ms

class Solution {
    func pancakeSort(_ A: [Int]) -> [Int] {
        
        var res: [Int] = []
        
        var sortArray: [Int] = A.sorted()
        var A = A
        
        for i in (0...A.count - 1).reversed() {
            if A[i] == sortArray[i] {
                continue
            } else {
                for j in (0...i).reversed() {
                    if A[j] == sortArray[i] {
                        A.replaceSubrange(Range.init(0...j), with: A[0...j].reversed())
                        A.replaceSubrange(Range.init(0...i), with: A[0...i].reversed())
                        
                        res.append(j + 1)
                        res.append(i + 1)
                        
                        break
                    }
                }
            }
            
        }
        
        return res
    }
}

---

100ms

class Solution {
    func pancakeSort(_ A: [Int]) -> [Int] {
        // find largest and send to back
        var sorted = true
        for i in 0..<A.count - 1 {
            if A[i] > A[i + 1] {
                sorted = false
                break;
            }
        }
        if sorted { return [] }
        
        var flippedArr = A
        var accum: [Int] = []
        for i in 0..<A.count {
            var max = biggest(A.count - 1 - i, flippedArr)
            accum.append(max + 1)
            flippedArr = flip(max, flippedArr)
            print(flippedArr)
            accum.append(A.count - i)
            flippedArr = flip(A.count - 1 - i, flippedArr)
            // print(flippedArr)
        }
        return accum
    }
    
    func flip(_ end: Int, _ arr: [Int]) -> [Int] {
        var out = arr
        for i in 0...end/2 {
            let temp = out[i]
            out[i] = out[end - i]
            out[end - i] = temp
        }
        
        return out
    }
    
    func biggest(_ end: Int, _ arr: [Int]) -> Int {
        var max = 0
        for i in 0...end {
            if arr[i] >= arr[max] {
                max = i
            }
        }
        return max
    }
}