#medium
#N16. 3Sum Closest
problem link
#solution

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        int min=Integer.MAX_VALUE, res=-1000;
        Arrays.sort(nums);
        for(int i=0; i<nums.length-2; i++){
            int j=i+1, k=nums.length-1;
            while(j<k){
                int sum=nums[i]+nums[j]+nums[k];
                if(sum>=target) k--;
                else j++;
                if(Math.abs(sum-target)<min){
                    min=Math.abs(sum-target);
                    res=sum;
                }
            }
        }
        return res;
    }
}

#medium
#N19. Remove Nth Node From End of List
problem link
#solution

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode start = new ListNode();
        ListNode slow=start, fast=start;
        start.next=head;
        while(n-- +1 >0){
            fast=fast.next;
        }
        
        while(fast!=null){
            fast=fast.next;
            slow=slow.next;
        }
        slow.next=slow.next.next;
        return start.next;
    }
}

#hard
#N23. Merge k Sorted Lists
problem link
#solution

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists.length==0) return null;
        ListNode res=lists[0];        
        for(int i=1; i<lists.length; i++)
            res=merge(res, lists[i]);
        return res;
    }
    public ListNode merge(ListNode res, ListNode list){
        ListNode l1=new ListNode(0);
        ListNode head=l1;
        while(res!=null && list!=null){
            if(res.val<list.val){
                l1.next=res;
                res=res.next;
            }else{
                l1.next=list;
                list=list.next;
            }
            l1=l1.next;
        }
        while(res!=null){
            l1.next=res;
            res=res.next;
            l1=l1.next;
        }
        while(list!=null){
            l1.next=list;
            list=list.next;
            l1=l1.next;
        }
        return head.next;
    }
}

#medium
#N729. My Calendar I
problem link
#solution

class MyCalendar {
    Set<Pair<Integer, Integer>> set = new HashSet<>();
    public MyCalendar() {}
    public boolean book(int start, int end) {
        Pair<Integer, Integer> pair = new Pair<>(start, end);
        for(Pair<Integer, Integer> s: set){
            if(s.getKey() < end && start < s.getValue()){
                return false;
            }
        }
        set.add(pair);
        return true;
    }
}

#medium
#N1338. Reduce Array Size to The Half
problem link
#solution

class Solution {
    public int minSetSize(int[] arr) {
        int count=0, sum=0;
        Map<Integer, Integer> map = new HashMap<>();
        for(int n: arr){
            map.put(n, map.getOrDefault(n, 0) +1);
        }
        List<Map.Entry<Integer, Integer>> list = new LinkedList<>(map.entrySet());
        Collections.sort(list, (i1, i2) -> i2.getValue().compareTo(i1.getValue()));
        for (Map.Entry<Integer, Integer> aa : list) {
            sum+=aa.getValue();
            count++;
            if(sum>=arr.length/2){
                return count;
            }
        }
        return -1;
    }
}

#medium
#N38. Count and Say
problem link
#solution

class Solution {
    public String countAndSay(int n) {
        StringBuilder sb = new StringBuilder("1");
        StringBuilder temp = new StringBuilder();
        int sikl=2, count;
        while(sikl++<=n){
            count=1;
            for(int i=1; i<sb.length(); i++){
                if(sb.charAt(i-1)==sb.charAt(i)) count++;
                else{
                    temp.append(count).append(sb.charAt(i-1));
                    count = 1;
                }
            }
            temp.append(count).append(sb.charAt(sb.length()-1));
            sb=temp;
            temp = new StringBuilder();
        }
        return sb.toString();
    }
}

#medium
#N36. Valid Sudoku
problem link
#solution

class Solution {
    public boolean isValidSudoku(char[][] board) {
        boolean case1=true, case2=true, case3=true;
        Set<Character> set1 = new HashSet<>();
        Set<Character> set2 = new HashSet<>();
        Set<Character> set3 = new HashSet<>();
        for(int i=0; i<9; i++){ 
            for(int j=0; j<9; j++){ 
                if(board[i][j] != '.' && !set1.add(board[i][j])) return false;
                if(board[j][i] != '.' && !set2.add(board[j][i])) return false;
                if(board[3*(i/3)+j/3][3*(i%3)+j%3] != '.' && 
                   !set3.add(board[3*(i/3)+j/3][3*(i%3)+j%3])) return false;
            }
            set1 = new HashSet<>();
            set2 = new HashSet<>();
            set3 = new HashSet<>();
        }
        return true;
    }
}

