DEV Community: Piyush Acharya

Fastest Java Solution!! 🔥🔥🔥

Piyush Acharya — Wed, 14 Jun 2023 17:35:23 +0000

Intuition

This problem is really simple if you think about the 2 types of testcases. First, the number inputted can be divisible by 2. In this case, we can just return the number itself since it satisfies all of the criteria. Else, you can just return the number times 2.

Complexity

Time complexity: O(1)
Space complexity: O(1)

Code

class Solution {
    public int smallestEvenMultiple(int n) {
        if (n % 2 == 0) {
            return n;
        } else {
            return n * 2;
        }
    }
}

2648. LeetCode's Generate Fibonacci Sequence - JS Solution Beats 56% in Memory

Piyush Acharya — Wed, 14 Jun 2023 16:55:20 +0000

Code

/**
 * @return {Generator<number>}
 */
var fibGenerator = function*() {
    let a = 0, b = 1;
    yield a;
    yield b;

    while (true) {
        let c = a + b;
        a = b;
        b = c;
        yield c;
    }
};

/**
 * const gen = fibGenerator();
 * gen.next().value; // 0
 * gen.next().value; // 1
 */

FASTEST JAVA SOLUTION 🔥🔥🔥

Piyush Acharya — Wed, 14 Jun 2023 16:26:06 +0000

Code

class Solution {
    public int[] shuffle(int[] nums, int n) {
        int[] newNums = new int[nums.length];
        for (int i = 0; i < n; i++) { 
            newNums[i * 2] = nums[i];
        }
        for (int j = 1; j < nums.length; j += 2) {
            newNums[j] = nums[n + (j / 2)];
        }
        return newNums;
    }
}

2629. LeetCode's Function Composition - Linear Solution Beats 53%

Piyush Acharya — Wed, 14 Jun 2023 16:02:56 +0000

Code

/**
 * @param {Function[]} functions
 * @return {Function}
 */
var compose = function(functions) {
    return function(x) {
        for (var i = functions.length - 1; i >= 0; i--) {
            x = functions[i](x);
        }
        return x;
    }
};

/**
 * const fn = compose([x => x + 1, x => 2 * x])
 * fn(4) // 9
 */

Fastest JS Solution - Beats 75% of Solutions with 50 MS Runtime

Piyush Acharya — Wed, 14 Jun 2023 15:58:42 +0000

Intuition

The code snippet is a JavaScript function that takes an array and a function as input and returns a new array with the function applied to each element of the input array.

Approach

The approach used in the code snippet is to loop through each element of the input array and apply the given function to it. The result of the function is then stored in a new array.

Complexity

Time complexity: The time complexity of the map function is O(n), where n is the length of the input array. This is because the function loops through each element of the input array once and applies the given function to it.
Space complexity: The space complexity of the map function is O(n), where n is the length of the input array. This is because the function creates a new array of the same length as the input array to store the results of the function applied to each element of the input array. # Code

/**
 * @param {number[]} arr
 * @param {Function} fn
 * @return {number[]}
 */
var map = function(arr, fn) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        newArr[i] = fn(arr[i], i);
    }
    return newArr;
};

JAVASCRIPT SOLUTION BEATS 83% IN MEMORY USAGE

Piyush Acharya — Wed, 14 Jun 2023 15:50:17 +0000

Intuition

The code snippet is a JavaScript implementation of the reduce() method for arrays. The reduce() method is used to apply a function to each element of an array and reduce the array to a single value.

Approach

The reduce() method is called on an array and takes two arguments: a callback function and an initial value. The callback function is executed on each element of the array and takes two arguments: an accumulator and the current element. The accumulator is the value returned by the previous invocation of the callback function, or the initial value if it is the first invocation. The current element is the current element being processed in the array. The callback function returns a value that is used as the accumulator for the next invocation of the callback function. The reduce() method returns the final value of the accumulator after all elements of the array have been processed.

Complexity

