Naveen Kumar’s Post

Leetcode problem of the day : Maximum Swap The problem that we are tackling for today is that the goal is to swap two digits in a given number to produce the largest possible value Approach used: 1. Convert the Number to a Char Array: - The first step is to convert the given integer to a character array, so we can easily manipulate individual digits. 2. Track the Last Occurrence of Each Digit: - We create an array to store the last occurrence of every digit (0 through 9). This helps us quickly find the best digit to swap later. 3. Find the Optimal Swap: - For each digit in the number, we look for a larger digit (starting from 9) that occurs later in the number. If found, we swap the current digit with this larger digit to maximize the number. 4. Return the Result: - After the swap, we convert the array back to an integer and return the result. Time Complexity : O(N) Space Complexity : O(N) Link : https://lnkd.in/gkwHx66r Feel free to connect for more insights on algorithm optimization and problem-solving strategies! 😉

Leetcode problem of the day : Three Consecutive Odds The problem that we are tackling for today is given an array of integers, determine whether there are three consecutive odd numbers in the array. Approach used: 1. Iterative Check: - Traverse through the array and check each triplet of consecutive elements. - If all three numbers in any triplet are odd, return true. - if no such triplet is found by the end of the array, return false. 2. Optimized Approach: - Use a counter to keep track of consecutive odd numbers. - If the counter reaches three, return true. - Reset the counter to zero whenever an even number is encountered. - Continue until the end of the array and return false if no triplet of odd numbers is found. Time Complexity : O(N) Space Complexity : O(1) Link : https://lnkd.in/gqf-Kqxp Feel free to connect for more insights on algorithm optimization and problem-solving strategies! 😉

Leetcode problem of the day : Separate Black and White Balls The problem that we are tackling for today is that the goal is to determine the minimum steps needed to move all '0's in a binary string to the front while preserving the relative order of '1's. Approach used: 1. Initialize two variables: steps to keep track of the total steps and prev to point to the position where the next '0' should go. 2. Traverse the string, and for every '0' encountered, calculate the difference between its current position (curr) and the last valid position (prev). This difference is added to the steps. 3. After every valid move, increment the prev pointer to the next position. Finally, return the total steps. Time Complexity : O(N) Space Complexity : O(1) Link : https://lnkd.in/eX9abP82 Feel free to connect for more insights on algorithm optimization and problem-solving strategies! 😉

Leetcode problem of the day : Lucky Numbers in a Matrix The problem that we are tackling for today is that given a matrix of distinct integers, find all lucky numbers in the matrix. A lucky number is defined as an element that is the minimum in its row and maximum in its column. Approach used: 1. Initialize Dimensions and Result List: - Determine the number of rows and columns in the matrix. - Initialize a list to store the result. 2. Find Minimum Element in Each Row: - For each row, iterate through the columns to find the minimum element and its index. 3. Check Maximum Element in Corresponding Column: - For the column index of the minimum element found, check if it is the maximum element in that column by iterating through all rows. 4. Collect Lucky Numbers: - If the minimum element in a row is also the maximum element in its column, add it to the result list. 5. Return Result: - Return the list of lucky numbers. Time Complexity : O(N*M) Space Complexity : O(1) Link : https://lnkd.in/gdQvGDW5 Feel free to connect for more insights on algorithm optimization and problem-solving strategies! 😉

Today....I solved another leetcode problem "Maximum product of Three Numbers"......... Problem Description: Given an integer array nums, find three numbers whose product is maximum and return the maximum product.   My Approach: Sort the nums array and find the product of last three elements and store it in product1 variable and use another test case that multiply first, second and last of the sorted nums array and store it in the product2.....Finally find the max of the two variables.......

Leetcode Problem Of The Day : Maximum Width Ramp Approach : 1. Understanding the Problem: You need to find the maximum width of a ramp in an array, where a ramp is defined as a pair of indices i and j such that: i<j nums[i]≤nums[j] The goal is to maximize j−i. 2. Using a Stack: A stack is employed to store indices of the array where the elements are in increasing order. This helps efficiently find valid indices for ramp pairs. 3. Two-Pass Algorithm: First Pass: Iterate through the array to fill the stack: Push indices onto the stack when you find an index where the value is less than the value of the previous index in the stack. This ensures that the stack maintains indices of potential starting points for valid ramp pairs. Second Pass: Iterate from the end of the array: For each element, check if the element at the index stored at the top of the stack is less than or equal to the current element. If it is, pop the index from the stack and calculate the width as j−i. Update the maximum width found if this width is greater than the previously recorded maximum width. 4. Returning the Result: After iterating through the array, the maximum width recorded will be the final answer. Time Complexity: O(n) Space Complexity: O(n)

Leetcode problem of the day : Delete Nodes And Return Forest The problem that we are tackling for today is that given the root of a binary tree and an array of node values to delete, return the forest obtained by deleting the specified nodes. Each node in the forest is represented as a separate binary tree. Approach used: 1. Create a Set of Nodes to Delete: - Convert the array of node values to delete into a set for O(1) lookup time. 2. Depth-First Search (DFS) Traversal: - Implement a recursive DFS function to traverse the tree. - Check if the current node needs to be deleted. - If the node is deleted, its children (if any) become new roots. - Continue the traversal for the left and right children. - Return null if the node is deleted, otherwise return the node. 3. Handle Root Nodes: - Start the DFS traversal from the root. - If the root is not deleted, add it to the result list. Time Complexity : O(N) Space Complexity : O(N) Link : https://lnkd.in/gRNhbg-9 Feel free to connect for more insights on algorithm optimization and problem-solving strategies! 😉

Day 107: Today, I tackled LeetCode Problem 962, "Maximum Width Ramp." Problem Overview:   A "ramp" in an array is a pair of indices (i, j) such that i < j and nums[i] <= nums[j]. The task is to return the maximum width of such a ramp, calculated as j - i. If no ramp exists, return 0. Example 1:   Input:   nums = [6,0,8,2,1,5] Output:   4 Explanation:   The maximum width ramp is at (1, 5) where nums[1] = 0 and nums[5] = 5, and the width is 5 - 1 = 4. Example 2:   Input:   nums = [9,8,1,0,1,9,4,0,4,1] Output:   7 Explanation:   The maximum width ramp is at (2, 9) where nums[2] = 1 and nums[9] = 1, with the width of 9 - 2 = 7. Solution Approach:   I implemented a solution that tracks indices in a way that ensures finding the largest possible ramp width efficiently. You can check out my solution here: https://lnkd.in/eMN9JvzY This problem was a great exercise in array manipulation and index tracking. It challenged me to consider different approaches for maximizing the width while maintaining the conditions of the ramp.

***Day 9: Deleting the Middle Node in a Linked List*** Approach: This algorithm deletes the middle node of a singly linked list in one pass using the two-pointer technique. We start with two pointers, slow and fast, both initialized to the head. The fast pointer moves twice as fast as the slow pointer. When fast reaches the end, slow will be at the middle node. A prev pointer keeps track of the node before slow. Once slow reaches the middle, prev.next is updated to bypass the middle node. Time Complexity: O(n): The algorithm makes a single pass through the list. #Leetcode #ProblemSolving

LeetCode Problem Of The Day 169 :- Majority element Given an array nums of size n, return the majority element. The majority element is the element that appears more than [n / 2] times. You may assume that the majority element always exists in the array. Example 1: Input: nums = [3,2,3] Output: 3 Approach :- first all store the frequency of each element in a map and then iterate over map and check if frequency is > n/2 then assign it to answer.