DEV Community: vinnu gollakoti

Day 59 Journal

vinnu gollakoti — Tue, 17 Dec 2024 04:19:43 +0000

Hi, Folks! Today, I solved three problems on LeetCode: Letter Combination of a Phone Number, Container with Most Water, and Rotate Array. Solving different problems every day helps us to think about problems from different angles. There are various ways to solve a problem. If you find one way to solve it, don’t stop there try to optimize the solution further. This will help you find the most efficient way to solve the given problem.

Letter Combination of a Phone Number: To solve this problem, we can use the concept of backtracking with one base condition. We need to find all possible combinations of characters linked to specific digits in the given input. The base condition will help us stop the function’s execution when necessary. This approach allows us to solve the problem effectively.

Container with Most Water: In this problem, we need to find the maximum area that can be formed. We can traverse the array using two pointers: one starting from the beginning of the array and the other from the end. This method helps us efficiently find the solution.

Rotate Array: The task here is to rotate the array by a specified number of positions. We can achieve this by slicing the array according to the specified position and creating a new array by appending the slices in the correct order. This approach solves the problem effectively.

I hope my experience will be helpful to you.

Day 55 Journal

vinnu gollakoti — Tue, 17 Dec 2024 04:13:29 +0000

Hi, Folks! Today, I solved three questions on LeetCode: Maximize greatness in array, Push Dominoes, and Beautiful Arrangements. All these problems may seem tough at first, but using data structures, we can develop a solid logic to solve them easily. With continuous practice, we can improve ability to frame the logics.

As a Beginner, to frame good logic. Firstly, we should have clarity on the problem statement. Next, try to breakdown entire process into small steps and give code to each small step. In this way we can complete the problem. If, we need to see some other approaches then just try to dry run the code this makes even more clear with approach.

Beautiful Arrangements : To solve this problem, we can use the backtracking concept. If we find the valid element, the code will traverse to the next. If, not it will backtrack to another position. In this we can solve this problem.

In this way every problem has some logic try to find it and solve the problem. Some times we might not come up with the logic in that case we can find the approach and dry run the code. Dry running the code will be really helpful.

I hope my experience will be helpful.

Day 53 Journal

vinnu gollakoti — Tue, 17 Dec 2024 04:10:47 +0000

Hi, Folks! Today, I prepared a problem-solving plan for entire week and solved three problems on LeetCode: Swap nodes in pairs, Maximal rectangle, and Friends Of Appropriate Ages.

There are many things which we should keep in mind when preparing a plan. First, consider the concepts which you want to learn in problem solving and find all the related problems and choose the most conceptual among them. Add them one by one to your plan.

Make sure that chosen problems are of your skill range. This means problem should not be too hard or too easy. Gaining experience in that specific concept should be beneficial to you. Now, I do not mean that we should avoid hard problems or only solve problems of familiar level. Each day, ensure that you have 2 or 3 problems of the same level and 1 or 2 problems of a higher level. The problems of same level help you revise the concept and also to gain the confidence in problem-solving. The problems in higher level will help you understand the extent of difficulty a problem can have. So, including both level problems in daily plan is essential.

Swap node pairs : This is a linked list problem which we can be solved by interchanging the addresses of pair nodes.

Maximal Rectangle : This problem can be solved using the stack. Traverse through out the matrix. if you find one increment the count or else replace it with zero. Every time, update the stack with new value. In this way we can solve maximal rectangle problem.

Friends of Appropriate Ages: In this problem we can traverse through out given array of ages and check if the given constraints are getting satisfied. In this way we can solve this problem.

I hope my experiences will be helpful!

Day 51 Journal

vinnu gollakoti — Tue, 17 Dec 2024 04:08:16 +0000

Hi, Folks! Today I solved three problems on LeetCode: Basic Calculator, Permutations and Maximum Subarray.

For Basic Calculator problem, we can use stack manage operators and parentheses. By popping elements when needed. This way and logic makes the basic calculator as a easier problem.

The Permutation problem can be solved using recursion. We can repeat the same function execution until all the possible combinations are added to result. In this way we can solve permutations problems on LeetCode.

The Maximum Subarray problem can be solved using single for loop. We iterate over the array to find the maximum sums, which helps us to identify maximum subarray. In this way we can solve the maximum subarray problem.

There are many problems around us which can be solved using data structures. Understanding how to apply these structures, like using a stack in the calculator problem, makes the problem more interesting and helps us to connect various concepts.

