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

import math

class Solution:
    def judgeSquareSum(self, c: int) -> bool:
        def check(x):
            return math.sqrt(x).is_integer()
            
        def binarySearch(l , r , x):
            if not check(x): return False
            while l <= r:
                mid = (l + r) // 2
                if mid == x:
                    return True
                elif mid > x: r = mid - 1
                else: l = mid + 1
            
            return False
        
        for l in range(0 , int(math.sqrt(c) + 1)):
            if binarySearch(0 , c , c - l * l): return True
            
        return False

fun judgeSquareSum(c: Int): Boolean {
    return (0..sqrt(c.toDouble()).toInt()).any { sqrt((c - it * it).toDouble()) % 1 == 0.0 }
}

public class Solution
{
    public bool JudgeSquareSum(int c)
    {
        if (c == 2 || c == 1 || c == 0)
        {
            return true;
        }
        
        Dictionary<int, int> primeFactors = PrimeFactorization(c);
        foreach (var entry in primeFactors)
        {
            int prime = entry.Key;
            int exponent = entry.Value;
            if (prime % 4 == 3 && exponent % 2 != 0)
            {
                return false;
            }
        }

        return true;;
    }

    private Dictionary<int, int> PrimeFactorization(int n)
    {
        Dictionary<int, int> primeFactors = new(); // key = prime, value = exponent

        while (n % 2 == 0)
        {
            n /= 2;
            if (!primeFactors.ContainsKey(2))
            {
                primeFactors[2] = 1;
                continue;
            }
            primeFactors[2]++;
        }

        int sqrtn = (int)Math.Sqrt(n);
        for (int i = 3; i <= sqrtn; i += 2)
        {
            while (n % i == 0)
            {
                n /= i;
                if (!primeFactors.ContainsKey(i))
                {
                    primeFactors[i] = 1;
                    continue;
                }
                
                primeFactors[i]++;
            }
        }

        primeFactors[n] = 1;

        return primeFactors;
    }
}

class Solution {
    public boolean judgeSquareSum(int c) {
        Set<Integer> set = new HashSet<>();

        for (int i = 0; i <= Math.sqrt(c); i++) {
            set.add(i*i);
            if (set.contains(c - i * i)) return true;
        }

        return false;
    }
}

public class Solution {
    public bool JudgeSquareSum(int c) {
        HashSet<int> set = new HashSet<int>();
        for(int i = 0; i<(int)(Math.Sqrt(c)) + 1; i++)
        {
            set.Add(i*i);
            if(set.Contains(c-i*i))
                return true;
        }
        return false;
    }
}

class Solution {
    public int maxProfitAssignment(int[] difficulty, int[] profit, int[] worker) {
        Map<Integer, Integer> map = new HashMap<>();
        int n = difficulty.length;
        int m = worker.length;

        for (int i = 0; i < n; i++) {
            if (!map.containsKey(difficulty[i]) || profit[i] > map.get(difficulty[i])) {
                map.put(difficulty[i], profit[i]);
            }
        }

        Arrays.sort(difficulty);

        for (int i = 0; i < n; i++) {
            profit[i] = map.get(difficulty[i]);
        }

        for (int i = 1; i < n; i++) {
            profit[i] = Math.max(profit[i], profit[i - 1]);
        }

        int ans = 0;
        Arrays.sort(worker);
        int wp = 0, dp = 0;

        while (wp < m) {
            if (worker[wp] >= difficulty[dp]) {
                if (dp == n - 1 || worker[wp] < difficulty[dp + 1]) {
                    ans += profit[dp];
                    wp++;
                } else if (worker[wp] >= difficulty[dp + 1]) {
                    dp++;
                }
            } else {
                ans += 0;
                wp++;
            }
        }

        return ans;
    }
}