#N1431 Kids With the Greatest Number of Candies
problem link=>https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/

class Solution {
    public List<Boolean> kidsWithCandies(int[] candies, int extra) {
        ArrayList<Boolean> ans = new ArrayList<Boolean>();
        int max=0;
        for(int candy: candies){
            max=Math.max(candy, max);
        }
        for(int candy: candies){
            ans.add(candy+extra>=max);
        }
        
        return ans;
    }
}

#N1920 Build Array from Permutation
problem link=>https://leetcode.com/problems/build-array-from-permutation/

class Solution {
    public int[] buildArray(int[] nums) {
        int[] ans=new int[nums.length];
        for(int i=0; i<nums.length; i++){
            ans[i]=nums[nums[i]];
        }
        return ans;
    }
}

#N1929 Concatenation of Array
problem link=>https://leetcode.com/problems/concatenation-of-array/

class Solution {
    public int[] getConcatenation(int[] nums) {
        int[] ans=new int[nums.length * 2];
        for(int i=0; i<nums.length; i++){
            ans[i]=nums[i];
            ans[i+nums.length]=nums[i];
        }
        return ans;
    }
}

#N1313 Decompress Run-Length Encoded List
problem link=>https://leetcode.com/problems/decompress-run-length-encoded-list/

#solution

class Solution {
    public int[] decompressRLElist(int[] nums) {
        int size=0;
        for(int i=0; i<nums.length; i+=2){
            size+=nums[i];
        }
        int[] ans=new int[size];
        for(int i=0, ix=0; i<nums.length; i+=2){
            for(int j=0; j<nums[i]; j++){
                ans[ix++]=nums[i+1];
            }
        }
        return ans;
    }
}

#N1773 Count Items Matching a Rule
problem link=>https://leetcode.com/problems/count-items-matching-a-rule/

#solution

class Solution {
    public int countMatches(List<List<String>> items, String ruleKey, String ruleValue) {
        int key, count=0;
        if(ruleKey.equals("type"))
            key=0;
        else if(ruleKey.equals("color"))
            key=1;
        else
            key=2;
        
        for(int i=0; i<items.size(); i++){
            if(items.get(i).get(key).equals(ruleValue))
                count++;
        }
        
        return count;
    }
}

#N2006 Count Number of Pairs With Absolute Difference K
problem link=>https://leetcode.com/problems/count-number-of-pairs-with-absolute-difference-k/

#solution

class Solution {
    public int countKDifference(int[] nums, int k) {
        int count=0;
        int[] helper=new int[101];
        for (int n:nums)
            helper[n]++;
        for (int i=k+1; i<101; i++)
            count+=helper[i]*helper[i-k];
        
        return count;
    }
}

Best Solution ever for me)😃

#2011 Final Value of Variable After Performing Operations
problem link=>https://leetcode.com/problems/final-value-of-variable-after-performing-operations/

#solution

class Solution {
    public int finalValueAfterOperations(String[] operations) {
        int x=0;
        for(int i=0; i<operations.length; i++){
            if(operations[i].contains("++")){
                x++;
            }
            if(operations[i].contains("--")){
                x--;
            }
        }
        return x;
    }
}

#N1588 Sum of All Odd Length Subarrays
problem link=>https://leetcode.com/problems/sum-of-all-odd-length-subarrays/

#solution

class Solution {
    public int sumOddLengthSubarrays(int[] arr) {
        int res=0;
        for(int i=0; i<arr.length; i++){
            int start=arr.length-i;
            int end=i+1;
            if(start*end%2==1)
                res+=(start*end+1)/2 * arr[i];
            else
                res+=(start*end)/2 * arr[i];
        }
        return res;
    }
}

#N1662 Check If Two String Arrays are Equivalent
problem link=>https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent/

#solution

class Solution {
    public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
        String str1="", str2="";
        for(int i=0; i<Math.max(word1.length, word2.length); i++){
            if(i<word1.length)
                str1+=word1[i];
            if(i<word2.length)
                str2+=word2[i];
        }
        return str1.equals(str2);
    }
}

#N1684 Count the Number of Consistent Strings
problem link=>https://leetcode.com/problems/count-the-number-of-consistent-strings/

#solution

class Solution {
    public int countConsistentStrings(String allowed, String[] words) {
        int count = 0;
        for (String s : words) {
            boolean isValid = true;
            for (char ch : s.toCharArray()) {
                if (!allowed.contains(String.valueOf(ch))) {
                    isValid = false;
                }
            }
            if (isValid) count++;
        }
        return count;
    }
}

#N1913 Maximum Product Difference Between Two Pairs
problem link=>https://leetcode.com/problems/maximum-product-difference-between-two-pairs/

#solution

