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

var isPowerOfTwo = function(n) {
    if (n <= 0) return false;
    return (n & (n - 1)) === 0;
}

class Solution:
    def isPowerOfTwo(self, n: int) -> bool:
        return n != 0 and n & (n-1) == 0

class Solution {
    public boolean isPowerOfTwo(int n) {
        return n > 0 && (n & n - 1) == 0;
    }
}

class Solution {
    public boolean isPowerOfTwo(int n) {
        if(n < 1) return false;
        return ((n&(n-1)) == 0);
    }
}

impl Solution {
    pub fn is_power_of_two(n: i32) -> bool {
        n>0 && ((n << 1)-1 == (n-1)|n)
    }
}

var isPowerOfTwo = function(n) {
    return n > 0 && n === (-n & n);
};

class Solution {
    public static boolean isPowerOfTwo(int n) {
        if (n <= 0) {
            return false;
        }
        return (n & (n - 1)) == 0;
    }
}

public class Solution
{
    public int MostBooked(int n, int[][] meetings)
    {
        Array.Sort(meetings, MeetingCompare);

        // roomId
        PriorityQueue<Room, int> availables = new();
        // endTime & id
        PriorityQueue<Room, Room> usings = new(new RoomComparer());
        for (int i = 0; i < n; i++)
        {
            Room room = new();
            room.id = i;
            availables.Enqueue(room, i);
        }

        int result = int.MaxValue;
        int mostUsed = 0;
        for (int i = 0; i < meetings.Length; i++)
        {       
            while (usings.Count > 0 && usings.Peek().end <= meetings[i][0])
            {
                Room room = usings.Dequeue();
                availables.Enqueue(room, room.id);
            }
            
            Retry:{}
            int used = TryUseRoom(availables, usings, meetings[i], out int roomId);
            if (roomId == -1)
            {
                Room delayRoom = usings.Dequeue();
                availables.Enqueue(delayRoom, delayRoom.id);
                goto Retry;
            }
            
            if (mostUsed < used)
            {
                mostUsed = used;
                result = roomId;
                continue;
            }
            if (mostUsed == used)
            {
                result = Math.Min(result, roomId);
            }
        }

        return result;
    }
    
    private int TryUseRoom(PriorityQueue<Room, int> availables, PriorityQueue<Room, Room> usings, int[] meeting, out int roomId)
    {
        roomId = -1;
        if (availables.Count == 0)
        {
            return -1;
        }
        Room room = availables.Dequeue();
        room.end = Math.Max(room.end, meeting[0]) + meeting[1] - meeting[0];
        room.used++;
        roomId = room.id;
        usings.Enqueue(room, room);
        
        return room.used;
    }

    private int MeetingCompare(int[] a, int[] b)
    {
        return a[0] - b[0];
    }

    public class Room
    {
        public int id;
        public int end;
        public int used;     
    }
    
    public class RoomComparer : IComparer<Room>
    {
        public int Compare(Room a, Room b)
        {
            int diff = a.end - b.end;
            if (diff == 0)
            {
                return a.id - b.id;
            }
            return diff;
        }
    }
}

public class Solution
{
    public bool IsPowerOfTwo(int n)
    {
        if (n == 0)
        {
            return false;
        }
        int oneBit = 0;
        while (n > 0)
        {
            if (oneBit > 1)
            {
                return false;
            }
            oneBit += n % 2 == 1 ? 1 : 0;
            n >>= 1;
        }

        return oneBit == 1;
    }
}

return  n > 0 && (n & (n - 1)) == 0;

class Solution {
    public boolean isPowerOfTwo(int n) {
        if (n <= 0){
            return false;
        }
        if (0 < n && n < 3){
            return true;
        }
        int s = 0;
        while (n > 1){
            
            s += n % 2;
            n = n/2;
        }
        if (s > 0){
            return false;
        }
        return true;
    }
}

class Solution {
public:
    bool isPowerOfTwo(int n) {
        if (n <= 0) return false;
        return (1 << (int)(log(n)/log(2)) == n);
    }
};

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        sum = 0
        n = len(nums)
        for num in nums:
            sum += num

        return n*(n + 1)//2 - sum

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        total = len(nums)
        for i, num in enumerate(nums):
            total += i - num
        return total

public class Solution
{
    public int MissingNumber(int[] nums)
    {
        int n = nums.Length;
        int expected = n * (n + 1) / 2;
        int actual = 0;
        for (int i = 0; i < nums.Length; i++)
        {
            actual += nums[i];
        }
        return expected - actual;
    }
}

public int missingNumber(int[] nums) {
    boolean[] mark = new boolean[nums.length + 1];
    for (int v : nums) {
        mark[v] = true;
    }
    for (int i = 0; i < mark.length; i++) {
        if (!mark[i]) {
            return i;
        }
    }
    return 0;
}

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        n = len(nums)
        result = n

        for i in range(n):
            result ^= (i ^ nums[i])
        
        return result