#updated

class Solution {
    public String customSortString(String order, String s) {
        StringBuilder res=new StringBuilder();
        int[] arr=new int[26];
        
        for(int i=0; i<s.length(); i++){
            arr[s.charAt(i)-'a']++;
        }
        
        for(int i=0; i<order.length(); i++){
            while(arr[order.charAt(i)-'a']>0){
                res.append(order.charAt(i));
                arr[order.charAt(i)-'a']--;
            }
        }
        
        for(int i=0; i<26; i++){
            while(arr[i]>0){
                res.append((char) (i+'a'));
                arr[i]--;
            }
        }
        
        return res.toString();
    }
}

p.s.: better runtime than previous one)

#N1122. Relative Sort Array
problem link

#solution

class Solution {
    public int[] relativeSortArray(int[] arr1, int[] arr2) {
        int[] count=new int[1001];
        int[] res=new int[arr1.length];
        
        for(int i=0; i<arr1.length; i++){
            count[arr1[i]]++;
        }
        int index=0;
        for(int i=0; i<arr2.length; i++){
            while(count[arr2[i]] > 0){
                res[index]=arr2[i];
                index++;
                count[arr2[i]]--;
            }
        }
        
        for(int i=0; i<count.length; i++){
            if(count[i]!=0){
                while(count[i]>0){
                    res[index]=i;
                    index++;
                    count[i]--;
                }
            }
        }
        
        return res;
    }
}

#N441. Arranging Coins
problem link

#solution

class Solution {
    public int arrangeCoins(int n) {
        return ((int)(Math.pow((1+8*(long)n), 0.5))-1)/2;
    }
}

p.s. Yeah, math really helps to solve this kind of problems😅

#N1413. Minimum Value to Get Positive Step by Step Sum
problem link

#solution

class Solution {
    public int minStartValue(int[] nums) {
        int sum=0, minValue=0;
        
        for(int num:nums){
            sum+=num;
            minValue=Math.min(minValue, sum);
        }
        
        return 1-minValue;
    }
}

#N136. Single Number
problem link

#solution

class Solution {
    public int singleNumber(int[] nums) {
        int ans = 0;
        int len = nums.length;
        for(int i = 0; i != len; i++)
            ans ^= nums[i];
        
        return ans;

    }
}

p.s. good problem to understand XOR operator better)

#N1925. Count Square Sum Triples
problem link

#solution

class Solution {
    public int countTriples(int n) {
        int count = 0;
        for (int i = 1; i < n; i++){
            for (int j = i + 1; j < n; j++){
                int square = i * i + j * j;
                int c = (int) Math.sqrt(i * i + j * j);
                if (c <= n && c * c == square) count++;
            }
        }
        
        return count*2;
    }
}

#N1323. Maximum 69 Number
problem link

#solution

class Solution {
    public int maximum69Number (int num) {
        int first6=-1;
        int number=num;
        
        for(int i=1; num>0; i++){
            if(num%10==6){
                first6=i;
            }
            num/=10;
        }
        
        return number+3*(int)Math.pow(10, first6-1);
    }
}

#N66. Plus One
problem link

#solution

class Solution {
    public int[] plusOne(int[] digits) {
        int count=0;
        for(int i=0;i<digits.length; i++){
            if(digits[i]==9) count++;
        }
        if(digits[digits.length-1]!=9){
            digits[digits.length-1]=digits[digits.length-1]+1;
            return digits;
        }
        if(count!=digits.length){
            for(int i=digits.length-1; i>=0; i--){
                if(digits[i]>=9){
                    digits[i]=0; 
                }else{
                    digits[i]=digits[i]+1;
                    break;
                }
            }
        }else{
            int[] arr=new int[digits.length+1];
            arr[0]=1;
            for(int i=1; i<arr.length; i++){
                arr[i]=0;
            }
            return arr;
        }
        return digits;
    }
}

#N1290. Convert Binary Number in a Linked List to Integer
problem link

#solution

