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

int findMaxK(vector<int>& nums) {
    unordered_set<int> s;
    int ret = -1;
    for(auto e : nums) {
        if (s.count(-e))
            ret = max(ret, abs(e));
        else
            s.insert(e);
    }
    return ret;
}

class Solution {
    public int findMaxK(int[] nums) {
        Set<Integer> negative = new HashSet<>();

        for (int num: nums) {
            if (num < 0) {
                negative.add(num);
            }
        }

        int max = -1;

        for (int num: nums) {
            if (num > max && negative.contains(-num)) {
                max = num;
            }
        }

        return max;
    }
}

public int findMaxK(int[] nums) {
    int max = 0;
    Set<Integer> set = new TreeSet<>();
    for (int n1 : nums) {
        int n2 = -n1;
        if (set.contains(n2)) {
            max = Math.max(max, Math.max(n1, n2));
        }
        set.add(n1);
    }
    return max == 0 ? -1 : max;
}

function findMaxK(nums: number[]): number {
    let res = -1;
    const set = new Set();
    for (const num of nums) {
        set.add(num)
        if (set.has(num * -1)) res = Math.max(res, Math.abs(num))
    }
    return res; 
};

use std::collections;
use std::cmp;

impl Solution {
    pub fn find_max_k(nums: Vec<i32>) -> i32 {
        let n = nums.len();
        let mut hash_set = vec![false; 2001];

        for &a in &nums {
            hash_set[(a + 1000) as usize] = true;
        }

        let mut max = -1;
        for &a in &nums {
            if (a > 0 && hash_set[(1000 - a) as usize]) {
                max = cmp::max(max, a);
            }
        }

        max
    }
}

class Solution:
    def findMaxK(self, nums: List[int]) -> int:
        have_positive = [0] * 1001 # have_positive[n] = 1 if n in nums
        have_negative = [0] * 1001 # have_negative[n] = 1 if -n in nums
        
        result = -1
        
        for num in nums:
            if num > 0:
                have_positive[num] = 1
                if have_negative[num] and num > result:
                    result = num
            elif num < 0:
                have_negative[-num] = 1
                if have_positive[-num] and -num > result:
                    result = -num
                    
        return result

class Solution {
    fun findMaxK(nums: IntArray): Int {
        var ans = -1
        val numsSet = nums.toSet()
        nums.forEach {
            if (it > 0 && -it in numsSet) {
                ans = max(it, ans)
            }
        }
        return ans
    }
}

class Solution {
    public int findMaxK(int[] nums) {
        int ans =-1;
        boolean[] check = new boolean[2002];

        for(int num:nums){
            check[num+1000] = true;
            if(check[num+1000] && check[-num+1000]) {
                ans= ans<Math.abs(num)? Math.abs(num):ans;
            }
        }
        return ans;
    }
}

var findMaxK = function(nums) {
    const set = new Set(nums);
    let res = -1;
    for (const n of nums) {
        if (n > res && set.has(-n)) res = n;
    }
    return res;
};

use std::cmp;
use std::str;

impl Solution {
    pub fn longest_nice_substring(s: String) -> String {
        let bytes = s.as_bytes();
        let n = bytes.len();

        let mut max_i = 0;
        let mut max_j = 0;

        for i in 0..n {
            let mut lower_case_mask = 0u32;
            let mut upper_case_mask = 0u32;

            for j in i..n {
                if (bytes[j] >= b'a' && bytes[j] <= b'z') {
                    let char_mask = 1 << (bytes[j] - b'a');
                    lower_case_mask |= char_mask;
                }

                if (bytes[j] >= b'A' && bytes[j] <= b'Z') {
                    let char_mask = 1 << (bytes[j] - b'A');
                    upper_case_mask |= char_mask;
                }

                if (lower_case_mask ^ upper_case_mask == 0 && j + 1 - i > max_j - max_i) {
                    max_i = i;
                    max_j = j + 1;
                }
            }
        }

        unsafe { str::from_utf8_unchecked(&bytes[max_i..max_j]) }.to_string()
    }
}

class Solution:
    def findMaxK(self, nums: List[int]) -> int:
        existed = {}
        for num in nums:
            if num < 0:
                existed[num] = True
        result = -1
        for num in nums:
            if num > result and (0 - num) in existed:
                result = num
        return result

public int findMaxK(int[] nums) {
        Arrays.sort(nums);
        int idx = nums.length - 1;
        while (idx > 0 && nums[idx] > 0) {
            boolean isFound = found(nums, -nums[idx]);
            if (isFound) return nums[idx];
            idx--;
        }

        return -1;
    }

    boolean found(int[] nums, int num) {
        int left = 0;
        int right = nums.length - 1;
        while (right >= left) {
            int mid = (right + left) / 2;

            if (num < nums[mid]) {
                right = mid - 1;
            } else if (num > nums[mid]) {
                left = mid + 1;
            } else if (num == nums[mid]) {
                return true;
            }
        }

        return false;
    }

class Solution {
    public int findMaxK(int[] nums) {
      Set<Integer> setNegativeNums = new HashSet<>();
      int max = -1;
      for (int num : nums) {
        if (setNegativeNums.contains(-num)) {
          max = Math.max(max, Math.abs(num));
        }
        setNegativeNums.add(num);
      }
      return max;
    }
}

function findMaxK(nums: number[]): number {
    let set = new Set<number>();
    let res = -1;

    for (let num of nums) {
        if (set.has(num * -1) && Math.abs(num) > res) {
            res = Math.abs(num)
        }

        set.add(num)
    }

    return res
};