chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-11-01-3217-Delete-Nodes-From-Linked-List-Present-in-Array/explanation.md

@@ -0,0 +1,32 @@
+# Delete Nodes From Linked List Present in Array (Medium)
+
+**Problem ID:** 3217  
+**Date:** 2025-11-01  
+**Link:** https://leetcode.com/problems/delete-nodes-from-linked-list-present-in-array/
+
+## Approach
+
+To solve the problem of deleting nodes from a linked list that have values present in a given array, we can follow a systematic approach:
+
+### Main Idea:
+The core idea is to traverse the linked list while maintaining a reference to the previous node. For each node, we check if its value exists in the provided array. If it does, we skip that node by adjusting the `next` pointer of the previous node. If it doesn't, we simply move the previous pointer to the current node. This way, we effectively remove nodes from the linked list without needing to create a new list.
+
+### Data Structures:
+1. **Linked List**: We are given a singly linked list where each node contains a value and a pointer to the next node.
+2. **Set**: To efficiently check if a node's value exists in the array `nums`, we can convert `nums` into a set. This allows for O(1) average time complexity for lookups.
+
+### Steps:
+1. Convert the input array `nums` into a set for fast membership checking.
+2. Initialize a dummy node that points to the head of the linked list. This helps simplify edge cases, such as removing the head node.
+3. Use two pointers: one (`prev`) to track the last node that was kept and another (`current`) to traverse the linked list.
+4. Iterate through the linked list:
+   - If the value of the `current` node is in the set, skip this node by setting `prev.next` to `current.next`.
+   - If the value is not in the set, move the `prev` pointer to `current`.
+5. Move the `current` pointer to the next node in each iteration.
+6. Finally, return the modified list starting from the node next to the dummy node.
+
+### Complexity:
+- **Time Complexity**: O(n + m), where n is the number of nodes in the linked list and m is the number of elements in the array `nums`. Creating the set takes O(m) time, and traversing the linked list takes O(n) time.
+- **Space Complexity**: O(m) for storing the elements of `nums` in a set.
+
+This approach efficiently modifies the linked list in a single pass while ensuring that we handle all edge cases, such as the removal of the head node or consecutive nodes with values in `nums`.

Medium/2025-11-01-3217-Delete-Nodes-From-Linked-List-Present-in-Array/solution.java

@@ -0,0 +1,31 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class ListNode {
+    int val;
+    ListNode next;
+    ListNode(int x) { val = x; }
+}
+
+public class Solution {
+    public ListNode deleteNodes(ListNode head, int[] nums) {
+        Set<Integer> toDelete = new HashSet<>();
+        for (int num : nums) {
+            toDelete.add(num);
+        }
+
+        ListNode dummy = new ListNode(0);
+        dummy.next = head;
+        ListNode current = dummy;
+
+        while (current.next != null) {
+            if (toDelete.contains(current.next.val)) {
+                current.next = current.next.next;
+            } else {
+                current = current.next;
+            }
+        }
+
+        return dummy.next;
+    }
+}

Medium/2025-11-01-3217-Delete-Nodes-From-Linked-List-Present-in-Array/solution.js

@@ -0,0 +1,23 @@
+class ListNode {
+    constructor(val = 0, next = null) {
+        this.val = val;
+        this.next = next;
+    }
+}
+
+var deleteNodes = function(head, nums) {
+    const numSet = new Set(nums);
+    let dummy = new ListNode(0);
+    let current = dummy;
+
+    while (head) {
+        if (!numSet.has(head.val)) {
+            current.next = head;
+            current = current.next;
+        }
+        head = head.next;
+    }
+    
+    current.next = null; // Terminate the new list
+    return dummy.next; // Return the modified list
+};

Medium/2025-11-01-3217-Delete-Nodes-From-Linked-List-Present-in-Array/solution.py

@@ -0,0 +1,19 @@
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+class Solution:
+    def deleteNodes(self, head: ListNode, nums: List[int]) -> ListNode:
+        nums_set = set(nums)
+        dummy = ListNode(0)
+        current = dummy
+        
+        while head:
+            if head.val not in nums_set:
+                current.next = head
+                current = current.next
+            head = head.next
+        
+        current.next = None
+        return dummy.next

README.md

@@ -265,3 +265,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-10-29 — [Smallest Number With All Set Bits](https://leetcode.com/problems/smallest-number-with-all-set-bits/) (Easy) → `Easy/2025-10-29-3370-Smallest-Number-With-All-Set-Bits`
 - 2025-10-30 — [Minimum Number of Increments on Subarrays to Form a Target Array](https://leetcode.com/problems/minimum-number-of-increments-on-subarrays-to-form-a-target-array/) (Hard) → `Hard/2025-10-30-1526-Minimum-Number-of-Increments-on-Subarrays-to-Form-a-Target-Array`
 - 2025-10-31 — [The Two Sneaky Numbers of Digitville](https://leetcode.com/problems/the-two-sneaky-numbers-of-digitville/) (Easy) → `Easy/2025-10-31-3289-The-Two-Sneaky-Numbers-of-Digitville`
+- 2025-11-01 — [Delete Nodes From Linked List Present in Array](https://leetcode.com/problems/delete-nodes-from-linked-list-present-in-array/) (Medium) → `Medium/2025-11-01-3217-Delete-Nodes-From-Linked-List-Present-in-Array`