I hope my experience will be helpful.

Day 48 Journal

vinnu gollakoti — Tue, 17 Dec 2024 04:00:27 +0000

Hi, Folks! I have been solving the LeetCode questions daily and have noticed small improvements in myself. This encourages me to continue this problem solving. Understanding and visualizing data structures will become better day by day. Concepts like recursion and backtracking need number of problems to grasp.

On the First day, I started with some simple problems like reverse linked list this involves interchanging of links between nodes. The ‘Add two numbers’ problem was solved with help of dummy node concept. For ‘Merge k sorted lists’, we can use heaps to pop the smallest possible element, this makes sorting process easier.

On the Second day, I focused on some linked list types. In ‘Linked list cycle’ problem, we return true if the given input is circular linked list or else we return false. We can use Hare and Tortoise Algorithm to solve this problem. For ‘Palindrome linked list’ problem we divide the given linked list into two equal parts and reverse the second half of the linked list. Then, we compare the nodes of first half with those of second half. If they are same through out the linked list, it is a palindrome.

On the Third day, I covered the concept of queue and stacks. “Implement the queue using stack” is a conceptual question. For “Sliding window maximum” to solve this problem, we can use dequeue to store the indices of maximum elements every time the window slide. For “Perfect square”, we can use dynamic programming to store the minimum number of perfect squares required to add up to give input.

On the Fourth day, I covered some recursion and backtracking involved problems. For “Spiral matrix”, we use index limits and for loops to print elements in spiral order. For “N-Queens” to solve this problem we have three lists upper diagonal, lower diagonal and row. If I place a queen in any position, I update the corresponding position in list to indicate that already queen exists and helps to avoid unnecessary recursion. For “Unique paths”, we observe that every cell has two possible ways to be reached, we can use this logic to solve the problem.

I hope my experience will be helpful!

Day 46 Journal

vinnu gollakoti — Tue, 17 Dec 2024 03:57:51 +0000

Hi, folks! Today I solved three problems on LeetCode : Sliding window maximum, Implement queue with stack and Perfect squares.

These problems are great for improving our logical thinking skills. Let me walk you through the logics for each problem.

The first problem Sliding window maximum. The problem states that we are provided with a numbers array and a window of size k. We can only see k elements from the window. The window will start sliding from first element to last element of array according to window size. For every window slide, we have to return the maximum number.

We can solve this problem in two ways based on my understandings. The first approach is using nested for loop: one for loop to traverse through the array and the other for loop is to keep track of k elements and we will use max to find the maximum number in that k elements and then we create a list with all the maximum numbers, and return that list.

The second approach is using dequeue. Dequeue can handle push, pop and top operations in the both ends(first and last). We will use dequeue to store the indices of maximum number for every k(size of window) in array. Whenever the window size exceeds then we will pop a specific index from dequeue. In this way we will return all the maximum numbers in a list.

The second problem Implement queue with stack. In this problem we can use two stacks to achieve the functionality of queue. lets say we have stack one and stack two. Whenever there is push operation we can push it to stack one. For pop and top operations, we check whether stack two is empty. If it is, we will shift all the elements from stack one to stack two Otherwise we directly apply pop or top operations on stack two. In this way we can implement the queue with help of two stacks.

The third problem Perfect squares. In this problem, we are given an input number, and we need to find the minimum number of perfect squares are required to sum up to that input number. We can solve this problem by initializing two arrays. One array is to store all the perfect squares less than input number, and the other is used to keep track of minimum number of perfect squares that sum up to give input number. This way can efficiently solve the problem.

I hope my experience will be useful.

Day 44 Journal

vinnu gollakoti — Tue, 17 Dec 2024 03:53:02 +0000

Hi, Folks! Today I want to share my experience in LeetCode problem-solving. I am a beginner in data structures and algorithms, and currently, I am focusing on Python. I solved three questions from the linked list concept on LeetCode: Merge k Sorted Lists, Reverse Linked List, and Add Two Numbers.

For the problem Merge k Sorted Lists, there are many approaches you can choose. But, choosing the most efficient one comes with practice. As a beginner, I started with this approach: I created a new list, merged all the given lists into the newly created list, and then sorted it.

After completing the coding part, I wanted to know if there were any other approaches. So, I went through some resources and discovered that there is an even more efficient way using a min-heap. I found this approach to be more logical compared to mine, and this realization comes only with practice. If we can think of the most efficient logic in our first approach, it indicates that we are experts in programming.