Time complexity: The time complexity of the reduce() method is O(n), where n is the number of elements in the array. This is because the callback function is executed once for each element in the array.
Space complexity: The space complexity of the reduce() method is O(1), because it only uses a constant amount of additional space to store the accumulator and the current element. # Code

/**
 * @param {number[]} nums
 * @param {Function} fn
 * @param {number} init
 * @return {number}
 */
var reduce = function(nums, fn, init) {
    var res = init
    for (var i = 0; i < nums.length; i++) {
        res = fn(res, nums[i])
    }
    return res;
};

2396. LeetCode's Strictly Palindromic Number - FASTEST JAVA SOLUTION - 0 MS RUNTIME ⏩⏩

Piyush Acharya — Wed, 14 Jun 2023 15:44:39 +0000

Intuition

The code seems to be checking if a given number is strictly palindromic in all bases from 2 to n-2.

Approach

The code seems to be checking if a given number is strictly palindromic in all bases from 2 to n-2.

Complexity

Time complexity: The time complexity of the convert method is O(log n), since it is converting the number to a different base. The time complexity of the isPalindrome method is O(log n), since it is checking if the number is a palindrome. The time complexity of the isStrictlyPalindromic method is O(n log n), since it is iterating through all bases from 2 to n-2, and for each base it is calling the convert and isPalindrome methods. Therefore, the overall time complexity is O(n log n).
Space complexity: The space complexity of the convert method is O(log n), since it is creating a string representation of the number in a different base. The space complexity of the isPalindrome method is O(log n), since it is creating a string representation of the number. The space complexity of the isStrictlyPalindromic method is O(1), since it is only using a constant amount of space. Therefore, the overall space complexity is O(log n).

Code

class Solution {
    public boolean isStrictlyPalindromic(int n) {
        int size = n - 2;
        for (int i = 2; i <= size; i++) {
            if (!isPalindrome(convert(n, i))) {
                return false;
            }
        }
        return true;
    }

    public long convert(int number, int base) {
        String binary = Integer.toString(number, base);
        return Long.parseLong(binary);
    }

    public Boolean isPalindrome(long number) {
        String num = Long.toString(number);
        int max = num.length() / 2;
        for (int i = 0; i < max; i++) {
            if (!(num.charAt(i) == num.charAt(num.length() - i - 1))) {
                return false;
            }
        }
        return true;
    }
}

I'm approaching 1000 followers!

Piyush Acharya — Wed, 14 Jun 2023 05:02:48 +0000

Hey everyone, I have some amazing news to share with you all! I'm approaching 1000 followers on dev.to and I couldn't be more thankful for your support and engagement. You guys are awesome and I love reading your comments and messages. Thank you for being part of my journey and for making this community so wonderful. To celebrate this milestone, I'm going to do a Q&A session where you can ask me anything you want about my projects, skills, interests, or anything else. Just drop your questions in the comments below or DM me and I'll answer them in a video soon. I can't wait to hear from you and to share more of my thoughts and insights with you. Stay tuned and stay awesome! 😊

P.S. If you haven't checked out my latest project, DNAnalyzer, please do so! It's a groundbreaking open source tool that brings the power of machine learning to DNA analysis. You can find it on GitHub or read more about it here on dev.to. I would love to hear your feedback and suggestions on how to make it better and more useful for everyone.

2733. LeetCode's Neither Minimum nor Maximum - JAVA SOLUTION BEATS 100% OF SOLUTIONS IN BOTH RUNTIME AND MEMORY

Piyush Acharya — Sun, 11 Jun 2023 04:02:49 +0000

Code

class Solution {
    public int findNonMinOrMax(int[] nums) {
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > max) {
                max = nums[i];
            } if (nums[i] < min) {
                min = nums[i];
            }
        }
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != max && nums[i] != min) {
                return nums[i];
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        int[] nums = { 1, 2 };
        System.out.println(sol.findNonMinOrMax(nums));
    }
}

