DEV Community: Jerin

LeetCode 747 in Java: Largest Number At Least Twice of Others Explained

Jerin — Sun, 24 May 2026 15:02:08 +0000

Difficulty: Easy
Topics: Array, Sorting
Platform: Leetcode

Problem Statement

You are given an integer array nums where the largest integer is unique.
Determine whether the largest element in the array is at least twice as much as every other number in the array. If it is, return the index of the largest element, or return -1 otherwise.
Problem Statement Simplified
Check if the largest didgit is twice the other

Mistakes and Learning

Started working on it with the assumption to check if the largest number is twice - but the problem is atleast twice.

Example 1

Input: nums = [3,6,1,0]
Output: 1
Explanation: 6 is the largest integer.
For every other number in the array x, 6 is at least twice as big as x.
The index of value 6 is 1, so we return 1.

Example 2

Input: nums = [1,2,3,4]
Output: -1
Explanation: 4 is less than twice the value of 3, so we return -1.
Key Insight
Check the largest number
Check if it is atleast twice the other
If yes then return the index 
If no then return -1

Algorithm

Copy nums array to another array.
Sort the new array.
Check if the largest is atleast twice the second largest
5If yes then loop through the nums array
Check if nums[i]==largest in new array.
Return i;
End if
End loop
End if
Else return -1.

Algorithm in simple words

Copy the nums array to another array to preserve the original index.
Then sort the new array, and check of the largest of new array is atleast twice the second largest array, if yes then loop through the nums array and find the original index of that largest array.
If the largest is not atleast twice the second largest then return -1.

Java code

class Solution {
    public int dominantIndex(int[] nums) {
        int [] arr = Arrays.copyOf(nums, nums.length);
        Arrays.sort(arr);
        int index=0;
        int secondLargest=arr[arr.length-2];
        if(arr[arr.length-1]>=2*secondLargest){
            for(int i=0;i<nums.length;i++){
                if(nums[i]==arr[arr.length-1]){
                    index=i;
                }
            }
        }
        else{
            index=-1;
        }       
        return index;
    }
}

Time & Space Complexity

Time Complexity: O(nlogn)
Space Complexity: O(n)

LeetCode 228: Summary Ranges Solution in Java (Time: O(n))

Jerin — Wed, 13 May 2026 14:11:33 +0000

Difficulty: Easy

Topics: Array

Platform: Leetcode

Problem Statement

You are given a sorted unique integer array nums.

A range [a,b] is the set of all integers from a to b (inclusive).

Return the smallest sorted list of ranges that cover all the numbers in the array exactly. That is, each element of nums is covered by exactly one of the ranges, and there is no integer x such that x is in one of the ranges but not in nums.
Each range [a,b] in the list should be output as:

"a->b" if a != b
"a" if a == b

Problem Statement Simplified

Get back the range of continuous numbers in the array.

Mistakes and Learning

Forgot to check for the leftover at the end of the for loop — always need to check the end-of-data scenario.
Forgot to check if nums. length is 0 or not—always need to check if the nums array has any element in it.

Example 1

Input: nums = [0,1,2,4,5,7]
Output: ["0->2","4->5","7"]
Explanation: The ranges are:
[0,2] --> "0->2"
[4,5] --> "4->5"
[7,7] --> "7"

Example 2

Input: nums = [0,2,3,4,6,8,9]
Output: ["0","2->4","6","8->9"]
Explanation: The ranges are:
[0,0] --> "0"
[2,4] --> "2->4"
[6,6] --> "6"
[8,9] --> "8->9"

Key Insight

If the array is not empty, loop through it.
While i+1 is less than nums.length and nums[i+1] equals nums[i+1]+1, then i++.
Else, add to the list.

Algorithm

Initialize a list to store the range.
Check if the nums is empty if yes then return list.
Loop through the nums.
Initialize a start variable and assign nums[i] to it.
while i+1 is less than nums.length and nums[i] equals num[i]+1.
Then i++.
End while.
If start is not equal to nums[i] then add first -> nums[i] to the list.
Else, convert to string value and add to list
End if.
End for.
Return list.

Algorithm in simple words

First, initialize a list to store the range, then check if nums is empty if empty, then return the list else we can continue.

Loop through the nums and assign the current value to an int, start. While i+1 is less than total length and nums[i]=nums[i]+1, then i++, ie goto the next value, because this is a continuous number.

