Add Two Numbers as Linked Lists in Java

Some linked list problems are all about reversing connections in a controlled range. 🚀 Day 115/365 — DSA Challenge Solved: Reverse Linked List II Problem idea: We need to reverse a portion of a linked list from position left to right, while keeping the rest unchanged. Efficient approach: Use in-place reversal with pointer manipulation. Steps: 1. Use a dummy node to simplify edge cases 2. Move a pointer to the node just before position left 3. Start reversing nodes one by one within the range 4. Adjust links so that reversed nodes are inserted at the correct position 5. Connect the reversed portion back to the list This avoids creating extra space and keeps the solution efficient. ⏱ Time: O(n) 📦 Space: O(1) Day 115/365 complete. 💻 250 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #LeetCode #LearningInPublic

Many linked list problems are about pointer manipulation and maintaining order. 🚀 Day 113/365 — DSA Challenge Solved: Merge Two Sorted Lists Problem idea: We are given two sorted linked lists, and we need to merge them into a single sorted list. Efficient approach: Use a two-pointer technique to compare elements and build the merged list. Steps: 1. Create a dummy node to simplify result construction 2. Compare current nodes of both lists 3. Attach the smaller node to the result 4. Move the corresponding pointer forward 5. Once one list ends, attach the remaining part of the other list This ensures the final list remains sorted. ⏱ Time: O(n + m) 📦 Space: O(1) Day 113/365 complete. 💻 252 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #LeetCode #LearningInPublic

Linked list problems often become simpler when you break them into clear steps. 🚀 Day 111/365 — DSA Challenge Solved: Remove Nth Node From End of List Problem idea: We need to remove the nth node from the end of a linked list. Efficient approach: Convert the problem into finding the (size − n)th node from the start. Steps: 1. Traverse the list to calculate its size 2. If n equals size → remove the head 3. Otherwise, find the node just before the target 4. Update pointers to remove the node This simplifies the problem using basic traversal and pointer manipulation. ⏱ Time: O(n) 📦 Space: O(1) Day 111/365 complete. 💻 254 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #LeetCode #LearningInPublic

Linked list problems often test how well you can manipulate pointers without losing track. 🚀 Day 114/365 — DSA Challenge Solved: Swap Nodes in Pairs Problem idea: We need to swap every two adjacent nodes in a linked list without changing values, only pointers. Efficient approach: Use a dummy node and carefully adjust pointers in pairs. Steps: 1. Use a dummy node pointing to head 2. Maintain a pointer prev before the current pair 3. Identify two nodes: first and second 4. Swap them by updating pointers 5. Move prev forward to the next pair This ensures all pairs are swapped correctly. ⏱ Time: O(n) 📦 Space: O(1) Day 114/365 complete. 💻 251 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #LeetCode #LearningInPublic

Sometimes linked list problems become simple when you convert them into a circular structure. 🚀 Day 116/365 — DSA Challenge Solved: Rotate List Problem idea: We need to rotate a linked list to the right by k positions. Efficient approach: Convert the list into a circular linked list, then break it at the right point. Steps: 1. Find the length of the list 2. Compute effective rotations → k % length 3. Connect the last node to the head (make it circular) 4. Find the new tail → (length − k) steps 5. Break the circle and update head This avoids repeated rotations and keeps it efficient. ⏱ Time: O(n) 📦 Space: O(1) Day 116/365 complete. 💻 249 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #LeetCode #LearningInPublic

🤖 Most developers use the JVM daily But rarely think about what happens between writing code and running it Here’s the simplified flow 👇 1️⃣ Compile javac converts .java into bytecode (.class / JAR) → platform independent 2️⃣ Load Classes are loaded on demand using the parent delegation model (Bootstrap → Platform → Application) 3️⃣ Link • Verify (safety) • Prepare (allocate memory) • Resolve (map references) 4️⃣ Initialize Static variables and blocks execute once 5️⃣ Memory • Heap → objects • Method Area → metadata • Stack → execution GC cleans unused memory 6️⃣ Execution • Interpreter runs bytecode • JIT compiles hot code → better performance over time 7️⃣ Native JNI allows calls to C/C++ when needed 💡 JVM = portability + memory management + runtime optimization 🔍 Production signals: Slow startup, GC pauses, warm-up gains → all JVM behavior #Java #JVM #BackendEngineering #SystemDesign #Performance

