#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 ;)

#N205. Isomorphic Strings
problem link
#solution

class Solution {
    public boolean isIsomorphic(String s, String t) {
        Map<Character, Character> map = new HashMap<>();
        Map<Character, Character> map1 = new HashMap<>();
        for(int i=0; i<s.length(); i++){
            if(map.containsKey(s.charAt(i)) && map.get(s.charAt(i))!=t.charAt(i)
              || map1.containsKey(t.charAt(i)) && map1.get(t.charAt(i))!=s.charAt(i)){
                return false;
            }else if(!map.containsKey(s.charAt(i))){
                map.put(s.charAt(i), t.charAt(i));
                map1.put(t.charAt(i), s.charAt(i));
            }
        }
        return true;
    }
}

Runtime 13 ms Beats 95.50%
Memory 46.2 MB Beats 91.49%

#N703. Kth Largest Element in a Stream
problem link
#solution

class KthLargest {
    int k;
    PriorityQueue<Integer> pq;
    public KthLargest(int k, int[] nums) {
        pq=new PriorityQueue<>();
        for(int n: nums) pq.offer(n);
        this.k=k;
        while(pq.size()>k) pq.poll();
    }
    
    public int add(int val) {
        pq.offer(val);
        if(pq.size()>k) pq.poll();
        return pq.peek();
    }
}

Runtime 2 ms Beats 81.30% Memory 41.9 MB Beats 88.62%

#N883. Projection Area of 3D Shapes
problem link
#solution

class Solution {
    public int projectionArea(int[][] grid) {
        int xy=0, yz=0, zx=0, max=0;

        for(int i=0; i<grid.length; i++){
            for(int j=0; j<grid[0].length; j++){
                if(grid[i][j]!=0) xy++;
                max=Math.max(max, grid[i][j]);
            }
            zx+=max;
            max=0;
        }
        for(int i=0; i<grid[0].length; i++){
            for(int j=0; j<grid.length; j++)
                max=Math.max(max, grid[j][i]);
            yz+=max;
            max=0;
        }

        return xy+yz+zx;
    }
}

Runtime 3 ms Beats 99.42%
Memory 42.1 MB Beats 97.7%

#N2500. Delete Greatest Value in Each Row
problem link
#solution

class Solution {
    public int deleteGreatestValue(int[][] grid) {
        int m=grid.length, n=grid[0].length;
        int sum=0, max=0;
        for(int i=0; i<m; i++) Arrays.sort(grid[i]);
        
        for(int i=n-1; i>=0; i--){
            max=0;
            for(int j=0; j<m; j++){
                if(grid[j][i]>max) max=grid[j][i];
            }
            sum+=max;
        }
        return sum;
    }
}

Runtime 1 ms Beats 98.18%
Memory 40.9 MB Beats 82%

#N2283. Check if Number Has Equal Digit Count and Digit Value
problem link
#solution

class Solution {
    public boolean digitCount(String num) {
        Map<Integer, Integer> map = new HashMap<>();
        for(char c: num.toCharArray()){
            int n=c-'0';
            map.put(n, map.getOrDefault(n, 0) +1);
        }

        for(int i=0; i<num.length(); i++){
            if(!map.containsKey(i) && num.charAt(i)!='0' 
            || map.containsKey(i) && map.get(i)!=num.charAt(i)-'0') return false;
        }
        return true;
    }
}

Runtime16 msBeats61.69%
Memory41.4 MBBeats66.23%

#N1399. Count Largest Group
problem link
#solution

class Solution {
    public int countLargestGroup(int n) {
        Map<Integer, Integer> map = new HashMap<>();
        int count=0, max=0;
        int[] dp = new int[n+1];
        
        for(int i=1; i<=n; i++){
            dp[i]=dp[i/10]+i%10;
            map.put(dp[i], map.getOrDefault(dp[i], 0) +1);
            if(map.get(dp[i])>max){
                count=0;
                max=map.get(dp[i]);
            }
            if(map.get(dp[i])==max) count++;
        }
        return count;
    }
}

#note
Useful way to find sum of digits from 1 to n

dp[i]=dp[i/10]+i%10;

#N2481. Minimum Cuts to Divide a Circle
problem link
#solution

class Solution {
    public int numberOfCuts(int n) {
        return (n==1?0:n/(2-n%2));
    }
}

#note
If we want to look through all subsets of array:

int n=arr.length;
for(int i=0; i<(1<<n); i++){
    for(int j=0; j<n; j++){
        if((i&(1<<j))>0){
            System.out.println(arr[j]+"  ");
        }
    }
}

I know this is not a big result.😀
I just wanted to share like others😅

Little achievement from Leetcode

Runtime1 msBeats95.21%
Memory40.3 MBBeats73.73%

#N290. Word Pattern
problem link
#solution

class Solution {
    public boolean wordPattern(String pattern, String s) {
        Map<Character, String> map = new HashMap<>();
        int i=0;
        for(String part: s.split(" ")){
            if(i==pattern.length()||map.containsKey(pattern.charAt(i)) && !map.get(pattern.charAt(i)).equals(part)
            ||map.containsValue(part) && get(map, part)!=pattern.charAt(i))
                return false;

            map.put(pattern.charAt(i), part);
            i++;
        }

        return i==pattern.length();
    }
    public char get(Map<Character, String> map, String part){
        for (Map.Entry<Character, String> entry : map.entrySet()) {
            if (entry.getValue().equals(part)) {
                return entry.getKey();
            }
        }
        return '0';
    }
}

Runtime11 msBeats98.9%
Memory51.3 MBBeats99.48

#N2244. Minimum Rounds to Complete All Tasks
problem link
#solution

class Solution {
    public int minimumRounds(int[] tasks) {
        Arrays.sort(tasks);
        int l=tasks.length;
        if(l>1 && tasks[l-2]!=tasks[l-1]) return -1;
        int r=0, type=tasks[0], count=0;
        

        for(int i=0; i<l; i++){
            if(type==tasks[i]) count++;
            if(type!=tasks[i] || i==l-1){
                type=tasks[i];
                if(count==1) return -1;
                else r+=count/3 + (count%3+count%3%2)/2;
                count=1;
            }
        }
        return r;
    }
}

Runtime70 msBeats76.84%
Memory80 MBBeats68.31%

#N452. Minimum Number of Arrows to Burst Balloons
problem link
#solution

class Solution {
    public int findMinArrowShots(int[][] points) {
        int n=points.length;
        //Arrays.sort(points, Comparator.comparingInt(o -> o[0]));
        Arrays.sort(points, (a, b) -> Integer.compare(a[0], b[0]));
        int l=points[0][0], r=points[0][1], count=1;
        for(int i=0; i<n; i++){
            if(points[i][0]>r || points[i][1]<l){  // not cross
                l=points[i][0];
                r=points[i][1];
                count++;
            }else{
                l=Math.max(l, points[i][0]);
                r=Math.min(r, points[i][1]);
            }
        }
        return count;
    }
}