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

class Solution {
    public int minOperations(int[] nums) {
        Map<Integer,Integer> map = new HashMap();
        int ans =0;
        for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);
        }
        for(int num:map.values()){
            if(num==1) return -1;
            ans+=findOperations(num);
        
        }
        return ans;
    }
    public int findOperations(int num){
        int ans =0;
        while(num>0){
            if(num-3==0||num-3>=2){
                num=num-3;
                ans++;
            }else{
                num=num-2;
                ans++;
            }
        }
        return ans;
    }
}

class Solution {
  public int minOperations(int[] nums) {
    int[] count = new int[1000001];
    for (int num: nums) {
      count[num]++;
    }
    int ans = 0;
    for (int num: count) {
      if (num == 0) continue;

      if (num == 1) return -1;
      else if (num % 3 == 0) ans += num / 3;
      else if (num % 3 != 0) ans += num / 3 + 1;
    }
    return ans;
  }
}

class Solution {
    public int minOperations(int[] nums) {
        Arrays.sort(nums);
        int prev=-1;
        int count=0;
        int res=0;
        for(int i=0;i<nums.length;++i){
            if(prev!=nums[i]){
                if(count==1)return -1;
                else if(count%3!=0)res+=(count/3)+1;
                else res+=count/3;
                count=1;
                prev=nums[i];
            }else count++;
        }
        if(count==1)return -1;
        else if(count%3!=0)res+=(count/3)+1;
        else res+=count/3;
        return res;
    }
}

public int MinOperations(int[] nums)
{
    var dic = new Dictionary<int, int>();
    foreach (var num in nums)
    {
        dic[num] = dic.GetValueOrDefault(num) + 1;
    }

    int max = dic.Max(x => x.Value);
    var dp = new int[max +1];
    Array.Fill(dp, int.MaxValue);
    dp[0] = 0;
    for (int i = 2; i <= 3; i++)
    {
        for(int j = 0; j <= max - i; j++)
        {
            if (dp[j] != int.MaxValue)
            {
                dp[i + j] = Math.Min(dp[j] + 1, dp[i + j]);
            }
        }
    }

    int sum = 0;
    foreach (var pair in dic)
    {
        if (dp[pair.Value] == int.MaxValue)
        {
            return -1;
        }

        sum += dp[pair.Value];
    }

    return sum;
}

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def get(num):
            cnt = 0
            while num > 0:
                if num % 3 == 0:
                    num -= 3
                else:
                    num -= 2
                cnt += 1
            return cnt
        mp = {}
        for num in nums:
            mp[num] = mp.get(num , 0) + 1
        res = 0
        for k in mp:
            if mp[k] == 1:
                return -1
            res += get(mp[k])
        return res

function minOperations(nums: number[]): number {
    const intergerFrequency = new Map<number, number>();

    for (const num of nums){
        intergerFrequency.set(num, (intergerFrequency.get(num) || 0)+1);
    }

    let operationNumber = 0;
    for (const [num, frequency] of intergerFrequency){
        if (frequency === 1){
            return -1;
        }
        operationNumber += Math.ceil(frequency/3)
    }
    return operationNumber;
};

defmodule Solution do
  @spec min_operations(nums :: [integer]) :: integer
  def min_operations(nums) do
    integer_frequency = Enum.reduce(nums, %{}, fn num, acc ->
        Map.update(acc, num, 1, &(&1 + 1))
    end)

    Enum.reduce_while(integer_frequency, 0, fn {_integer, frequency}, acc ->
        if (frequency == 1) do
            {:halt, -1}
        else
            {:cont, acc + Float.ceil(frequency/3)}
        end
    end)
    |> trunc()
  end
end

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        freq = Counter(nums)
        @cache
        def cal(n):
            if n <= 3:
                return 1 if n == 2 or n == 3 else inf
            return 1 + min(cal(n-2), cal(n-3))
       
        ret = 0
        for val in freq.values():
            tmp = cal(val)
            if tmp == inf:
                return -1
            ret += tmp
        return ret

return reduce(lambda acc, n: -1 if n < 2 or acc < 0 else acc + n//3 + 1 if n%3 else acc + n//3, Counter(nums).values(), 0)

class Solution {
    public static int minOperations(int[] nums) {
        int ans = 0;
        Arrays.sort(nums);
        int[] freq = new int[nums[nums.length-1]+1];
        for (int num : nums) {
            freq[num]++;
        }
        for (int j : freq) {
             if (j == 1) {
                return -1;
            }
            if (j % 3 != 0) {
                ans += j / 3 + 1;
            } else {
                ans += j / 3;
            }
        }
        return ans;
    }
}

class Solution {
public:
    int minOperations(vector<int>& nums) {
        unordered_map<int,int> mp;
        int res = 0;
        for(int i : nums){
            mp[i]++;
        }
        for(auto &pair : mp){
            int se = pair.second;
            if(se == 1) return -1;
            res += se / 3;
            if(se % 3) res++;
        }
        return res;
    }
};