🚀 Day 69 of #100DaysOfCode Solved 98. Validate Binary Search Tree on LeetCode 🔗 🧠 Key Insight: A valid BST must satisfy: 👉 Left subtree → all values < root 👉 Right subtree → all values > root 👉 This must hold for every node (not just immediate children) ⚙️ Approach (Range Validation - DFS): 1️⃣ Start with full range: 🔹 (-∞, +∞) 2️⃣ For each node: 🔹 Check if min < node.val < max 🔹 If not → ❌ invalid BST 3️⃣ Recurse left: 🔹 Range becomes (min, node.val) 4️⃣ Recurse right: 🔹 Range becomes (node.val, max) 5️⃣ Return true only if both subtrees are valid ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(h) #100DaysOfCode #LeetCode #DSA #BinaryTree #BST #Recursion #DFS #Java #InterviewPrep #CodingJourney

Some subarray counting problems become much easier when we transform them into “at most” problems. 🚀 Day 101/365 — DSA Challenge Solved: Binary Subarrays With Sum Problem idea: We need to count the number of subarrays whose sum equals a given goal in a binary array. Efficient approach: Instead of directly counting subarrays with exact sum, we use a trick: subarrays with sum = goal = subarrays with sum ≤ goal − subarrays with sum ≤ (goal − 1) Steps: 1. Create a helper function to count subarrays with sum at most k 2. Use a sliding window to maintain a valid window where sum ≤ k 3. Add the number of valid subarrays ending at each index 4. Subtract results to get the exact count for the goal This converts the problem into an efficient sliding window solution. ⏱ Time: O(n) 📦 Space: O(1) Day 101/365 complete. 💻 264 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #SlidingWindow #LeetCode #LearningInPublic

𝐃𝐚𝐲 𝟖𝟒/𝟑𝟔𝟓 🚀 📌 𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐏𝐎𝐓𝐃: 𝐌𝐢𝐧𝐢𝐦𝐮𝐦 𝐃𝐢𝐬𝐭𝐚𝐧𝐜𝐞 𝐭𝐨 𝐓𝐲𝐩𝐞 𝐚 𝐖𝐨𝐫𝐝 𝐔𝐬𝐢𝐧𝐠 𝐓𝐰𝐨 𝐅𝐢𝐧𝐠𝐞𝐫𝐬 Continuing my 𝟑𝟔𝟓 𝐃𝐚𝐲𝐬 𝐨𝐟 𝐂𝐨𝐝𝐞 journey with a focus on 𝐩𝐫𝐨𝐛𝐥𝐞𝐦-𝐬𝐨𝐥𝐯𝐢𝐧𝐠, 𝐃𝐒𝐀, 𝐚𝐧𝐝 𝐜𝐨𝐧𝐬𝐢𝐬𝐭𝐞𝐧𝐜𝐲. 💪 🔎 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Model the keyboard as a grid. Use 3D DP where: dp[i][f1][f2] → minimum distance after typing first i characters with fingers at positions f1 and f2. At each step, choose which finger types the current character and update the cost. 🔍 𝐀𝐥𝐠𝐨𝐫𝐢𝐭𝐡𝐦 𝐮𝐬𝐞𝐝: Dynamic Programming with state (index, finger1, finger2). ⏱ 𝐓𝐢𝐦𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝐧 × 𝟐𝟔 × 𝟐𝟔) 🧠 𝐒𝐩𝐚𝐜𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝐧 × 𝟐𝟔 × 𝟐𝟔) 📈 𝐊𝐞𝐲 𝐭𝐚𝐤𝐞𝐚𝐰𝐚𝐲: When multiple agents (fingers) are involved, include their positions as part of the DP state. #LeetCode #LeetCodeDaily #365DaysOfCode #DSA #Java #DynamicProgramming #Strings #ProblemSolving #LearningInPublic 👨💻 🔗 Problem link in comments 👇

🚀𝐃𝐚𝐲 88/100 – 𝐀𝐝𝐝 𝐁𝐢𝐧𝐚𝐫𝐲 Today’s problem was Add Binary — a great exercise to understand how addition works at the binary level. 🔍 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠: Just like decimal addition, binary addition also uses a carry, but with base 2. 💡 𝐂𝐨𝐫𝐞 𝐈𝐝𝐞𝐚: Traverse both strings from right to left Add digits along with carry Append result and update carry  𝐖𝐡𝐲 𝐢𝐭 𝐰𝐨𝐫𝐤𝐬? Binary addition rules: 0 + 0 = 0 1 + 0 = 1 1 + 1 = 0 (carry 1) ⚡ 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Use two pointers (end of both strings) Add digits + carry Append (sum % 2) Update carry (sum / 2) Reverse the result ⏱️ 𝐓𝐢𝐦𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝐦𝐚𝐱(𝐧, 𝐦)) 📦 𝐒𝐩𝐚𝐜𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝐧) #Day88 #100DaysOfCode #Java #DSA #LeetCode #Strings #CodingJourney