So when nums[i] != nums[i]+1 or have reached the end of the array, we will check if start!=num[i] — that means to check if start and current value is same or not; if they are not the same, then add start + "->" + nums[i] to the list

If they are same, then convert the int to a string and add to the list. And return the list.

Java code

class Solution {
    public List<String> summaryRanges(int[] nums) {

        List <String> result= new ArrayList<>();
        if(nums.length==0){
            return result;
        }
    for(int i=0;i<nums.length;i++){
       int start= nums[i];
       while(i+1<nums.length && nums[i+1]==nums[i]+1){
        i++;
       }
       if(start!=nums[i]){
        result.add(start+"->"+nums[i]);
       }
       else{
        result.add(String.valueOf(start));
       }
    }return result;
    }
}

Time & Space Complexity

Time Complexity: O(n)

Space Complexity: O(n)

Solving LeetCode 414 Third Maximum Number: A Streamlined Java Approach

Jerin — Tue, 12 May 2026 15:36:14 +0000

Difficulty: Easy

Topics: Array, Sorting

Platform: Leetcode

Problem Statement

Given an integer array nums, return the third distinct maximum number in this array. If the third maximum does not exist, return the maximum number.

Problem Statement Simplified

Give back the 3rd largest number from the array if it exists, else give back the largest number.

Mistakes and Learning

Confusing over the array indexing and length—array indexing starts at 0 and length starts at 1, always forget that.

Example 1

Input: nums = [3,2,1]
Output: 1
Explanation:
The first distinct maximum is 3.
The second distinct maximum is 2.
The third distinct maximum is 1.

Example 2

Input: nums = [1,2]
Output: 2
Explanation:
The first distinct maximum is 2.
The second distinct maximum is 1.
The third distinct maximum does not exist, so the maximum (2) is returned instead.

Key Insight

Sort the array.
Get the unique array.
If less than 3, then return the largest.
Else return the nums.length - 3.

Algorithm

Sort the array.
Initialize an array to store the unique array, using stream , distinct operation and toArray to make it into an array.
If the array length is less than 3 then return the last digit of the array.
Else return the element in total length-3.
End if.

Algorithm in simple words

Fisrt sort the array in ascending order to get the elements in order. Then find out the duplicating element using distinct() operation and discard it.
Then using an if statment check if the array length is less than 3 , if yes then return the last digit which will be the largest digit.

If greater than 3 then return the element in total length-3 that will be the 3rd largest digit.

Java code

class Solution {
    public int thirdMax(int[] nums) {
        Arrays.sort(nums);
        int[] uniqueArr= Arrays.stream(nums).distinct().toArray();
        if(uniqueArr.length<3){
            return uniqueArr[uniqueArr.length-1];
        }
        else{
            return uniqueArr[uniqueArr.length-3];
        }
    }
}

Time & Space Complexity

Time Complexity: O(nlogn)

Space Complexity: O(n)

Solving LeetCode 2553: Separate the Digits in an Array using Java

Jerin — Mon, 11 May 2026 14:44:14 +0000

Difficulty: Easy
Topics: Array, Simulation
Platform: Leetcode

Problem Statement

Given an array of positive integers nums, return an array answer that consists of the digits of each integer in nums after separating them in the same order they appear in nums.
To separate the digits of an integer is to get all the digits it has in the same order.
For example, for the integer 10921, the separation of its digits is [1,0,9,2,1].

Problem Statement Simplified

Deconstruct each digits in nums array and return inorder in answer array.
Mistakes and Learning
Added the modules value to final array list without reversing it - Learned: Created another arraylist and added the values to it and then reversed and added to the main arraylist

Example 1

Input: nums = [13,25,83,77]
Output: [1,3,2,5,8,3,7,7]
Explanation: 
- The separation of 13 is [1,3].
- The separation of 25 is [2,5].
- The separation of 83 is [8,3].
- The separation of 77 is [7,7].
answer = [1,3,2,5,8,3,7,7]. Note that answer contains the separations in the same order.

Example 2

Input: nums = [7,1,3,9]
Output: [7,1,3,9]
Explanation: The separation of each integer in nums is itself.
answer = [7,1,3,9].
Key Insight
Loop through each value in the array.
Take the modules of each digit and add them to an arraylist.
Reverse it and add it to the arraylist.

