Ritansh Singh’s Post

🔸Here's Todays Leetcode Problem of the day : (DAY161) 🔸Name: Merge In Between Linked Lists 🔸Approach : You are given two linked lists: list1 and list2 of sizes n and m respectively. Remove list1's nodes from the ath node to the bth node, and put list2 in their place. The blue edges and nodes in the following figure indicate the result: YBuild the result list and return its head.   Example 1: oInput: list1 = [10,1,13,6,9,5], a = 3, b = 4, list2 = [1000000,1000001,1000002] Output: [10,1,13,1000000,1000001,1000002,5] Explanation: We remove the nodes 3 and 4 and put the entire list2 in their place. The blue edges and nodes in the above figure indicate the result. Example 2: uInput: list1 = [0,1,2,3,4,5,6], a = 2, b = 5, list2 = [1000000,1000001,1000002,1000003,1000004] Output: [0,1,1000000,1000001,1000002,1000003,1000004,6] Explanation: The blue edges and nodes in the above figure indicate the result.   Constraints: 3 <= list1.length <= 104 1 <= a <= b < list1.length - 1 1 <= list2.length <= 104 🔸 Link: https://lnkd.in/dBff5CCr

Day 135: Problem Name : Merge Nodes in Between Zeros Logic : 1. Start with the input `ListNode` head and initialize a new `ListNode` called `node` to the next node after the head. 2. Create a temporary `ListNode` called `temp` and set it equal to `node`. 3. Start a while loop that continues as long as `temp` is not null. 4. Inside this while loop, initialize a variable `sum` to 0. This variable is used to store the sum of values within the linked list. 5. Start an inner while loop that continues as long as the value of `temp` is not 0. 6. Inside this inner while loop, add the value of `temp` to the `sum` and move to the next node by setting `temp` to its next node. 7. After the inner while loop finishes, update the `val` of the current `node` to the calculated `sum`. 8. Move `temp` to the next node so that it's positioned at the succeeding block. 9. Set the next node of `node` to `temp`. 10. Move `node` to `temp` to repeat the process for the next block. 11. After the while loop finishes, skip the head of the input linked list because it is always 0, and return the updated head. T.C: O(N) S.C: O(1) Problem link: https://lnkd.in/dxjKS7CG

LeetCode Linked List Components Medium Topics Companies You are given the head of a linked list containing unique integer values and an integer array nums that is a subset of the linked list values. Return the number of connected components in nums where two values are connected if they appear consecutively in the linked list.   Example 1: Input: head = [0,1,2,3], nums = [0,1,3] Output: 2 Explanation: 0 and 1 are connected, so [0, 1] and [3] are the two connected components. Example 2: Input: head = [0,1,2,3,4], nums = [0,3,1,4] Output: 2 Explanation: 0 and 1 are connected, 3 and 4 are connected, so [0, 1] and [3, 4] are the two connected components.   Constraints: The number of nodes in the linked list is n. 1 <= n <= 104 0 <= Node.val < n All the values Node.val are unique. 1 <= nums.length <= n 0 <= nums[i] < n All the values of nums are unique.

🔸Here's Todays Leetcode Problem of the day : [ 🔥DAY 207 ] 🔸Name : Delete Node in a Linked List 🔸Description : There is a singly-linked list head and we want to delete a node node in it. You are given the node to be deleted node. You will not be given access to the first node of head. All the values of the linked list are unique, and it is guaranteed that the given node node is not the last node in the linked list. Delete the given node. Note that by deleting the node, we do not mean removing it from memory. We mean: The value of the given node should not exist in the linked list. The number of nodes in the linked list should decrease by one. All the values before node should be in the same order. All the values after node should be in the same order. Custom testing: For the input, you should provide the entire linked list head and the node to be given node. node should not be the last node of the list and should be an actual node in the list. We will build the linked list and pass the node to your function. The output will be the entire list after calling your function.   Example 1: YInput: head = [4,5,1,9], node = 5 Output: [4,1,9] Explanation: You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function. Example 2: oInput: head = [4,5,1,9], node = 1 Output: [4,5,9] Explanation: You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.   Constraints: The number of the nodes in the given list is in the range [2, 1000]. -1000 <= Node.val <= 1000 The value of each node in the list is unique. The node to be deleted is in the list and is not a tail node. 🔸Link: https://lnkd.in/d_kDgWiC

🔸Here's Todays Leetcode Problem of the day : [ 🔥DAY 209 ] 🔸Name :  Double a Number Represented as a Linked List 🔸Description : You are given the head of a non-empty linked list representing a non-negative integer without leading zeroes. Return the head of the linked list after doubling it.   Example 1: YInput: head = [1,8,9] Output: [3,7,8] Explanation: The figure above corresponds to the given linked list which represents the number 189. Hence, the returned linked list represents the number 189 * 2 = 378. Example 2: oInput: head = [9,9,9] Output: [1,9,9,8] Explanation: The figure above corresponds to the given linked list which represents the number 999. Hence, the returned linked list reprersents the number 999 * 2 = 1998.   Constraints: The number of nodes in the list is in the range [1, 104] 0 <= Node.val <= 9 The input is generated such that the list represents a number that does not have leading zeros, except the number 0 itself. 🔸Link: https://lnkd.in/dWW47XyS