#medium
#N34. Find First and Last Position of Element in Sorted Array
problem link
#solution

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int res[] = new int[2];
        res[0]=first(nums, target);
        res[1]=last(nums, target);
        return res;
    }
    public int first(int[] nums, int target){
        int idx=-1, l=0, r=nums.length-1, mid;
        while(l<=r){
            mid=l+(r-l)/2;
            if(nums[mid]==target) idx=mid;
            if(nums[mid]>=target) r=mid-1;
            else l=mid+1;
        }
        return idx;
    }
    public int last(int[] nums, int target){
        int idx=-1, l=0, r=nums.length-1, mid;
        while(l<=r){
            mid=l+(r-l)/2;
            if(nums[mid]==target) idx=mid;
            if(nums[mid]>target) r=mid-1;
            else l=mid+1;
        }
        return idx;
    }
}

#N2133. Check if Every Row and Column Contains All Numbers
problem link
#solution

class Solution {
    public boolean checkValid(int[][] matrix) {
        int n=matrix.length;
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();
        for(int i=0; i<n; i++){ 
            for(int j=0; j<n; j++){ 
                if(!set1.add(matrix[i][j]) || !set2.add(matrix[j][i])) return false;
            }
            set1 = new HashSet<>();
            set2 = new HashSet<>();
        }
        return true;
    }
}

#hard
#N37. Sudoku Solver
problem link
#solution

class Solution {
    public void solveSudoku(char[][] board) {
        solve(board);}
    public boolean solve(char[][] board){
        for(int i=0; i<9; i++){
            for(int j=0; j<9; j++){
                if(board[i][j]=='.'){
                    for(char k='1'; k<='9'; k++){
                        if(isValidSudoku(board, i, j, k)){
                            board[i][j]=k;
                            if(solve(board))return true;
                            else board[i][j]='.';
                        }
                    }return false;}}}return true;}
    public boolean isValidSudoku(char[][] board, int r, int c, char k) {
        for(int i=0; i<9; i++){ 
            if(board[r][i] != '.' && board[r][i] == k) return false;
            if(board[i][c] != '.' && board[i][c] == k) return false;
            if(board[3*(r/3)+i/3][3*(c/3)+i%3] != '.' 
               && board[3*(r/3)+i/3][3*(c/3)+i%3] == k) return false;
        }return true;}}

#medium
#N49. Group Anagrams
problem link
#solution

public List<List<String>> groupAnagrams(String[] strs) {
        Set<String> set=new HashSet<>();
        List<List<String>> res=new ArrayList<>();
        for(int i=0; i<strs.length; i++){
            if(!set.contains(strs[i])){
                set.add(strs[i]);
                List<String> temp = new ArrayList<>();
                temp.add(strs[i]);
                for(int j=i+1; j<strs.length; j++){
                    if(isAnagram(strs[i], strs[j]) || strs[i].equals(strs[j])){
                        temp.add(strs[j]);
                        set.add(strs[j]);}}
                res.add(temp);
            }}return res;}
    public boolean isAnagram(String s, String t) {
        if (s.length()!=t.length()) return false;
        int[] store=new int[26];
        for (int i=0; i<s.length(); i++) {
            store[s.charAt(i)-'a']++;
            store[t.charAt(i)-'a']--;
        }
        for (int n : store) if (n!=0) return false;
        return true;
    }

#medium
#N54. Spiral Matrix
problem link
#solution

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        int up=0, down=matrix.length-1, left=0, right=matrix[0].length-1;
        List<Integer> list = new ArrayList<>();
        while(up<=down && left<=right){
            for(int i=left; i<=right; i++)
                list.add(matrix[up][i]);
            up++;
            if(up>down || left>right) break;
            for(int i=up; i<=down; i++)
                list.add(matrix[i][right]);
            right--;
            for(int i=right; i>=left; i--)
                list.add(matrix[down][i]);
            down--;
            if(up>down || left>right) break;
            for(int i=down; i>=up; i--)
                list.add(matrix[i][left]);
            left++;
        }
        return list;
    }
}

#medium
#N59. Spiral Matrix II
problem link
#solution

class Solution {
    public int[][] generateMatrix(int n) {
        int num=1;
        int[][] mat = new int[n][n];
        int up=0, down=n-1, left=0, right=n-1;
        while(up<=down && left<=right){
            for(int i=left; i<=right; i++)
                mat[up][i]=num++;
            up++;
            if(up>down || left>right) break;
            for(int i=up; i<=down; i++)
                mat[i][right]=num++;
            right--;
            for(int i=right; i>=left; i--)
                mat[down][i]=num++;
            down--;
            if(up>down || left>right) break;
            for(int i=down; i>=up; i--)
                mat[i][left]=num++;
            left++;
        }
        return mat;
    }
}

