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

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

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%

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

Runtime0 msBeats100%
Memory40 MBBeats62.93%

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p==null&&q==null) return true;
        if(p==null||q==null) return false;
        if(p.val!=q.val) return false;
        
        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }
}

Runtime2 msBeats88.7%
Memory40.4 MBBeats99.43%

class Solution {
    public String smallestEquivalentString(String s1, String s2, String base) {
        int[] graph = new int[26];
        for(int i=0; i<26; i++) graph[i]=i;
        for(int i=0; i<s1.length(); i++){
            int a1=s1.charAt(i)-'a';
            int a2=s2.charAt(i)-'a';
            int p1=find(graph, a1);
            int p2=find(graph, a2);
            if(p1<p2) graph[p2]=p1;
            else graph[p1]=p2;
        }
        StringBuilder sb = new StringBuilder();
        for(Character ch: base.toCharArray())
            sb.append((char)(find(graph, ch-'a')+'a'));
        return sb.toString();
    }
    public int find(int[] graph, int x){
        while(x!=graph[x])
            x=graph[x];
        return x;
    }
}

Runtime9 msBeats96.66%
Memory117.2 MBBeats89.51%

class Solution {
    public boolean validPath(int n, int[][] edges, int source, int destination) {
        int[] parents=new int[n];
        for(int i=0; i<n; i++) parents[i]=i;

        for(int[] edge: edges){
            int p1=find(parents, edge[0]);
            int p2=find(parents, edge[1]);
            
            if(p1<p2) parents[p2]=p1;
            else parents[p1]=p2;
        }

        return find(parents, source) == find(parents, destination);
    }
    public int find(int[] parents, int x){
        while(x!=parents[x]){
            x=parents[x];
        }
        return x;
    }
}

Runtime9 msBeats90.97%
Memory42.1 MBBeats44.5%

class Solution {
    public int countQuadruplets(int[] nums) {
        int res=0, l=nums.length;
        Map<Integer, Integer> count = new HashMap<>();
        count.put(nums[l-1]-nums[l-2], 1);
        for(int b=l-3; b>=1; b--){
            for(int a=b-1; a>=0; a--){
                res+=count.getOrDefault(nums[b]+nums[a], 0);
            }
            for(int d=l-1; d>b; d--){
                count.put(nums[d]-nums[b], count.getOrDefault(nums[d]-nums[b], 0) +1);
            }
        }
        return res;
    }
}

class Solution {
    public boolean canPlaceFlowers(int[] f, int n) {
        int l = f.length;
        if(n==0) return true;
        if(l==1) return f[0]==0 && n == 1;

        for(int i=0; i<l; i++){
            if(i==0 && f[0] + f[1] == 0) {
                n--;
                i++;
            }
            else if(i==l-1 && f[l-1] + f[l-2]==0) {
                n--;
                i++;
            }
            else if(i>0 && i<l-1 && f[i]+f[i-1]+f[i+1]==0){
                n--;
                i++;
            }
        }
        return n<=0;
    }
}

class Solution {
    public String reverseVowels(String s) {
        String vowels = "aeiouAEIOU";
        char[] arr = s.toCharArray();
        for(int i=0, j=arr.length-1; i<j; ){
            if(vowels.contains(""+arr[i]) && vowels.contains(""+arr[j])){
                char temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
                i++;
                j--;
            }
            else if(vowels.contains(""+arr[i])) j--;
            else if(vowels.contains(""+arr[j])) i++;
            else{
                i++;
                j--;
            }
        }
        return new String(arr);
    }
}

class Solution {
    public String reverseWords(String s) {
        String[] arr = s.split("\\s+");
        for(int i = 0, j = arr.length-1; i<j; ){
            if(arr[i].equals("")){
                i++; continue;
            }
            if(arr[j].equals("")){
                j--; continue;
            }
            String temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++; j--;
        }
        StringBuilder sb = new StringBuilder();
        for(String ss: arr) {
            if(!ss.equals("")) sb.append(ss).append(" ");
        }
        return sb.toString().trim();
    }
}

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int n = nums.length;
        int arr[] = new int[n];
        int left[] = new int[n];
        arr[0] = left[n-1] = 1;
        for(int i=1; i<n; i++){
            arr[i] = arr[i-1]*nums[i-1];
        }
        for(int i=n-2; i>-1; i--){
            left[i] = left[i+1]*nums[i+1];
        }
        for(int i=0; i<n; i++){
            arr[i]*=left[i];
        }
        return arr;
    }
}

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int small = Integer.MAX_VALUE, mid = Integer.MAX_VALUE;
        for(int n: nums){
            if(n<=small) small = n;
            else if(n<=mid) mid = n;
            else return true;
        }
        return false;
    }
}