Algorithm

Initialize 2 arraylists.
Loop through each digits of nums array.
Initialize an integer to store the deconstructed values.
While the nums[i]>0.
Assign 10 modules of nums[i] to integer value.
Add that value to an arraylist.
Divide the nums[i] by 10.
End while.
Reverse the arraylist that stored the value.
Add the reversed arraylist to another arraylist.
Clear the reversed arraylist.
Convert arraylist to int[].
return answer.

Algorithm in simple words

Initialize 2 arraylists one to save the array and another to save the modules value of element having more than single digit and reverse it.
Loop through nums and initialize an integer to assign the modules value. While the nums[i] is greater than 0 so that when the nums[i] is < or = 0 it will go for another for loop iteration. The value becomes nums[i]%10. and add this value to the 2nd arraylist. Then nums[i]=nums[i]/10 - this will remove the last digit of the element.
After the while loop ends we will reverse the arraylist and add it to the 1st arraylist, and clear the 2nd arraylist for next element.

Java code

class Solution {
    public int[] separateDigits(int[] nums) {
        ArrayList <Integer> answers = new ArrayList<>();
         ArrayList <Integer> answers2 = new ArrayList<>();
        for (int i=0;i<nums.length;i++){
            int value=0;
            while(nums[i]>0){
                value=nums[i]%10;
                answers2.add(value);
                nums[i]=nums[i]/10;
            }
            Collections.reverse(answers2);
            answers.addAll(answers2);
            answers2.clear();
        }
        int[] answer = answers.stream()
                         .mapToInt(i -> i)
                         .toArray();
        return answer;
    }
}

Time & Space Complexity

Time Complexity: O(nm)
Space Complexity: O(nm)

Optimizing Generosity: A Greedy Approach to LeetCode 455 (Assign Cookies)

Jerin — Wed, 06 May 2026 14:49:24 +0000

Difficulty: Easy
Topics: Array, Two Pointers, Greedy, Sorting
Platform: Leetcode

Problem Statement

Assume you are an awesome parent and want to give your children some cookies. But, you should give each child at most one cookie.
Each child i has a greed factor g[i], which is the minimum size of a cookie that the child will be content with; and each cookie j has a size s[j]. If s[j] >= g[i], we can assign the cookie j to the child i, and the child i will be content. Your goal is to maximize the number of your content children and output the maximum number.
Problem Statement Simplified
Give each children a cookies and each children have a dreed factor, give the result of how many children were satisfied.

Mistakes and Learning

Dont check for eact value - in greedy problems we should look for threhold not exact value.
At first used the 2 lists that stored the 2 arrays then remove the one by one from lists after going through the loop - The problem : If remove an element from index 2, then the element that was at index 3 will slides to index 2, will skip that element.

Example 1

Input: g = [1,2,3], s = [1,1]
Output: 1
Explanation: You have 3 children and 2 cookies. The greed factors of 3 children are 1, 2, 3. 
And even though you have 2 cookies, since their size is both 1, you could only make the child whose greed factor is 1 content.
You need to output 1.

Example 2

Input: g = [1,2], s = [1,2,3]
Output: 2
Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2. 
You have 3 cookies and their sizes are big enough to gratify all of the children, 
You need to output 2.

Key Insight

If s[i] ≥ g[i] then child satisfied.
If s[i]<g[i] then child not satisfied.

Algorithm

Sort the 2 arrays.
Initialize 2 integers for child and cookies.
While the child is less than g.length and cookies is less than s.length.
If s[cookies] is greater than or equal to g[child].
Then child++.
End if.
Cookies++.
End for loop.
return child.

Algorithm in simple words

First, sort the 2 arrays so that we can we can match smallest available cookies with smallest greed factor.
Initialize 2 int pointers for child and cookies, then we will iterate and check if the current cookies can satify the current child if yes then we will move on to next child and next cookies, if not then we will move to next cookies . Return the child pointer with how many children are satisfied.

Java code

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int child=0;
        int cookies=0;
        while(child<g.length && cookies<s.length){
            if(s[cookies]>=g[child]){
                child++;
            }
            cookies++;
        }
        return child;
    }
}

Time & Space Complexity

Time Complexity: O(n logn + m logm)
Space Complexity: O(logn + logm)

LeetCode 387: Finding the First Unique Character - Frequency Mapping in Java