class Solution {
    public int maxProductDifference(int[] nums) {
        int largest = 0, largest2 = 0, smallest = Integer.MAX_VALUE, smallest2 = Integer.MAX_VALUE;
     for(int i=0;i<nums.length;i++) {
  if(nums[i]>=largest) {
   largest2 = largest;
   largest = nums[i];
  } else if(nums[i]>largest2) largest2 = nums[i];
  if(nums[i]<=smallest) {
   smallest2 = smallest;
   smallest = nums[i];
  } else if(nums[i]<smallest2) smallest2 = nums[i];
 }
 return largest * largest2 - smallest * smallest2;
    }
}

#N1816 Truncate Sentence
problem link=>https://leetcode.com/problems/truncate-sentence/

#solution

class Solution {
    public String truncateSentence(String s, int k) {
        s=s+" ";
        String res="";
        int start=0;
        for(int i=0; i<s.length(); i++){
            if(s.charAt(i)==' '&&k>0){
                res+=s.substring(start, i);
                start=i;
                k--;
            }
        }
        
        return res;
    }
}

#N1534 Count Good Triplets
problem link=>https://leetcode.com/problems/count-good-triplets/

#solution

class Solution {
    public int countGoodTriplets(int[] arr, int a, int b, int c) {
        int count=0;
        for(int i=0; i<arr.length-2; i++){
            for(int j=i+1; j<arr.length-1; j++){
                if(Math.abs(arr[i]-arr[j])>a) continue;
                for(int k=j+1; k<arr.length; k++){
                    if(Math.abs(arr[j]-arr[k])<=b&&Math.abs(arr[i]-arr[k])<=c)
                        count ++;
                }
            }
        }
        
        return count;
    }
}

#N1979 Find Greatest Common Divisor of Array
problem link=>https://leetcode.com/problems/find-greatest-common-divisor-of-array/

#solution

class Solution {
    public int findGCD(int[] nums) {
        int min=1000, max=1, gcd=1;
        for(int eachNums: nums){
            max=Math.max(max, eachNums);
            min=Math.min(min, eachNums);
        }
        for(int i=1; i<=min; i++){
            if(min%i==0&&max%i==0)
                gcd=i;
        }
        return gcd;
    }
}

#N804 Unique Morse Code Words
problem link=>https://leetcode.com/problems/unique-morse-code-words/

#solution

class Solution {
    public int uniqueMorseRepresentations(String[] words) {
        String[] morseAlphabet={".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};
        String morse="";
        for(int i=0; i<words.length; i++){
            morse="";
            for(char ch:words[i].toCharArray()){
                morse+=morseAlphabet[ch-'a'];
            }
            words[i]=morse;
        }
        Arrays.sort(words);
        int count=words.length;
        for(int i=0; i<words.length-1; i++){
            if(words[i].equals(words[i+1]))
                count--;
        }
        
        return count;
    }
}

#N1266 Minimum Time Visiting All Points
problem link=>https://leetcode.com/problems/minimum-time-visiting-all-points/

#solution

class Solution {
    public int minTimeToVisitAllPoints(int[][] points) {
        int time=0;
        for(int i=0; i<points.length-1; i++){
            int max=Math.max(Math.abs(points[i][0]-points[i+1][0]), Math.abs(points[i][1]-points[i+1][1]));
            time+=max;   
        }
        return time;
    }
}

#N832 Flipping an Image
problem link=>https://leetcode.com/problems/flipping-an-image/

#solution

class Solution {
    public int[][] flipAndInvertImage(int[][] image) {
        int n = image.length;
        for (int[] row : image)
            for (int i = 0; i * 2 < n; i++)
                if (row[i] == row[n - i - 1])
                    row[i] = row[n - i - 1] ^= 1;
        return image;
    }
}

#N1732 Find the Highest Altitude
problem link=>https://leetcode.com/problems/find-the-highest-altitude/

#solution

class Solution {
    public int largestAltitude(int[] gain) {
        int max=0, altitude=0;
        for(int i=0; i<gain.length; i++){
            altitude+=gain[i];
            gain[i]=altitude;
            max=Math.max(max, gain[i]);
        }
        
        return max;
    }
}

#N1725 Number Of Rectangles That Can Form The Largest Square
problem link=>https://leetcode.com/problems/number-of-rectangles-that-can-form-the-largest-square/

#solution

class Solution {
    public int countGoodRectangles(int[][] rectangles) {
        int max=0, count=0, side;
        for(int i=0; i<rectangles.length; i++){
            side=Math.min(rectangles[i][0], rectangles[i][1]);
            if(side>max){
                count=1;
                max=side;
            }else if(side==max)
                count++;
        }
        
        return count;
    }
}