select distinct author_id as id from views where author_id=viewer_id order by author_id

select activity_date as day, count(distinct user_id) as active_users from activity
where datediff('2019-07-27', activity_date)<30
group by activity_date

select user_id, count(distinct follower_id) as followers_count
from followers group by user_id;

select actor_id, director_id 
from (select actor_id, director_id, count(*) as total from actordirector group by actor_id, director_id) as a where total>=3

class Solution {
    public int maxCoins(int[] piles) {
        int n=piles.length/3;
        int count=0;
        Arrays.sort(piles);
        for(int i=piles.length-2; n-- >0; i-=2){
            count+=piles[i];
        }
        return count;
    }
}

class Solution {
    public int[] deckRevealedIncreasing(int[] deck) {
        Deque<Integer> deque = new ArrayDeque<>();
        Arrays.sort(deck);
        for(int i=deck.length-1; i>=0; i--){
            if(deque.isEmpty()){
                deque.offer(deck[i]);
            }else{
                deque.offerFirst(deque.pollLast());
                deque.offerFirst(deck[i]);
            }
        }
        int ans[] = new int[deque.size()];
        for(int i=0; i<ans.length; i++){
            ans[i]=deque.poll();
        }
        return ans;
    }
}

class Solution {
    public boolean divideArray(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        for(int num: nums){
            map.put(num, map.getOrDefault(num, 0) +1);
        }
        for(Map.Entry<Integer, Integer> entry: map.entrySet()){
            if(entry.getValue()%2!=0) return false;
        }
        return true;
    }
}

class Solution {
    public int findTheWinner(int n, int k) {
        int cycle=n-1, curr=0, temp;
        int[] arr = new int[n];
        while(cycle-- >0){
            temp=0;
            while(temp<k){
                if(arr[curr%n]==0) temp++;
                if(temp<k) curr++;
            }
            arr[curr%n]++;
            curr++;
        }
        
        for(int i=0; i<arr.length; i++){
            if(arr[i]==0) return i+1;
        }
        return -1;
    }
}

class Solution {
    public String intToRoman(int num) {
        StringBuffer sb = new StringBuffer();
        String[] romans={"I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M"};
        int[] nums={1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000};
        for(int i=romans.length-1; i>=0; i--){
            while(num>=nums[i]){
                sb.append(romans[i]);
                num = num-nums[i];
            }
        }
        return sb.toString();
    }
}

class Solution {
    public int singleNumber(int[] nums) {
        Arrays.sort(nums);
        for(int i=1; i<nums.length-1; i+=3){
            if(nums[i-1]!=nums[i]) return nums[i-1];
        }
        return nums[nums.length-1];
    }
}

class Solution {
    public int[] singleNumber(int[] nums) {
        int single1=0, single2=0;
        boolean found=false;
        Map<Integer, Integer> map = new HashMap<>();
        for(int num: nums){
            map.put(num, map.getOrDefault(num, 0) +1);
        }
        for(Map.Entry<Integer, Integer> entry: map.entrySet()){
            if(entry.getValue()==1&&!found){
                single1=entry.getKey();
                found=true;
            }
            if(entry.getValue()==1&&found){
                single2=entry.getKey();
            }
        }
        return new int[]{single1, single2};
    }
}

class Solution {
    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
        ListNode head=list1;
        int diff=b-a;
        while(a-- > 1){
            list1=list1.next;
        }
        ListNode move=list1.next;
        list1.next=list2;
        while(diff-- >= 0){
            move=move.next;
        }
        while(list2.next!=null){
            list2=list2.next;
        }
        list2.next=move;
        
        return head;
    }
}

public class Solution extends GuessGame {
    public int guessNumber(int n) {
        int l=1, r=n, mid;
        while(l<=r){
            mid=l+(r-l)/2;
            if(guess(mid)==0) return mid;
            if(guess(mid)==1) l=mid+1;
            if(guess(mid)==-1) r=mid-1;
        }
        
        return l;
    }
}

class Solution {
    public void nextPermutation(int[] nums) {
        int i=nums.length-2, j=nums.length-1, temp;
        while(i>-1 && nums[i]>=nums[i+1])
            i--;
        if(i>=0){
            while(nums[i]>=nums[j])
            j--;
        
            temp=nums[i];
            nums[i]=nums[j];
            nums[j]=temp;
        }
        int k=nums.length-1;
        i++;
        while(i<k){
            temp=nums[i];
            nums[i]=nums[k];
            nums[k]=temp;
            i++; k--;
        }
    }
}

class Solution {
    public int findFinalValue(int[] nums, int original) {
        for(int i=0; i<nums.length; i++){
            if(nums[i]==original){
                return findFinalValue(nums, 2*original);
            }
        }
        return original;
    }
}

class Solution {
    public static List<List<String>> displayTable(List<List<String>> orders) {
        int table; String food;
        Map<Integer, TreeMap<String, Integer>> map = new TreeMap<>();
        Set<String> set = new TreeSet<>();
        for (List<String> order : orders) {
            table = Integer.parseInt(order.get(1));food = order.get(2);
            set.add(food);
            TreeMap<String, Integer> foodMap;
            if (map.get(table) == null) foodMap = new TreeMap<>();
            else foodMap = map.get(table);
            foodMap.put(food, foodMap.getOrDefault(food, 0) +1);
            map.put(table, foodMap);
        }

        List<List<String>> list = new ArrayList<>();
        List<String> temp = new ArrayList<>(); temp.add("Table");
        for (String s: set)
            temp.add(s);
        list.add(temp);
        for (Map.Entry<Integer, TreeMap<String, Integer>> entry: map.entrySet()){
            temp = new ArrayList<>();
            temp.add(String.valueOf(entry.getKey()));
            for (String s : set)
                temp.add(String.valueOf(entry.getValue().getOrDefault(s, 0)));
            list.add(temp);
        }
        return list;
    }
}

public List<String> subdomainVisits(String[] cpdomains) {
        Map<String, Integer> map = new HashMap<>(); String website, websites[]; int number; StringBuilder sb;
        for(String s: cpdomains){
            sb=new StringBuilder(); number=Integer.parseInt(s.split(" ")[0]);
            websites=s.split(" ")[1].split("\\.");
            for(int i=websites.length-1; i>0; i--){
                sb.insert(0, websites[i]);
                map.put(sb.toString(), map.getOrDefault(sb.toString(), 0) +number);
                sb.insert(0, ".");
            } sb.insert(0, websites[0]);
            map.put(sb.toString(), map.getOrDefault(sb.toString(), 0) +number);
        } List<String> list = new ArrayList<>();
        for(Map.Entry<String, Integer> entry: map.entrySet()){
            sb=new StringBuilder();
            sb.append(entry.getValue()).append(" ").append(entry.getKey());
            list.add(sb.toString());
        } return list;}

class Solution {
    public int percentageLetter(String s, char letter) {
        int count=0;
        for(char ch: s.toCharArray())
            if(ch==letter) count++;
        return count*100/s.length();
    }
}

class Solution {
    public void rotate(int[][] matrix) {
        int n=matrix.length, temp;
        for(int i=0; i<n/2; i++){
            for(int j=0; j<(n+1)/2; j++){
                temp=matrix[i][j];
                matrix[i][j]=matrix[n-1-j][i];
                matrix[n-1-j][i]=matrix[n-1-i][n-1-j];
                matrix[n-1-i][n-1-j]=matrix[j][n-1-i];
                matrix[j][n-1-i]=temp;
            }
        }
    }
}