#medium
#N985. Sum of Even Numbers After Queries
problem link
#solution

class Solution {
    public int[] sumEvenAfterQueries(int[] nums, int[][] queries) {
        int sum=0;
        for(int n: nums) if(n%2==0) sum+=n;
        int[] ans = new int[queries.length];
        for(int i=0; i<queries.length; i++){
            if((nums[queries[i][1]]+queries[i][0]) %2==0){
                if(nums[queries[i][1]]%2==0)
                    sum+=queries[i][0];
                else
                    sum+=nums[queries[i][1]]+queries[i][0];
            }else{
                if(nums[queries[i][1]] %2==0)
                    sum-=nums[queries[i][1]];
            }
            nums[queries[i][1]]+=queries[i][0];
            ans[i]=sum;
        }
        return ans;
    }
}

#medium
#N1680. Concatenation of Consecutive Binary Numbers
problem link
#solution

class Solution {
    public int concatenatedBinary(int n) {
        int digits=0;
        long res=0;
        
        for(int i=1; i<=n; i++){
            if((i&(i-1))==0) digits++;
            res=((res<<digits)+i)%1000000007;
        }
        return (int) res;
    }
}

#N101. Symmetric Tree
problem link
#solution

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return root==null||func(root.left, root.right);
    }
    public boolean func(TreeNode left, TreeNode right){
        if(left==null && right==null) return true;
        if(left==null ^ right==null || left.val!=right.val) return false;
        return func(left.left, right.right) && func(left.right, right.left);
    }
}

#N125. Valid Palindrome
problem link
#solution

class Solution {
    public boolean isPalindrome(String s) {
        for(int i=0, j=s.length()-1; i<j; ){
            char chari=s.charAt(i);
            char charj=s.charAt(j);
            if(!Character.isLetterOrDigit(chari)) {
                i++; continue;
            }
            if(!Character.isLetterOrDigit(charj)) {
                j--; continue;
            }
            if(Character.isLetterOrDigit(chari) && Character.isLetterOrDigit(charj) 
               && Character.toLowerCase(chari)!=Character.toLowerCase(charj)) return false;
            else{
                i++;j--;
            }
        }
        return true;
    }
}

#medium
#N8. String to Integer (atoi)
problem link
#solution

class Solution {
    public int myAtoi(String s) {
        if(s.contains("+-")||s.contains("-+")) return 0;
        int num=0;
        boolean isPos=true, isbrak=true;
        for(int i=0;i<s.length();i++){
            if(Character.isLetter(s.charAt(i)) || s.charAt(i)=='.' || (s.charAt(i)==' ')&&!isbrak) break;
            if(!isbrak && (s.charAt(i)=='-' || s.charAt(i)=='+')) break;
            if(s.charAt(i)=='+'||s.charAt(i)=='-') isbrak=false;
            if(Character.isDigit(s.charAt(i))){
                isbrak=false;
                int x=s.charAt(i)-'0';
                if(num>Integer.MAX_VALUE/10 || (num==Integer.MAX_VALUE/10 && x>7)){
                    return isPos?Integer.MAX_VALUE:-Integer.MAX_VALUE-1;
                }
                num=num*10+x;
            }
            if(s.charAt(i)=='-') isPos=false;
        }
        
        return isPos?num:-num;
    }
}

P.s.: F**k finally, after 28 submissions

#N118. Pascal's Triangle
problem link
#solution

class Solution {
    public List<List<Integer>> generate(int rows) {
        List<List<Integer>> list = new ArrayList<>();
        List<Integer> temp = new ArrayList<>();
        temp.add(1);
        list.add(temp);
        for(int i=2; i<=rows; i++){
            List<Integer> temp1 = new ArrayList<>();
            temp1.add(1);
            for(int j=1; j<list.get(i-2).size(); j++){
                temp1.add(list.get(i-2).get(j-1) + list.get(i-2).get(j));
            }
            temp1.add(1);
            list.add(temp1);
        }
        
        return list;
    }
}

#N2367. Number of Arithmetic Triplets
problem link
#solution

class Solution {
    public int arithmeticTriplets(int[] nums, int diff) {
        int count=0;
        Set<Integer> set = new HashSet<>();
        for(int n: nums) set.add(n);
        for(int i=0; i<nums.length; i++){
            if(set.contains(nums[i]+diff) && set.contains(nums[i]+2*diff)) count++;
        }
        return count;
    }
}

I liked new UI of leetcode.com ;)