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

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

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

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