class Solution {
    public int compress(char[] chars) {
        String s;
        StringBuilder sb = new StringBuilder();
        int count=1;
        for(int i=1; i<chars.length; i++){
            if(chars[i]==chars[i-1]){
                count++;
            }else{
                sb.append(chars[i-1]);
                if(count!=1) sb.append(count);
                count=1;
            }
        }
        
        sb.append(chars[chars.length-1]);
        if(count!=1) sb.append(count);
        s=sb.toString();
        for(int i=0; i<s.length(); i++){
            chars[i]=s.charAt(i);
        }
        return s.length();
    }
}

class Solution {
    public List<String> summaryRanges(int[] nums) {
        List<String> list = new ArrayList<>();
        if(nums.length==0) return list;
        int a=nums[0], b=nums[0];
        for(int i=1; i<nums.length; i++){
            if(nums[i]-nums[i-1]==1){
                b=nums[i];
            }else{
                if(a!=b) list.add(a+"->"+b);
                else list.add(""+a);
                a=nums[i];
                b=nums[i];
            }
        }
        if(a!=b) list.add(a+"->"+b);
        else list.add(""+a);
        return list;
    }
}

algorithm Sieve of Eratosthenes is
    input: an integer n > 1.
    output: all prime numbers from 2 through n.

    let A be an array of Boolean values, indexed by integers 2 to n,
    initially all set to true.
    
    for i = 2, 3, 4, ..., not exceeding √n do
        if A[i] is true
            for j = i2, i2+i, i2+2i, i2+3i, ..., not exceeding n do
                set A[j] := false

    return all i such that A[i] is true.

Time - O(nloglogn)

Example problem: https://leetcode.com/problems/closest-prime-numbers-in-range/description

   public static boolean isUnique(String s) {
        int[] arr = new int[128];
        for (int i=0; i<s.length(); i++) {
            int idx = s.charAt(i) - 'a';
            if (arr[idx] == 1) return false;
            arr[idx]++;
        }
        return true;
    }
    TC - O(c)
    SC - O(1)

 public static boolean isUnique2(String s) {
        int bits = 0;
        for (int i=0; i<s.length(); i++) {
            int idx = s.charAt(i) - 'a';
            if ((bits & (1 << idx)) > 0) {
                return false;
            }
            bits |= (1 << idx);
        }
        return true;
    }
    TC - O(c)
    SC - O(1)

    public static boolean f1(String s) {
        Map<Character, Integer> map = new HashMap<>();
        int oddFrequencies = 0;
        for (char ch : s.toCharArray()) {
            if (!Character.isLetter(ch)) continue;
            ch = Character.toLowerCase(ch);
            map.put(ch, map.getOrDefault(ch, 0) + 1);
            if (map.get(ch) % 2 != 0) oddFrequencies++;
            else oddFrequencies--;
        }
        return oddFrequencies <= 1;
    }
    // TC - O(n)
    // SC - O(n)

    public static boolean f2(String s) {
        int bits = 0;
        for (char ch : s.toCharArray()) {
            if (!Character.isLetter(ch)) continue;
            int k = Character.toLowerCase(ch) - 'a';
            bits ^= (1 << k);
        }
        return bits == 0 || (bits & (bits - 1)) == 0;
    }
    // TC - O(n)
    // SC - O(1)

class Solution {
    public int maxOperations(int[] nums, int k) {
        int count = 0;
        Map<Integer, Integer> map = new HashMap<>();
        for(int n: nums){
            if(map.containsKey(n)){
                count++;
                map.put(n, map.get(n) -1);
                if(map.get(n)==0) map.remove(n);
            }else if(n<k){
                map.put(k-n, map.getOrDefault(k-n, 0) +1);
            }
        }
        return count;
    }
}