class Solution {
    public int countPairs(int[] nums, int k) {
        int count=0;
        for(int i=0; i<nums.length-1; i++){
            for(int j=i+1; j<nums.length; j++){
                if(nums[i]==nums[j] && i*j%k==0)
                    count++;
            }
        }
        
        return count;
    }
}

class Solution {
    public List<Boolean> checkArithmeticSubarrays(int[] nums, int[] l, int[] r) {
        List<Boolean> list = new ArrayList<>();
        
        for(int i=0; i<l.length; i++){
            int temp[] = new int[r[i]-l[i]+1];
            for(int j=l[i]; j<=r[i]; j++){
                temp[j-l[i]]=nums[j];
            }
            Arrays.sort(temp);
            list.add(check(temp));
        }
        
        return list;
    }
    public boolean check(int[] arr){
        for(int i=1; i<arr.length-1; i++){
            if(arr[i]*2!=arr[i-1]+arr[i+1])
                return false;
        }
        
        return true;
    }
}

class Solution {
    public int prefixCount(String[] words, String pref) {
        int count=0;
        
        for(String word: words){
            if(word.startsWith(pref))
                count++;
        }
        
        return count;
    }
}

class Solution {
    public int countOperations(int num1, int num2) {
        int count=0;
        while(num1*num2!=0){
            if(num1<num2)
                num2-=num1;
            else
                num1-=num2;
            
            count++;
        }
        
        return count;
    }
}

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;
    }
}