Jerin — Wed, 06 May 2026 09:15:32 +0000

Difficulty: Easy

Topics: Hash Table, String, Queue, Counting

Platform: Leetcode

Problem Statement

Given a string s, find the first non-repeating character in it and return its index. If it does not exist, return -1.

Problem Statement Simplified
Get the index of the first non-repeating character, else return -1.

Mistakes and Learning
Do not blindly loop thorugh.
Do not just delete the duplicates, remove the duplicated character also.

Example 1

`Input: s = "leetcode"

Output: 0

Explanation:

The character 'l' at index 0 is the first character that does not occur at any other index.`

Example 2

`Input: s = "loveleetcode"

Output: 2`

Key Insight

Remove all the duplicating characters
Then get the first character
Get the first character index.
If no unique then -1.

Algorithm

Convert the string to a char array.
Intitialize a HashMap to store the character and the repeating counts.
Intitialize a for loop
Put the character in the HashMap with getOrDefault to check if the character already preset or not, if yes then increment by 1.
End for loop
Intitialize a for loop
Check if the first value is 1 if yes then return the for loop index else continue the for loop
End for loop
return -1

Algorithm in simple words

First, convert the string to a char array. Then initialize a HashMap so that we can store each character with its repeating counts.
Then initialize a for loop to add each character from character array to HashMap with getOrDefault ( if the value of preseent the increment b 1 else it will be 0 ), end of for loop. Then initialize another for loop to check the first character with value 1 from HashMap. if found then return the loop index else it will end the loop and return -1.

Java code

class Solution {
    public int firstUniqChar(String s) {
        char[] character = s.toCharArray();
        Map <Character, Integer> map= new HashMap<>();
        for(int i=0;i<character.length;i++){
            map.put(character[i],map.getOrDefault(character[i],0)+1);
        }
       for(int i=0;i<character.length;i++){
        if(map.get(character[i])==1){
            return i;
        }
       }
        return -1;
    }
}

Time & Space Complexity

Time Complexity: O(n)

Space Complexity: O(n)

LeetCode 819: Finding the Most Common Word - String Cleaning and Counting in Java

Jerin — Wed, 06 May 2026 07:05:19 +0000

Difficulty: Easy

Topics: Array, Math, Hash Table, String, Counting

Platform: Leetcode

Problem Statement

Given a string paragraph and a string array of the banned words banned, return the most frequent word that is not banned. It is guaranteed there is at least one word that is not banned, and that the answer is unique.

The words in paragraph are case-insensitive and the answer should be returned in lowercase.

Note that words can not contain punctuation symbols.

Problem Statement Simplified
If in the paragraph string have the word in banned array, then discard it. If the paragraph string have ‘.’ or ‘ ’ then remove it. Make everything lowercase. Then give back the word that is most frequent.

Mistakes and Learning
Forgetting about removing ‘.’ or ‘ ’.
Look out for rare cases (ex:[a.])

Example 1

Input: paragraph = "Bob hit a ball, the hit BALL flew far after it was hit.", banned = ["hit"]
Output: "ball"
Explanation: 
"hit" occurs 3 times, but it is a banned word.
"ball" occurs twice (and no other word does), so it is the most frequent non-banned word in the paragraph. 
Note that words in the paragraph are not case sensitive,
that punctuation is ignored (even if adjacent to words, such as "ball,"), 
and that "hit" isn't the answer even though it occurs more because it is banned.

Example 2

Input: paragraph = "a.", banned = []
Output: "a"

Key Insight

Initialize a HashMap and HashSet for paragraph String and banned array.
If not a word from banned array then add to HashMap and increment the counter
If a word from banned array then move to next word.

Algorithm

Remove everything from string other than [a-z] and make it lowercase.
Initialize a String array and add the string words to it using split function.
Initialize HashMap and HashSet for string array and banned word array respectively.
Initialize an int max and string maxWord to check and return the max repeating word.
Initialize a for loop and add the banned array to HashSet. end for loop
Initialize a for loop.
Store the current word in String array to a string.
If not a word in HashSet.
Put in HashMap and increment the value if not already present.
If value is greater than max.
Assign the value to max.
Assign word to maxWord.
end if.
end if
end for loop.
return max word.

Algorithm in simple words

