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

class Solution {
    func minDifference(_ nums: [Int]) -> Int {
        guard nums.count > 4 else { return 0}
        //[1, 2, 3, 4, 4]
        //[1, 1, 1, 1, 4]
        //[1, 2, 3, 4, 5, 20, 21, 22]
        let nums = nums.sorted()
        var minDiff = nums.last! - nums.first!
        for left in 0...3 {
            let right = nums.count - (3 - left) - 1
            let diff = nums[right] - nums[left]
            minDiff = min(minDiff, diff)
        }
        return minDiff
    }
}

class Solution {
    public int minDifference(int[] nums) {
        int n = nums.length;
        if(n<=3) return 0;
        Arrays.sort(nums);
        int res = Math.min(nums[n-4]- nums[0],nums[n-1]-nums[3]);
        res = Math.min(res,nums[n-3]- nums[1]);
        res =Math.min(res, nums[n-2] - nums[2]);
        return res;
    }
}

class Solution:
    def minDifference(self, nums: List[int]) -> int:
        n = len(nums)
        if n <= 4:
            return 0
        
        nums.sort()
        ans = float("inf")
        for i in range(4):
            ans = min(ans, nums[n - 4 + i] - nums[i])
            if ans == 0:
                return ans
        return ans

class Solution:
    def minDifference(self, nums: List[int]) -> int:
        n = len(nums)
        if n <= 3:
            return 0
            
        smallests = heapq.nsmallest(4, nums)
        largests = heapq.nlargest(4, nums)
        ans = math.inf
        for small in range(4):
            large = 3 - small
            ans = min(ans, largests[large] - smallests[small])

        return ans

var minDifference = function(nums) {
    const n = nums.length
    if (n <= 4) {
        return 0;
    }
    
    for (let i = 0; i < 4; i++) {
        for (let j = i + 1; j < n; j++) {
            if (nums[i] > nums[j]) {
                [nums[i], nums[j]] = [nums[j], nums[i]];
            }
        }
    }
    for (let i = n - 1; i >= n - 4; i--) {
        for (let j = 0; j < i; j++) {
            if (nums[i] < nums[j]) {
                [nums[i], nums[j]] = [nums[j], nums[i]];
            }
        }
    }
    let ans = +Infinity;
    for (let i = 0; i < 4; i++) {
        ans = Math.min(
            ans,
            Math.max(0, nums[n - 1 - 3 + i] - nums[i])
        );
    }
    return ans;
};

class Solution {

    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function minDifference($nums) {
        if (count($nums) <= 4) return 0;

        sort($nums);
        $ans1 = $nums[count($nums)-4] - $nums[0];
        $ans2 = $nums[count($nums)-3] - $nums[1];
        $ans3 = $nums[count($nums)-2] - $nums[2];
        $ans4 = $nums[count($nums)-1] - $nums[3];

        return min([$ans1, $ans2, $ans3, $ans4]);
    }
}

var minDifference = function(nums) {
    const n = nums.length;
    if (n <= 4) return 0;
    nums.sort((a, b) => a - b);
    return Math.min(nums[n-1] - nums[3], nums[n-2] - nums[2], nums[n-3] - nums[1], nums[n-4] - nums[0]);
};

class Solution {
    public int minDifference(int[] nums) {
        int len = nums.length;
        if(nums.length <=4) return 0;
        Arrays.sort(nums);
        int min = Integer.MAX_VALUE;
        for(int i =0;i<=3;i++){
            int res = nums[len-4+i]-nums[i];
            min = Math.min(min,res);
        }
        return min;
    }
}

/**
 * @param {number[]} nums
 * @return {number}
 */
var minDifference = function(nums) {
    if(nums.length < 5) return 0

    nums.sort((a, b) => a - b)

    console.log(nums)

    let min = Infinity

    let l = 0
    let r = l + nums.length - 1 - 3
    while(r < nums.length) {
        min = Math.min(min, nums[r] - nums[l])
        l += 1
        r = l + nums.length - 1 - 3
    }

    return min
};

impl Solution {
    pub fn min_difference(nums: Vec<i32>) -> i32 {
        let (mut maxs, mut mins) = (
            std::collections::BinaryHeap::with_capacity(4),
            std::collections::BinaryHeap::with_capacity(4),
        );
        if nums.len() <= 4 {
            return 0;
        }
        nums.iter().take(4).for_each(|&n| {
            maxs.push(-n);
            mins.push(n);
        });
        nums.into_iter().skip(4).for_each(|n| {
            let max = unsafe { maxs.peek().unwrap_unchecked() };
            if *max >= -n {
                maxs.push(-n);
            }
            let min = unsafe { mins.peek().unwrap_unchecked() };
            if *min >= n {
                mins.pop();
                mins.push(n)
            }
        });
        
        let (maxs, mins) = (maxs.into_sorted_vec(), mins.into_sorted_vec());
        let mut diff = i32::MAX;
        for i in 0..4 {
            diff = i32::min(diff, -maxs[i] - mins[3 - i]);
        }
        return diff;        
    }
}

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

