class Solution {
    public int countOdds(int low, int high) {
        return low % 2 == 0 && high % 2 == 0 ? (high-low)/2: (high-low)/2+1;
    }
}

public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        int count=0;
        while(n!=0){
            if((n&1)==1)
            count++;

            n=n>>>1;
        }

        return count;
    }
}

class Solution {
    public boolean isHappy(int n) {
        int count=6;
        while(count-- >0){
            if(convert(n)!=1)
                n=convert(n);
            else
                return true;
        }
        return false;
    }
    public int convert(int num){
        int sum=0;
        while(num>0){
            sum+=Math.pow(num%10, 2);
            num/=10;
        }
        
        return sum;
    }
}

class Solution {
    public boolean areAlmostEqual(String s1, String s2) {
        List<Integer> l = new ArrayList<>();
        for (int i = 0; i < s1.length(); i++) {
            if (s1.charAt(i) != s2.charAt(i)) l.add(i);
   if (l.size() > 2) return false;
        }
        return l.size() == 0 || (l.size() == 2 && s1.charAt(l.get(0)) == s2.charAt(l.get(1)) && s1.charAt(l.get(1)) == s2.charAt(l.get(0)));
    }
}

class NumArray {
    int nums[];
    public NumArray(int[] nums) {
        this.nums=nums;
    }
    
    public int sumRange(int left, int right) {
        int sum=0;
        for(int i=left; i<=right; i++)
            sum+=nums[i];
        
        return sum;
    }
}

select product_id from products
where low_fats='Y' and recyclable='Y';

SELECT date_id, make_name, COUNT(DISTINCT lead_id) AS unique_leads, COUNT(DISTINCT partner_id) AS unique_partners
FROM DailySales group by date_id, make_name;

select event_day as day, emp_id, (sum(out_time) - sum(in_time)) as total_time
from employees group by emp_id, day;

SELECT employee_id, (
CASE
    WHEN employee_id%2=1 AND name NOT LIKE 'M%' THEN salary
    ELSE 0
END
) AS bonus FROM employees;

select stock_name, sum(
case
    when operation = 'Buy' then -price
    else price
end
) as capital_gain_loss from stocks
group by stock_name

class Solution {
    public int findDuplicate(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for(int n: nums){
            if(!set.contains(n))
                set.add(n);
            else
                return n;
        }
        
        return -1;
    }
}

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int r=matrix.length, c = matrix[0].length;
        int start=0, end=r*c-1, mid=(start+end)/2;
        
        while(start<=end){
            if(matrix[mid/c][mid%c]>target)
                end=mid-1;
            else if(matrix[mid/c][mid%c]<target)
                start=mid+1;
            else
                return true;
            
            mid=(start+end)/2;
        }
        
        return false;
    }
}

select
    u.name, sum(t.amount) as balance
from users u
join transactions t on u.account=t.account
group by t.account 
having balance>10000;

class Solution {
    public boolean checkStraightLine(int[][] coordinates) {
        int x0 = coordinates[0][0], y0 = coordinates[0][1], 
            x1 = coordinates[1][0], y1 = coordinates[1][1];
        int dx = x1 - x0, dy = y1 - y0;
        for (int[] co : coordinates) {
            int x = co[0], y = co[1];
            if (dx * (y - y1) != dy * (x - x1))
                return false;
        }
        return true;
    }
}

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        int res=0;
        if(root == null) return 0;
        if(root.left != null){
            if(root.left.left == null && root.left.right == null) res += root.left.val;
            else res += sumOfLeftLeaves(root.left);
        }
        
        res+=sumOfLeftLeaves(root.right);
        
        return res;
    }
}

class Solution {
    List<Integer> list = new ArrayList<>();
    public List<Integer> preorder(Node root) {
        if(root==null) return list;
        
        list.add(root.val);
        for(int i=0; i<root.children.size(); i++){
            preorder(root.children.get(i));
        }
        
        return list;
    }
}

class Solution {
    public boolean isAlienSorted(String[] words, String order) {
        
        for(int i=0; i<words.length-1; i++){
            if(!check(words[i], words[i+1], order))
                return false;
        }
        
        return true;
    }
    
    public boolean check(String s1, String s2, String order){
        for(int i=0; i<Math.min(s1.length(), s2.length()); i++){
            if(order.indexOf(s1.charAt(i))<order.indexOf(s2.charAt(i)))
                return true;
            if(order.indexOf(s1.charAt(i))>order.indexOf(s2.charAt(i)))
                return false;
        }
        
        return s1.length()<=s2.length();
    }
}

class UndergroundSystem {
    Map<Integer, Pair<String, Integer>> checkInMap = new HashMap<>();
    Map<String, Pair<Integer, Integer>> timeMap = new HashMap<>();
    public UndergroundSystem() {}
    public void checkIn(int id, String stationName, int t) {
        checkInMap.put(id, new Pair<>(stationName, t));
    }
    public void checkOut(int id, String stationName, int t) {
        Pair<String, Integer> checkIn = checkInMap.get(id);
        String stations = checkIn.getKey()+"-"+stationName;
        Pair<Integer, Integer> times = timeMap.getOrDefault(stations, new Pair<>(0, 0));
        int sum=(t-checkIn.getValue())+times.getKey();
        timeMap.put(stations, new Pair<>(sum, times.getValue()+1));
    }
    public double getAverageTime(String startStation, String endStation) {
        Pair<Integer, Integer> times = timeMap.get(startStation+"-"+endStation);
        return (double)times.getKey()/times.getValue();
    }
}