First, remove everything from string other than [a-z] and make it lowercase. Then split the string and store it in an array.
Initialize a HashMap to store the string and integer - so that we can just look at this hashmap and check how many times the string repeated. everytime we loop through the string array (we created earlier), we will store the words in hashmap and assign a value to it which will increment when the word is repeated in the array.

Initialize a HashSet to store the string — so that the banned word array can be stored and compared with hashmap.

Initialize an int max and string maxWord to check and return the max repeating word.

Initialize a for loop which will go thorugh the banned words array and add them to HashSet.

Then we will loop through the string array and check the HashSet and current word from String array. If same then we will move to next word from String array. If not then we will add it to HashMap and if the word already exists then we will increment the value of it ( using map.getOrDefault(word,0) it will return the current value, if the word doesnt exists then it wil return 0 otherwise the current value of that word from HashMap ).

Then we will check of this value is greater than max, if yes then we will set this value as new max and this word as new maxWord.

Java code

class Solution {
    public String mostCommonWord(String paragraph, String[] banned) {
        paragraph= paragraph.toLowerCase().replaceAll("[^a-z]"," ");
        String[] words= paragraph.split("\\s+");
        Map<String,Integer> map= new HashMap<>();
        Set<String> bannedWord=new HashSet<>();
        int counter=0;
        int max=-1;
        String maxWord="";
        for (int i=0;i<banned.length;i++){
            bannedWord.add(banned[i].toLowerCase());
        }
        for(int i=0;i<words.length;i++){
             String word=words[i];
            if(!bannedWord.contains(word)){
            map.put(word,map.getOrDefault(word,0)+1);

            if(map.get(word)>max){
                max=map.get(word);
                maxWord=word;
            }
            }
        }
        return maxWord;

    }
}

Time & Space Complexity

Time Complexity: O(n+m)

Space Complexity: O(n+m)

LeetCode 66: Plus One — Simple Explanation with Carry Logic (Java)

Jerin — Tue, 05 May 2026 13:54:59 +0000

Difficulty: Easy

Topics: Array, Math

Platform: Leetcode

Problem Statement

You are given a large integer represented as an integer array digits, where each digits[i] is the ith digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading 0's.Increment the large integer by one and return the resulting array of digits.

Problem Statement Simplified

Check the last digit, add 1, then return

Mistakes and Learning

Do not turn the array into number.
Only check/change last digit.
Look out for rare cases (ex:[9,9,9,…]

Example 1

Input: digits = [1,2,3]
Output: [1,2,4]
Explanation: The array represents the integer 123.
Incrementing by one gives 123 + 1 = 124.
Thus, the result should be [1,2,4].

Example 2

Input: digits = [4,3,2,1]
Output: [4,3,2,2]
Explanation: The array represents the integer 4321.
Incrementing by one gives 4321 + 1 = 4322.
Thus, the result should be [4,3,2,2].

Key Insight

Addition starts from the last digit
If digit < 9 → just increment and stop
If digit = 9 → set to 0 and carry forward

Algorithm

Initialize a for loop with i starting from last digit and i decrement at each loop.
Check if the digit[i] is less than 9
If less than 9, then increment (digit[i]++). return digit.
end if.
then digit[i]=0.
end for loop
Initialize an array with digits.length+1.
Assign the first digit of new array as 1.
return the new array.

Algorithm in simple words

First, initialize a for loop that will start from the end of the array and check if that digit is less than 9, if yes then just increment that digit by 1 and return it, SIMPLE ! (ex: suppose the digits array is [4,2,3,2] check the last digit, it is less than 9 , which is 2. So when we increment 2 the final result will be [4,2,3,3], that is the final output).

Suppose the last digit is 9 then make it 0 and then go to the second last digit and check in the if statment. if it is less than 9 then increment by 1 then return. (ex : suppose the digits array iss [4,3,2,9] check if less than 9, NO. Then digitsi will become 0 the array will be [4,3,2,0], i decrease then check for the second last digit (here it is 2) it is less than 9 so increamnet by 1 then return so the final result will be [4,3,3,0]).

Suppose the entire is 9 ie the array is [9,9,9] then we will initialize a new array increment the array length by 1, and make the first digit of the array 1.

Java code

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

        int[] newDigits = new int[digits.length + 1];
        newDigits[0] = 1;
        return newDigits;
    }
}

Time & Space Complexity

Time Complexity: O(n)

Space Complexity: O(1) (except when new array is created)