[Swift]LeetCode948. 令牌放置 | Bag of Tokens

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

You have an initial power P, an initial score of 0 points, and a bag of tokens.

Each token can be used at most once, has a value token[i], and has potentially two ways to use it.

• If we have at least token[i] power, we may play the token face up, losing token[i] power, and gaining 1 point.
• If we have at least 1 point, we may play the token face down, gaining token[i] power, and losing 1point.

Return the largest number of points we can have after playing any number of tokens.

Example 1:

Input: tokens = [100], P = 50
Output: 0

Example 2:

Input: tokens = [100,200], P = 150
Output: 1

Example 3:

Input: tokens = [100,200,300,400], P = 200
Output: 2

 Note:

1. tokens.length <= 1000
2. 0 <= tokens[i] < 10000
3. 0 <= P < 10000

---

你的初始能量为 P，初始分数为 0，只有一包令牌。

令牌的值为 token[i]，每个令牌最多只能使用一次，可能的两种使用方法如下：

• 如果你至少有 token[i] 点能量，可以将令牌置为正面朝上，失去 token[i] 点能量，并得到 1 分。
• 如果我们至少有 1 分，可以将令牌置为反面朝上，获得 token[i] 点能量，并失去 1 分。

在使用任意数量的令牌后，返回我们可以得到的最大分数。

示例 1：

输入：tokens = [100], P = 50
输出：0

示例 2：

输入：tokens = [100,200], P = 150
输出：1

示例 3：

输入：tokens = [100,200,300,400], P = 200
输出：2

提示：

1. tokens.length <= 1000
2. 0 <= tokens[i] < 10000
3. 0 <= P < 10000

---

40ms

class Solution {
    func bagOfTokensScore(_ tokens: [Int], _ P: Int) -> Int {
        var curTokens = tokens
        var curP = P
        curTokens.sort{$0<$1}
        var lo = 0;
        var hi = curTokens.count-1;
        var points = 0
        var ans = 0
        while (lo <= hi && (curP >= curTokens[lo] || points > 0)){
            while (lo <= hi && curP >= curTokens[lo]){
                curP -= curTokens[lo]
                lo += 1
                points += 1;
            }
            ans = ans > points ? ans : points
            if(lo <= hi && points > 0){
                curP += curTokens[hi]
                hi -= 1
                points -= 1
            }
        }
        
        return ans
    }
}

---

44ms

class Solution {
    func bagOfTokensScore(_ tokens: [Int], _ P: Int) -> Int {
        guard !tokens.isEmpty else { return 0 }
        let tokens = tokens.sorted()
        
        var l = 0
        var h = tokens.count - 1
        var result = 0
        var current = 0
        var power = P
        
        while l <= h {
            let cToken = tokens[l]
            if power >= cToken {
                current += 1
                result = max(result, current)
                power -= cToken
                l += 1
            } else if current > 0 {
                current -= 1
                power += tokens[h]
                h -= 1
            } else {
                break
            }
        }
        
        return result
    }

---

72ms

class Solution {
    
    func bagOfTokensScore(_ tokens: [Int], _ power: Int) -> Int {
        let tokens = tokens.sorted()
        var power = power

        var leftIndex = 0
        var rightIndex = tokens.count - 1
        var points = 0
        var maxPoints = 0
        while leftIndex <= rightIndex {
            if power >= tokens[leftIndex] {
                power -= tokens[leftIndex]
                leftIndex += 1
                points += 1
                maxPoints = max(maxPoints, points)
            } else if points > 0 {
                power += tokens[rightIndex]
                rightIndex -= 1
                points -= 1
            } else {
                break
            }
        }

        return maxPoints
    }
}

---

76ms

class Solution {
    func bagOfTokensScore(_ tokens: [Int], _ P: Int) -> Int {
        var tokens = tokens.sorted(by:<)
        var P = P
        if tokens.count == 0 || P < tokens[0]
        {
            return 0
        }
        var n:Int = tokens.count
        var p:Int = 0
        var point:Int = 0
        var ret:Int = 0
        for i in 0...n
        {
            if i > 0
            {
                P += tokens[n-i]
                point -= 1
            }
            while(p < n-i && P >= tokens[p])
            {
                P -= tokens[p]
                point += 1
                p += 1
            }
            if p <= n-i
            {
                ret = max(ret, point)
            }
        }
        return ret
    }
}

---

144ms

class Solution {
    func bagOfTokensScore(_ tokens: [Int], _ P: Int) -> Int {
        
          if tokens.count == 0 {
    return 0
  }
  
  var sortedTokens = tokens.sorted()
  
  if sortedTokens[0] > P {
    return 0
  }
  
  var maxScore = 0
  var score = 0
  var currentPower = P
  
  while !sortedTokens.isEmpty {
    let firstToken = sortedTokens.first!
    print("firstToken (firstToken) currentPower (currentPower)")
    if firstToken <= currentPower {
      score += 1
      maxScore = max(maxScore, score)
      currentPower -= sortedTokens.removeFirst()
    } else {
      score -= 1
      currentPower += sortedTokens.removeLast()
      print("currentPower (currentPower)")
    }
  }
  
  return maxScore
}
}