[Swift]LeetCode402. 移掉K位数字 | Remove K Digits

原文地址：https://www.cnblogs.com/strengthen/p/10310895.html 

Given a non-negative integer num represented as a string, remove k digits from the number so that the new number is the smallest possible.

Note:

• The length of num is less than 10002 and will be ≥ k.
• The given num does not contain any leading zero. 

Example 1:

Input: num = "1432219", k = 3
Output: "1219"
Explanation: Remove the three digits 4, 3, and 2 to form the new number 1219 which is the smallest. 

Example 2:

Input: num = "10200", k = 1
Output: "200"
Explanation: Remove the leading 1 and the number is 200. Note that the output must not contain leading zeroes. 

Example 3:

Input: num = "10", k = 2
Output: "0"
Explanation: Remove all the digits from the number and it is left with nothing which is 0.

---

给定一个以字符串表示的非负整数 num，移除这个数中的 k 位数字，使得剩下的数字最小。

注意:

• num 的长度小于 10002 且 ≥ k。
• num 不会包含任何前导零。

示例 1 :

输入: num = "1432219", k = 3
输出: "1219"
解释: 移除掉三个数字 4, 3, 和 2 形成一个新的最小的数字 1219。

示例 2 :

输入: num = "10200", k = 1
输出: "200"
解释: 移掉首位的 1 剩下的数字为 200. 注意输出不能有任何前导零。

示例 3 :

输入: num = "10", k = 2
输出: "0"
解释: 从原数字移除所有的数字，剩余为空就是0。

---

40ms

class Solution {
    func removeKdigits(_ num: String, _ k: Int) -> String {
        let n = num.count
        if n == k { return "0" }
        var k = k
        var stack: [Character] = []
        let ca = Array(num)
        for i in 0..<n {
            while k > 0 && !stack.isEmpty && stack.last! > ca[i] {
                stack.removeLast()
                k -= 1
            }
            stack.append(ca[i])
        }
        
        while k > 0 {
            stack.removeLast()
            k -= 1
        }
        
        while !stack.isEmpty && stack[0] == "0" {
            stack.removeFirst()
        }
        
        return stack.isEmpty ? "0" : String(stack)
    }
}

---

44ms

class Solution {
    func removeKdigits(_ num: String, _ k: Int) -> String {
        var stack = [Character]()
        var removed = 0
        for digit in num {
            while removed < k && !stack.isEmpty && digit < stack.last! {
                stack.removeLast()
                removed += 1
            }
            stack.append(digit)
        }
        while removed < k {
            stack.removeLast()
            removed += 1
        }
        stack = stack.reversed()
        while let last = stack.last, last == Character("0") {
            stack.removeLast()
        }
        guard !stack.isEmpty else {
            return "0"
        }
        return String(stack.reversed())
    }
}

---

52ms

class Solution {
    func removeKdigits(_ num: String, _ k: Int) -> String {
        guard num.count > 0 && k > 0 else {
            return num
        }
        var num = num.map{ String($0) }        
        var stack = [String]()
        var k = k
        var i = 0
        while i < num.count  {
            while stack.count > 0 && num[i] < stack.last! && k > 0 {
                stack.removeLast()
                k -= 1
            }            
            stack.append(num[i])
            i += 1
        }        
        while k > 0 && stack.count > 0 {
            stack.removeLast()
            k -= 1
        }        
        var j = 0 
        while j < stack.count && stack[j] == "0" {
            j += 1
        }        
        let result = Array(stack[j..<stack.count]).joined()        
        return result.count == 0 || k > 0 ? "0" : result        
    }
}

---

60ms

class Solution {
    func removeKdigits(_ num: String, _ k: Int) -> String {
        if num.count == k { return "0" }
        var array = [Character](num)
        var stack = [Character]()
        var count = k
        for c in array {
            while stack.count > 0 && stack.last! > c && count > 0 {
                stack.removeLast()
                count -= 1
            }
            stack.append(c)
        }
        while count > 0 {
            stack.removeLast()
            count -= 1
        }
        
        while stack.count > 0 && stack.first! == "0" {
            stack.removeFirst()
        }
        if stack.count == 0 {
            return "0"
        } else {
            return String(stack)    
        }       
    }
}

---

84ms

class Solution {
    func removeKdigits(_ num: String, _ k: Int) -> String {

        if num.isEmpty || num.count <= k {
            return "0"
        }

        var chars = Array(num)
        // var stack = Array(chars[0 ..< chars.count])
        var k = k

        while k > 0 {
            var idx = 0
            while idx+1 < chars.count && charToInt(chars[idx]) <= charToInt(chars[idx+1]) {
                idx += 1
            }
            
            if idx == chars.count-1 {
                chars.removeLast()
            } else {
                chars.remove(at:idx)
            }
            
            while chars.count > 0 && chars[0] == "0" {
                chars.removeFirst()
            }
            
            if chars.count == 0 {
                return "0"
            }

            k -= 1
        }
        
        return String(chars)
    }

    func charToInt(_ char:Character) -> Int {
        return Int(String(char))!
    }
}

---

100ms

class Solution {
    func removeKdigits(_ num: String, _ k: Int) -> String {
    guard num.count > k else{
        return "0"
    }
    
    var stack : [Int] = []
    var k = k
    for char in num{
        while k > 0 && !stack.isEmpty && stack.last! > int(of: char){
            stack.removeLast()
            k -= 1
        }
        if int(of: char) == 0 {
            if !stack.isEmpty{
                stack.append(int(of: char))
            }
        }else{
            stack.append(int(of: char))
        }
    }
    
    // there is a possibility in here that K is still greater than 1
    var result = ""
    for index in 0..<stack.count-k{
        result.append("(stack[index])")
    }
    
    return result.count == 0 ? "0" : result
  }

   func int(of char : Character)->Int{
          return Int(String(char))!
   }
}