impl Solution {
    pub fn min_difference(mut nums: Vec<i32>) -> i32 {
        let n = nums.len();

        if n <= 4 {
            return 0;
        }

        let (mut min_heap, mut max_heap) = (BinaryHeap::new(), BinaryHeap::new());

        for &num in &nums {
            min_heap.push(Reverse(num));

            if min_heap.len() > 4 {
                min_heap.pop();
            }

            max_heap.push(num);

            if max_heap.len() > 4 {
                max_heap.pop();
            }
        }

        let (maxes, mins) = (min_heap.into_sorted_vec(), max_heap.into_sorted_vec());
        let mut min_diff = i32::MAX;

        for i in 0..=3 {
            let (cur_min, Reverse(cur_max)) = (mins[i], maxes[3 - i]);
            min_diff = min_diff.min(cur_max - cur_min);
        }

        min_diff
    }
}

var minDifference = function (nums) {
    nums.sort((a, b) => a - b)
    let n = nums.length - 1
    if (n <= 3) return 0
    return Math.min(nums[n] - nums[3], nums[n - 1] - nums[2], nums[n - 2] - nums[1], nums[n - 3] - nums[0])
};

const isMatch = (s, p) => {
    let sPointer = 0;
    let pPointer = 0;
    let match = 0;
    let starIdx = -1;
   
    while (sPointer < s.length) {
        if (pPointer < p.length && (p[pPointer] === '?' || s[sPointer] === p[pPointer])) {
            sPointer++;
            pPointer++;
        } else if (pPointer < p.length && p[pPointer] === '*') {
            starIdx = pPointer;
            match = sPointer;
            pPointer++;
        } else if (starIdx !== -1) {
            pPointer = starIdx + 1;
            match++;
            sPointer = match;
        } else {
            return false;
        }
    }
   
    while (pPointer < p.length && p[pPointer] === '*') {
        pPointer++;
    }
   
    return pPointer === p.length;
};

public class Solution {
    public int MinDifference(int[] nums) {
        if(nums.Length <= 4)
            return 0;
        Array.Sort(nums);
        return Math.Min(nums[nums.Length-4] - nums[0], Math.Min(Math.Min(nums[nums.Length-1] - nums[3], nums[nums.Length-2] - nums[2]), nums[nums.Length-3] - nums[1]));
    }
}

class Solution:
    def minDifference(self, nums: List[int]) -> int:
        if len(nums) <= 4:
            return 0

        top_4_max = sorted(nums[:4])
        top_4_min = sorted(nums[:4], reverse=True)

        for num in nums[4:]:
            if num > top_4_max[0]:
                top_4_max[0] = num
                for i in range(3):
                    if top_4_max[i] > top_4_max[i+1]:
                        top_4_max[i], top_4_max[i+1] = top_4_max[i+1], top_4_max[i]
                    else:
                        break
            
            if num < top_4_min[0]:
                top_4_min[0] = num
                for i in range(3):
                    if top_4_min[i] < top_4_min[i+1]:
                        top_4_min[i], top_4_min[i+1] = top_4_min[i+1], top_4_min[i]
                    else:
                        break
        return min(
            (top_4_max[i] - top_4_min[3-i])
            for i in range(4)
        )

public class Solution
{
    public int MinDifference(int[] nums)
    {
        if (nums.Length <= 4)
        {
            return 0;
        }
        Array.Sort(nums);

        int result = nums[^1] - nums[0];
        for (int i = 0; i <= 3; i++)
        {
            result = Math.Min(result, nums[^(3 - i + 1)] - nums[i]);
        }

        return result;
    }
}

var mergeNodes = function(head) {
    let node = head;
    while (node.next) {
        let temp = node.next;
        let merged_sum = 0;

        while (temp && temp.val != 0) {
            merged_sum += temp.val;
            temp = temp.next;
        }

        temp.val = merged_sum;
        node.next = temp
        node = node.next;
    }

    return head.next;
};

function mergeNodes(head: ListNode | null): ListNode | null {
    if (!head) return head;
    let pre = head, cur = pre, val = 0;
    while (cur) {
        if (cur.val === 0) {
            if (val > 0) {
                pre.next.val = val;
                pre.next.next = cur.next;
                pre = pre.next;
                val = 0;
            }
        } else val+= cur.val;
        cur = cur.next;
    }
    return head.next;
};