[Swift]LeetCode611. 有效三角形的个数 | Valid Triangle Number

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

Given an array consists of non-negative integers, your task is to count the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle.

Example 1:

Input: [2,2,3,4]
Output: 3
Explanation:
Valid combinations are: 
2,3,4 (using the first 2)
2,3,4 (using the second 2)
2,2,3 

Note:

1. The length of the given array won't exceed 1000.
2. The integers in the given array are in the range of [0, 1000].

---

给定一个包含非负整数的数组，你的任务是统计其中可以组成三角形三条边的三元组个数。

示例 1:

输入: [2,2,3,4]
输出: 3
解释:
有效的组合是: 
2,3,4 (使用第一个 2)
2,3,4 (使用第二个 2)
2,2,3

注意:

1. 数组长度不超过1000。
2. 数组里整数的范围为 [0, 1000]。

---

Runtime: 36 ms

Memory Usage: 19.4 MB

class Solution {
    func triangleNumber(_ nums: [Int]) -> Int {
        var nums = nums
        var res:Int = 0
        var n:Int  = nums.count
        nums.sort()
        for i in stride(from:n - 1,through:2,by:-1)
        {
            var left:Int = 0
            var right:Int = i - 1
            while (left < right)
            {
                if nums[left] + nums[right] > nums[i]
                {
                    res += (right - left)
                    right -= 1
                }
                else
                {
                    left += 1
                }
            }
        }
        return res
    }
}

---

76ms

class Solution {
    func triangleNumber(_ nums: [Int]) -> Int {
        var result = 0
        guard nums.count >= 3 else {
            return 0
        }
        var nums = nums.sorted()
        for i in 0...nums.count - 2 {
            let longest = nums[i]
            var fast = i + 2
            var slow = i + 1
            while fast < nums.count {
                while slow < fast && nums[i] + nums[slow] <= nums[fast] {
                    slow += 1
                }
                result += fast - slow
                fast += 1
            }
        }
        return result
    }
}

---

124ms

class Solution {
    func triangleNumber(_ nums: [Int]) -> Int {
        guard nums.count >= 3 else { return 0 }
        let sortedNums = nums.sorted {
            return $0 < $1
        }
        var count = 0
        let last = sortedNums.count - 1
        print(sortedNums)
        for i in 0..<last {
            if sortedNums[i] == 0 {
                continue
            }
            var k = i + 1
            for j in i+1...last {
                if sortedNums[j] == 0 {
                    continue
                }
                let sum = sortedNums[i] + sortedNums[j]
                while k < sortedNums.count && sortedNums[k] < sum {
                    k += 1
                }
                count += (k - j - 1)
            }
        }
        return count
    }
}

---

128ms

class Solution {
    func triangleNumber(_ nums: [Int]) -> Int {
        let n = nums.sorted()
        var ans = 0
        for i in 0..<n.count {
            var k = i + 1
            for j in i + 1..<n.count {
                while k + 1 < n.count && n[k + 1] < n[i] + n[j] {
                    k += 1
                }
                if n[k] < n[i] + n[j] {
                    ans += max(0,k - j)
                }
            }
        }
        return ans
    }
}

---

232ms

class Solution {
    // return the last index of a biggest number <= target
    func binarySearch(_ nums: [Int], _ target: Int, _ start: Int, _ end: Int) -> Int {
        var i = start, j = end
        while i < j {
            let m = (i + j) / 2
            if nums[m] > target { j = m }
            else { i = m + 1 }
        }
        return i-1
    }
    
   
    func triangleNumber(_ nums: [Int]) -> Int {
        guard nums.count > 2 else { return 0 }
        let nums = nums.sorted()
        var res = 0
        for i in 0..<(nums.count - 2) {
            for j in i+1..<(nums.count - 1) {
                res += binarySearch(nums, nums[i] + nums[j] - 1, j+1, nums.count) - j
            }
        }
        return res
    }
}

---

248ms

class Solution {
    func triangleNumber(_ nums: [Int]) -> Int {
        if nums.count < 3 { return 0 }
        var res = 0
        let nums = nums.sorted()
        for i in 1..<nums.count - 1 {
            var k = nums.count - 1
            for j in (0..<i).reversed() {
                let s = nums[j] + nums[i]
                while k > i && nums[k] >= s { k -= 1 }
                res += k - i
            }
        }
        return res
    }
}

---

1180ms、18948kb

class Solution {
    func triangleNumber(_ nums: [Int]) -> Int {
    if nums.count < 3 {
      return 0
    }
    var count = 0
    let nums_sorted = nums.sorted()
    let maxNum = nums_sorted.last!
    for i in 0..<nums_sorted.count {
     
      for j in i+1..<nums_sorted.count {
        let side1 = nums_sorted[i]
        let side2 = nums_sorted[j]
        var numOfValidThridNums = 0
        for k in j+1..<nums_sorted.count {    
          if nums_sorted[k] < side1 + side2 {
            numOfValidThridNums = numOfValidThridNums + 1
          } else {
            break;
          }
        }
        count = count + numOfValidThridNums
      }
    }
    return count
  }
}

---

1584ms 

class Solution {
    func triangleNumber(_ nums: [Int]) -> Int {
        
        var n = 0
        let nums = nums.sorted()
        for i in 0..<nums.count {
            for j in i + 1..<nums.count {
                for k in j + 1..<nums.count {
                    if nums[k] < nums[i] + nums[j] {
                        n += 1
                    } else {
                        break
                    }
                }
            }
        }
        return n
    }
}

---

2332ms

class Solution {
    func triangleNumber(_ nums: [Int]) -> Int {
        let ct = nums.count
        if ct < 3 {
            return 0
        }
        var nums = nums.sorted { $0 > $1 }
        var ans = 0
        for i in 0..<ct-2 {
            for j in (i+1)..<ct-1 {
                for k in (j+1)..<ct {
                    if vailidTriangle(nums[i], nums[j], nums[k]) {
                        ans += 1
                    }else{
                        break
                    }
                }
            }
        }
        return ans
    }

    func vailidTriangle(_ a: Int, _ b: Int, _ c: Int) -> Bool {
        return (b+c>a)
    }
}