class Solution {
    public int getDecimalValue(ListNode head) {
        int num = head.val;
        while (head.next != null) {
            num = num * 2 + head.next.val;
            head = head.next;    
        }
        return num;

    }
}

#N876. Middle of the Linked List
problem link

#solution

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode temp=head;
        int length=0;
        while(temp!=null){
            temp=temp.next;
            length++;
        }
        
        for(int i=1; i<=length/2; i++)
            head=head.next;
        
        return head;
    }
}

#N237. Delete Node in a Linked List
problem link

#solution

class Solution {
    public void deleteNode(ListNode node) {
        node.val=node.next.val;
        node.next=node.next.next;
    }
}

p.s.: but the question is totally wrong), because the head node is not given

#N206. Reverse Linked List
problem link

#solution

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null) return head;
        ListNode prev=null, curr=head, after=head.next;
        
        while(curr.next.next!=null){
            curr.next=prev;
            prev=curr;
            curr=after;
            after=after.next;
        }
        
        curr.next=prev;
        after.next=curr;
        
        return after;
    }
}

#N21. Merge Two Sorted Lists
problem link

#solution

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode head = new ListNode();
        ListNode temp=head;
        
        while(l1!=null&&l2!=null){
            if(l1.val>=l2.val){
                temp.next=l2;
                l2=l2.next;
            }
            else{
                temp.next=l1;
                l1=l1.next;
            }
            temp=temp.next;
        }
        
        temp.next=(l1==null)?l2:l1;
        
        return head.next;
    }
}

#N1716. Calculate Money in Leetcode Bank
problem link

#solution

class Solution {
    public int totalMoney(int n) {
        return (n+1-5*(n/7))*(n-7*(n/7))/2+(49+(n/7)*7)*(n/7)/2;
    }
}

#statistics
Till this time, 118 in total,
109 easy;
9 medium;
type of problem solutions have been posted

#N868. Binary Gap
problem link

#solution

class Solution {
    public int binaryGap(int n) {
        int res=0, d=-30;
        
        while(n>0){
            if(n%2==1){
                res=Math.max(res, d);
                d=0;
            }
            n=n/2;
            d++;
        }
        
        return res;
    }
}

#N1518. Water Bottles
problem link

#solution

class Solution {
    public int numWaterBottles(int bottle, int exchange) {
        int count=0;
        
        while(bottle>0){
            count+=bottle-bottle%exchange;
            if(bottle>=exchange)
                bottle=bottle/exchange+bottle%exchange;
            else
                break;
        }
            
        return count+bottle;
    }
}

#medium

#N1833. Maximum Ice Cream Bars
problem link

#solution

class Solution {
    public int maxIceCream(int[] costs, int coins) {
        int count=0;
        Arrays.sort(costs);
        
        for(int i=0; i<costs.length&&coins>0; i++){
            if(costs[i]<=coins){
                coins-=costs[i];
                count++;
            }
        }
        return count;
    }
}

#N2032. Two Out of Three
problem link

#solution

class Solution {
    public List<Integer> twoOutOfThree(int[] nums1, int[] nums2, int[] nums3) {
        ArrayList<Integer> ans=new ArrayList<Integer>();
        int[] helper1=new int[101];
        int[] helper2=new int[101];
        int[] helper3=new int[101];
        
        for(int num:nums1)
            helper1[num]=1;
        
        for(int num:nums2)
            helper2[num]=1;
        
        for(int num:nums3)
            helper3[num]=1;
        
        for(int i=0; i<helper1.length; i++){
            if(helper1[i]+helper2[i]+helper3[i]>1)
                ans.add(i);
        }
        
        return ans;
    }
}

#N83. Remove Duplicates from Sorted List
problem link

#solution

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head==null) return head;
        ListNode curr=head;
        while(curr.next!=null){
            if(curr.val==curr.next.val){
                curr.next=curr.next.next;
            }
            else
                curr=curr.next;
        }
        
        return head;
    }
}