[Swift]LeetCode735. 行星碰撞 | Asteroid Collision

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

We are given an array asteroids of integers representing asteroids in a row.

For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.

Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.

Example 1:

Input: 
asteroids = [5, 10, -5]
Output: [5, 10]
Explanation: 
The 10 and -5 collide resulting in 10.  The 5 and 10 never collide. 

Example 2:

Input: 
asteroids = [8, -8]
Output: []
Explanation: 
The 8 and -8 collide exploding each other. 

Example 3:

Input: 
asteroids = [10, 2, -5]
Output: [10]
Explanation: 
The 2 and -5 collide resulting in -5.  The 10 and -5 collide resulting in 10. 

Example 4:

Input: 
asteroids = [-2, -1, 1, 2]
Output: [-2, -1, 1, 2]
Explanation: 
The -2 and -1 are moving left, while the 1 and 2 are moving right.
Asteroids moving the same direction never meet, so no asteroids will meet each other. 

Note:

• The length of asteroids will be at most 10000.
• Each asteroid will be a non-zero integer in the range [-1000, 1000].

---

给定一个整数数组 asteroids，表示在同一行的行星。

对于数组中的每一个元素，其绝对值表示行星的大小，正负表示行星的移动方向（正表示向右移动，负表示向左移动）。每一颗行星以相同的速度移动。

找出碰撞后剩下的所有行星。碰撞规则：两个行星相互碰撞，较小的行星会爆炸。如果两颗行星大小相同，则两颗行星都会爆炸。两颗移动方向相同的行星，永远不会发生碰撞。

示例 1:

输入: 
asteroids = [5, 10, -5]
输出: [5, 10]
解释: 
10 和 -5 碰撞后只剩下 10。 5 和 10 永远不会发生碰撞。

示例 2:

输入: 
asteroids = [8, -8]
输出: []
解释: 
8 和 -8 碰撞后，两者都发生爆炸。

示例 3:

输入: 
asteroids = [10, 2, -5]
输出: [10]
解释: 
2 和 -5 发生碰撞后剩下 -5。10 和 -5 发生碰撞后剩下 10。

示例 4:

输入: 
asteroids = [-2, -1, 1, 2]
输出: [-2, -1, 1, 2]
解释: 
-2 和 -1 向左移动，而 1 和 2 向右移动。
由于移动方向相同的行星不会发生碰撞，所以最终没有行星发生碰撞。

说明:

• 数组 asteroids 的长度不超过 10000。
• 每一颗行星的大小都是非零整数，范围是 [-1000, 1000] 。

---

84ms

class Solution {
    func asteroidCollision(_ asteroids: [Int]) -> [Int] {
        var positiveItems = [Int]()
        var negativeItems = [Int]()
        var isAddNegative = false
         
        for asteroid in asteroids
        {
            if asteroid > 0 
            {
                positiveItems.append(asteroid)
            }
            else
            {
              isAddNegative = true
              while positiveItems.count > 0
              {
                  
                if positiveItems.last! > abs(asteroid)
                {
                    isAddNegative = false
                    break
                }
                else 
                {
                    let lastPositiveItem = positiveItems.removeLast()

                    if lastPositiveItem == abs(asteroid)
                    {
                        isAddNegative = false
                        break

                    }                    
                  }
                }
                
                if isAddNegative
                {
                     negativeItems.append(asteroid)
                }
            }            
        }
        
        return negativeItems + positiveItems
        
    }
}

---

Runtime: 88 ms

Memory Usage: 19.2 MB

class Solution {
    struct Stack<T> {
        private var temperatures = [T]()
        mutating func push(_ item:T){
            self.temperatures.append(item)
        }
        
        mutating func pop()->T?{
            return self.temperatures.popLast()
        }
        
        func isEmpty() -> Bool {
            return self.temperatures.isEmpty
        }
        
        func peek() -> T? {
           return self.temperatures.last
        }
        
        func contents() -> [T] {
            return self.temperatures
        }
    }
    
        func asteroidCollision(_ asteroids: [Int]) -> [Int] {
        
        var stack:Stack = Stack<Int>()
        
        for asteroid in asteroids {
            var isShouldPush = true
            if asteroid < 0 {
                // 向左移动,碰撞检测
                while let peek = stack.peek(),peek > 0 {
                    if abs(peek) <= abs(asteroid) {
                        stack.pop()
                        isShouldPush = abs(asteroid) - abs(peek) > 0 ? true : false
                    }else{
                        isShouldPush = false
                    }
                    
                    if isShouldPush == false{
                        break
                    }
                }
                
            }
            
            if isShouldPush {
                stack.push(asteroid)
            }
        }
        return stack.contents()
    }
}

---

88ms

class Solution {
    func asteroidCollision(_ asteroids: [Int]) -> [Int] {
        var output = [Int]()
        
        for index in 0..<asteroids.count {
            let rock = asteroids[index]
            if rock > 0 {
                output.append(rock)
                continue
            }
            checkExplosion(&output, rock)
        }
        return output
    }
    
    func checkExplosion(_ output: inout [Int], _ rock: Int) {
        if let last = output.last {
            if last < 0 {
                output.append(rock)
            } else {
                output.removeLast()
                // Explode
                if abs(last) > abs(rock) {
                    output.append(last)
                } else if abs(last) < abs(rock) {
                    checkExplosion(&output, rock)
                }
            }
        } else {
            output.append(rock)
        }
    }
}

---

96ms

class Solution {
    func asteroidCollision(_ asteroids: [Int]) -> [Int] {
        var positives = [Int]()
        var negatives = [Int]()
        
        for asteroid in asteroids {
            if asteroid > 0 {
                positives.append(asteroid)
            } else {
                var shouldAppendToNegative = true
                
                while positives.count > 0 {
                    if positives.last! > -asteroid {
                        shouldAppendToNegative = false
                        break
                    } else {
                        let last = positives.removeLast()
                        
                        if -asteroid == last {
                            shouldAppendToNegative = false
                            break
                        }
                    }
                }
                
                if shouldAppendToNegative {
                    negatives.append(asteroid)
                }
            }
        }
        
        return negatives + positives
    }
}

---

100ms

class Solution {
    func asteroidCollision(_ asteroids: [Int]) -> [Int] {
        var goR = [Int]()
        var result = [Int]()
        
        for ast in asteroids {
            if ast < 0 {
                var astExploded = false
                while !goR.isEmpty && !astExploded {
                    if let prev = goR.last {
                        if prev.magnitude == ast.magnitude {
                            goR.removeLast()
                            astExploded = true
                        } else if prev.magnitude < ast.magnitude {
                            goR.removeLast()
                        } else {
                            astExploded = true
                        }
                    } else {
                        result.append(ast)
                    }
                }
                if !astExploded {
                    result.append(ast)
                }
            } else {
                goR.append(ast)
            }
        }

        if !goR.isEmpty {
            result.append(contentsOf: goR)
        }
        return result
    }
}

---

112ms

class Solution {
    func asteroidCollision(_ asteroids: [Int]) -> [Int] {
    guard asteroids.count > 1 else{
        return asteroids
    }
    
    var stack : [Int] = []
    
    outerLoop: for asteroid in asteroids{
        while !stack.isEmpty && stack.last! >= 0 && asteroid < 0{
            if stack.last! + asteroid == 0{
                stack.removeLast()
                continue outerLoop
            }else if stack.last! + asteroid > 0 {
                continue outerLoop
            }else{
                stack.removeLast()
            }
        }
        stack.append(asteroid)
        
    }
    return stack
  }
}