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

class Solution {
    public boolean canMeasureWater(int x, int y, int target) {
        if(x+y<target)
            return false;
        int gcd = gcd(x,y);
        if (target%gcd ==0)
            return true;
        else
            return false;
    }

    public int gcd(int x, int y){
        if(y==0)
            return x;
        return gcd(y,x%y);
    }
}

class Solution {
    public boolean canMeasureWater(int x, int y, int target) {
        if(x>y)
            return canMeasureWater(y,x,target);
        if(x+y<target)
            return false;
        for(int i = 0;i<x;i++){
            if((y*i)%x == target%x)
                return true;
        }
        return false;
    }
}

class Solution:
    def robotSim(self, commands: List[int], obstacles: List[List[int]]) -> int:
        directions = [[0, 1], [1, 0], [0, -1], [-1, 0]]
        obstacles = set([(x, y) for x, y in obstacles])
        current = 0
        x, y = 0, 0
        ans = 0
        for command in commands:
            if command == -1:
                current = (current + 1)%4
            elif command == -2:
                current = 3 if current == 0 else current - 1
            else:
                steps = 0
                while steps != command:
                    nx = x + (steps + 1)*directions[current][0]
                    ny = y + (steps + 1)*directions[current][1]
                    if (nx, ny) in obstacles:
                        break
                    
                    steps += 1
                
                x += steps*directions[current][0]
                y += steps*directions[current][1]
                ans = max(ans, x**2 + y**2)
        
        return ans

class Solution {
    int deg = 90;
    Set<Pair<Integer,Integer>> set = new HashSet();

    public int robotSim(int[] commands, int[][] obstacles) {
        genMap(obstacles);

        int x = 0, y = 0, nextX, nextY;
        int max = 0;
        boolean moveAble = true;

        for(int i : commands) {
            if (i < 0) {
                nextDeg(i);
                continue;
            }

            nextX = x;
            nextY = y;

            while(i-- > 0) {
                switch(deg) {
                    case 90:
                        moveAble = tryMove(nextX, ++nextY);
                        break;
                    case 180:
                        moveAble = tryMove(++nextX, nextY);
                        break;
                    case 270:
                        moveAble = tryMove(nextX, --nextY);
                        break;
                    case 0:
                        moveAble = tryMove(--nextX, nextY);
                        break;
                }

                if (!moveAble)
                    break;
    
                x = nextX;
                y = nextY;
                max = Math.max(max, x * x + y * y);
            }
        }

        return max;
    }

    boolean tryMove(int x, int y) {
        return !set.contains(new Pair(x,y));
    }

    void nextDeg(int i) {
        if (i == -1)
            deg += 90;
        else
            deg -= 90;
        
        if (deg == 360)
            deg = 0;
        else if (deg < 0)
            deg = 270;
    }

    void genMap(int[][] obstacles) {
        for(int[] i : obstacles){
            set.add(new Pair(i[0],i[1]));
        }
    } 
}

class Solution {
    public int robotSim(int[] commands, int[][] obstacles) {
        int[][] directions = {{0,1},{1,0},{0,-1},{-1,0}};
        int current =0;
        int[] pos = {0,0};
        int res =0;
        Set<Pair<Integer,Integer>> set = new HashSet();
        for(int[] obstacle:obstacles){
            set.add(new Pair(obstacle[0],obstacle[1]));
        }
        for(int command:commands){
            if(command ==-1){
              current = (current+1+directions.length)%directions.length;
            }
            else if(command==-2){
               current = (current-1+directions.length)%directions.length;
            }
            else{
                for(int i =0 ; i <command;i++){
                    int newX = pos[0]+directions[current][0];
                    int newY = pos[1]+directions[current][1];
                    if(set.contains(new Pair(newX,newY))) break;
                    pos[0]=newX;
                    pos[1]= newY;
                    res=Math.max(res, pos[0]*pos[0]+pos[1]*pos[1]);
                }
            }
          
        }
        return res;
    }
}

 if (commands[i] == -2) { // Turns left
                direction = (direction + 3) % 4;
            } else if (commands[i] == -1) { // Turns right
                direction = (direction + 1) % 4;

import numpy as np
class Solution:
    def robotSim(self, commands: List[int], obstacles: List[List[int]]) -> int:
        direction = np.array([0, 1])
        left = np.array([[0, -1],[1, 0]])
        right = np.array([[0, 1],[-1, 0]])
        location = np.array([0, 0])
        res = 0

        obsSet = set(tuple(o) for o in obstacles)

        for command in commands:
            if command == -2:
                direction = np.dot(left, direction)
            elif command == -1:
                direction = np.dot(right, direction)
            else:
                for i in range(command):
                    nextLocation = direction + location
                    if tuple(nextLocation) in obsSet:
                        break
                    else:
                        location = nextLocation
                        res = max(res, location[0] * location[0] + location[1] * location[1])
        
        return res