EXTREMELY SIMPLE & LOGICAL JAVA SOLUTION BEATS 85% IN RUNTIME

Piyush Acharya — Sat, 10 Jun 2023 22:48:46 +0000

Intuition

The problem asks us to find the number of good pairs in an array. A good pair is defined as a pair (i, j) where 0 <= i < j < nums.length and nums[i] == nums[j]. In other words, we need to count the number of occurrences of the same element in the array that have a lower index than another occurrence of the same element.

Approach

One simple approach to solve this problem is to use nested loops to compare each pair of elements in the array and count the good pairs. The outer loop iterates over each element in the array, and the inner loop starts from the next element and compares it with the current element. If the elements are equal, we increment the count of good pairs.

Complexity

Time complexity: O(n^2) - The nested loops iterate over all pairs of elements in the array, resulting in a quadratic time complexity.
Space complexity: O(1) - We are using a constant amount of extra space to store the count of good pairs.

Code

class Solution {
    public int numIdenticalPairs(int[] nums) {
        int goodPairs = 0;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] == nums[j]) {
                    goodPairs++;
                }
            }
        }
        return goodPairs;
    }
}

Note: This code snippet is in Java.

2716. LeetCode's Minimize String Length - FASTEST JAVA SOLUTION BEATS 100% OF SOLUTIONS!!!!

Piyush Acharya — Mon, 05 Jun 2023 16:44:35 +0000

Intuition

The problem is to find the minimum length of a string after removing all duplicate characters. One way to solve this problem is to use a boolean array to keep track of which characters have been seen before in the string. Then, we can iterate over the string and count how many unique characters there are. This will give us the minimum length of the string.

Approach

We can use a boolean array of size 26 to represent the 26 lowercase letters in the alphabet. We initialize all the elements to false, meaning that we have not seen any character yet. Then, we convert the input string to a char array and loop through it. For each character, we check its corresponding index in the boolean array. If it is false, we set it to true and increment a counter variable. If it is true, we ignore it and move on to the next character. At the end of the loop, the counter variable will hold the number of unique characters in the string, which is also the minimum length of the string after removing duplicates.

Complexity

Time complexity:
The time complexity of this solution is $$O(n)$$, where n is the length of the input string. This is because we only need to loop through the string once and perform constant time operations for each character.
Space complexity:
The space complexity of this solution is $$O(1)$$, because we only use a fixed size boolean array and a few variables that do not depend on the input size.

Code

import java.util.ArrayList;

class Solution {
    public int minimizedStringLength(String s) {
        char[] characters = s.toCharArray();
        int count = 0;
        boolean[] seen = new boolean[26];
        for (int i = 0; i < characters.length; i++) {
            if (!seen[characters[i] - 97]) {
                seen[characters[i] - 97] = true;
                count++;     
            }   
        }
        return count;
    }   
}

SIMPLE & EFFICIENT Java Solution BEATS 95%

Piyush Acharya — Mon, 05 Jun 2023 16:35:10 +0000

Intuition

To solve this problem, I need to keep track of the value of x and update it according to the operations in the array.

Approach

I will use a variable x to store the value of x and initialize it to zero. Then I will loop through the array of operations and use a switch statement to check each operation and increment or decrement x accordingly.

Complexity

Time complexity:
The time complexity is $$O(n)$$ where n is the length of the array, because I need to iterate through all the operations once.
Space complexity:
The space complexity is $$O(1)$$ because I only use a constant amount of extra space for the variable x.

Code

class Solution {
 public int finalValueAfterOperations(String[] operations) {
 int x = 0;
 int size = operations.length; // store the size of the array
 for (int i = 0; i < size; i++) { // use the size variable
 String operation = operations[i]; // store the operation in a variable
 switch (operation) { // use switch statement
 case "++X":
 case "X++":
 x++;
 break;
 case "--X":
 case "X--":
 x--;
 break;
 }
 }
 return x;
 }
}