thảo luận Leetcode mỗi ngày

class Solution {
public:
    int minOperations(vector<int>& nums) {
        cin.tie(0); cout.tie(0); ios::sync_with_stdio(0);
        unordered_map<int, int> cnt;
        for(int& num : nums)
            cnt[num]++;
        int n3, n2, res = 0;
        for(auto& [num, occ] : cnt) {
            n3 = occ / 3;
            if(occ % 3 == 2)
                res += n3 + (occ - n3 * 3) / 2;
            else if(occ % 3 == 1) {
                n3--;
                n2 = (occ - n3 * 3) / 2;
                if(n3 < 0 || n3 * 3 + n2 * 2 != occ)
                    return - 1;
                res += n3 + n2;
            }
            else
                res += n3;
        }
        return res;
    }
};

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        num_set = set()
        for num in nums:
            if num >= 0:
                num_set.add(num)
        k = 1
        while k in num_set:
            k+=1
        return k

class Solution:
    def firstMissingPositive(self, nums):
        n = len(nums)
        for i in range(n):
            if nums[i] < 1 or nums[i] > n:
                nums[i] = n+1
        for i in range(n):
            if abs(nums[i]) > 0 and abs(nums[i]) <= n:
                nums[abs(nums[i]) - 1] = -1* abs(nums[abs(nums[i]) - 1])
        for i in range(n):
            if nums[i] > 0:
                return i + 1
        return n+1

def min_operations(nums)
  nums.tally
  .inject(0) do |s, map|
    return -1 if m[1] == 1
    s += (m[1] / 3.0).ceil
  end
end

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        dp = [1]*len(nums)
        for i in range(1, len(nums)):
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], 1 + dp[j])

        ans = 0
        for i in range(len(dp)):
            ans = max(dp[i], ans)

        return ans

function lengthOfLIS(nums: number[]): number {
    const n = nums.length;
    const dp = new Array(n).fill(1);
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < i; j++) {
            if (nums[i] > nums[j] && dp[i] < dp[j] + 1) {
                dp[i] = dp[j] + 1;
            }
        }
    }
    return Math.max(...dp);
};

var lengthOfLIS = function (nums) {
    const dp = new Array(nums.length).fill(1);
    for (let i = 1; i < nums.length; i++) {
        for (let j = 0; j < i; j++) {
            if (nums[i] > nums[j]) {
                dp[i] = Math.max(dp[i], dp[j] + 1);
            }
        }
    }
    return Math.max(...dp);
};

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int res = 1;
        vector<int> dp(nums.size(), 1);
        for(int i = 1; i < nums.size(); ++i) {
            for(int j = 0; j < i; ++j) {
                if(nums[i] > nums[j]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            res = max(dp[i], res);
        }
        return res;
    }
};