Leetcode Problem Of The Day : Linked List in Binary Tree Approach: 1. Base Cases: If the root node (root) is null, the linked list cannot be a subpath because there's no tree to traverse. The function returns false. If the linked list head (head) is null, it's considered an empty path and is a valid subpath of any tree (think of an empty string being a substring of any other string). The function returns true. 2. Recursive Approach: The function first checks if the current node (root) value matches the head value (head.val) of the linked list. If not, it means the subpath doesn't start at this node, and false is returned. If the values match, the function calls itself recursively to check two possibilities: checkPath ( head. next , root. left): This checks if the remaining linked list (head. next) is a subpath of the left subtree (root. left) of the current node. checkPath(head. next , root. right): This checks if the remaining linked list (head. next) is a subpath of the right subtree (root. right) of the current node. 3. Overall Logic: The main function isSubPath keeps traversing the tree (root.left and root.right) until a matching subpath is found or all branches are exhausted. The helper function checkPath recursively compares the remaining linked list elements with the corresponding tree nodes. Time Complexity : O(n*m) Space Complexity : O(n)

Day 81 of #100DaysOfCode challenge: You are given an integer array banned and two integers n and maxSum. You are choosing some number of integers following the below rules: The chosen integers have to be in the range [1, n]. Each integer can be chosen at most once. The chosen integers should not be in the array banned. The sum of the chosen integers should not exceed maxSum. Return the maximum number of integers you can choose following the mentioned rules.   Example 1: Input: banned = [1,6,5], n = 5, maxSum = 6 Output: 2 Explanation: You can choose the integers 2 and 4. 2 and 4 are from the range [1, 5], both did not appear in banned, and their sum is 6, which did not exceed maxSum. Example 2: Input: banned = [1,2,3,4,5,6,7], n = 8, maxSum = 1 Output: 0 Explanation: You cannot choose any integer while following the mentioned conditions. Example 3: Input: banned = [11], n = 7, maxSum = 50 Output: 7 Explanation: You can choose the integers 1, 2, 3, 4, 5, 6, and 7. They are from the range [1, 7], all did not appear in banned, and their sum is 28, which did not exceed maxSum.   Constraints: 1 <= banned.length <= 10^4 1 <= banned[i], n <= 10^4 1 <= maxSum <= 10^9

#day19of100DaysCodingChallenge #leetcode 2095. Delete the Middle Node of a Linked List Companies You are given the head of a linked list. Delete the middle node, and return the head of the modified linked list. The middle node of a linked list of size n is the ⌊n / 2⌋th node from the start using 0-based indexing, where ⌊x⌋ denotes the largest integer less than or equal to x. For n = 1, 2, 3, 4, and 5, the middle nodes are 0, 1, 1, 2, and 2, respectively. Example 1: Input: head = [1,3,4,7,1,2,6] Output: [1,3,4,1,2,6] Explanation: The above figure represents the given linked list. The indices of the nodes are written below. Since n = 7, node 3 with value 7 is the middle node, which is marked in red. We return the new list after removing this node. Example 2: Input: head = [1,2,3,4] Output: [1,2,4] Explanation: The above figure represents the given linked list. For n = 4, node 2 with value 3 is the middle node, which is marked in red. Example 3: Input: head = [2,1] Output: [2] Explanation: The above figure represents the given linked list. For n = 2, node 1 with value 1 is the middle node, which is marked in red. Node 0 with value 2 is the only node remaining after removing node 1. Constraints: The number of nodes in the list is in the range [1, 105]. 1 <= Node.val <= 105

Day 61 of the Leetcode challenge: Remove Nth Node From End of List Challenge: Remove the nth node from the end of a singly linked list. Approach: Implemented a two-pointer technique with a fast pointer moving n steps ahead of the slow pointer. When the fast pointer reaches the end, the slow pointer is just before the node to be removed. Adjusted the next pointer of the slow node to skip the node to be deleted. This technique avoids the need to calculate the length of the list, achieving the task in a single pass. Letter Combinations of a Phone Number Challenge: Generate all possible letter combinations that a given phone number can represent. Approach: Used a recursive function to generate combinations. For each digit, the function iterates through its possible letters, appending each to a prefix string and recursing with the next digit. Base case occurs when the combination's length matches the input digits', adding the combination to the result list. This backtracking algorithm efficiently explores all possible letter combinations. Time Needed to Buy Tickets Challenge: Calculate the time required for a person at a given position in a queue to buy all their desired tickets. Approach: Iterated through the queue, simulating the ticket-buying process. Calculated the time based on the minimum tickets needed between the person at position k and others in the queue, adjusting for whether individuals are before or after position k. This method simulates the buying process without explicitly modeling the queue's state changes, providing an efficient way to find the total time needed.

This code showcases multiple applications of lambda functions. Firstly, it employs a lambda function to provide a default value for a function parameter. Secondly, it immediately invokes the lambda function within the function definition. Thirdly, it demonstrates how the lambda function captures and maintains the state of a static variable. Finally, it illustrates the recursive behavior of the lambda function, as the static variable within it is incremented each time the function is called.