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

class Solution(object):
    def numRescueBoats(self, people, limit):
        """
        :type people: List[int]
        :type limit: int
        :rtype: int
        """

        if (len(people) == 1): return 1

        boatNum = 0
        people.sort()
        sortedPeople = people

        left, right = 0, len(sortedPeople) -1

        while left < right :
            if sortedPeople[left] + sortedPeople[right] <= limit:
                print(left, right)
                left += 1
                right -= 1
                boatNum += 1
            else:
                print(left, right)
                right -= 1
                boatNum += 1
        
        if left == right:
            boatNum += 1

        return boatNum

function numRescueBoats(people: number[], limit: number): number {
    people.sort((a, b) => b - a)

    let count = 0;
    let left = 0;
    let right = people.length - 1;
    while (left <= right) {
        if (people[left] + people[right] <= limit) {
            left++;
            right--;
        } else {
            left++
        }

        count++
    }

    return count
};

var numRescueBoats = function(people, limit) {
    people.sort((a, b) => a - b);
    
    let res = 0;   
    let l = 0;
    let r = people.length - 1;
    while (l <= r) {
        if (people[l] + people[r] <= limit) {
            l++;
        }

        r--;
        res++;
    }
    
    return res;
};

class Solution:
    def numRescueBoats(self, people: List[int], limit: int) -> int:
        people.sort(reverse=True)
        i = 0
        res = 0
        while people[i] == limit:
            res += 1
            i += 1
        j = len(people) - 1
        while i <= j:
            if i != j:
                if people[i] + people[j] <= limit:
                    res += 1
                    i += 1
                    j -= 1
                else:
                    res += 1
                    i += 1
            else:
                res += 1
                i += 1
        return res

class Solution {
    public int numRescueBoats(int[] people, int limit) {
        Arrays.sort(people);
        int count=0;
        int r = people.length-1;
        int l =0;
        while(l<=r){
            if(people[r]==limit){
                count++;
            }
            else{
                if(people[r]+people[l]<=limit){
                    l++;
                }
                count++;
            }
            r--;
        }
        return count;
    }
}

public class Solution {
    public int NumRescueBoats(int[] people, int limit) {
        Array.Sort(people);
        int pointer1 = 0;
        int pointer2 = people.Length - 1;
        int result = 0;
        while(pointer1 <= pointer2)
        {
            result++;
            if(people[pointer1] + people[pointer2] <= limit)
            {
                pointer1++;
                pointer2--;
            }
            else
                pointer2--;
        }
        return result;
    }
}

var deleteNode = function(node) {
    const next = node.next;
    node.val = next.val;
    node.next = next.next;
};

void deleteNode(ListNode* node) {
        *node = *node->next;
    }

  public void deleteNode(ListNode node) {
    while (true) {
      node.val = node.next.val;
      if (node.next != null && node.next.next == null) {
        node.next = null;
        break;
      }
      node = node.next;
    }
  }

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void DeleteNode(ListNode node) {
        node.val = node.next.val;  
        node.next = node.next.next;
    }
}
}

class Solution {
    public void deleteNode(ListNode node) {
        node.val =node.next.val;
        node.next = node.next.next;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void DeleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

function deleteNode(node: ListNode | null): void {
    node.val = node.next.val;
    node.next = node.next.next;
};

void deleteNode(ListNode* node) {
    ListNode *cur = node, *next = node->next;
    while(next->next) {
        swap(cur->val, next->val);
        cur = cur->next;
        next = next->next;
    }
    swap(cur->val, next->val);
    cur->next = nullptr;
}

void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next = node->next->next;
    }

var deleteNode = function(node) {
    node.val = node.next?.val ?? null;
    node.next = node.next?.next ?? null;
};