Converting String to Integer with LeetCode Challenge

🚀 Day 68 of #100DaysOfLeetcodeHard — LeetCode 2382: Maximum Segment Sum After Removals (Hard) My Submission:https://lnkd.in/g-X4k2Hd Today’s challenge was a Disjoint Set Union (Union-Find) problem with a clever reverse processing approach. 🧩 Problem Summary: We start with an array and remove elements one by one, needing to track the maximum segment sum of contiguous non-removed elements after each removal. Instead of simulating removals forward (which is difficult to track), we reverse the process — ✅ Start from an empty array and add elements back in reverse order. ✅ Use Union-Find (Disjoint Set) to merge adjacent active segments and maintain their sums dynamically. 💡 Approach: Each index starts as its own segment with rank[i] = nums[i] (used to store segment sums). When a new index is added, we union it with its active neighbors (if any). Track the maximum segment sum after each merge. 🧠 Key Concepts Used: Union-Find with path compression & rank to efficiently merge contiguous segments. Reverse iteration to avoid handling splits directly. 📈 Complexity: Time: O(n α(n)) ≈ O(n) (inverse Ackermann function for DSU) Space: O(n) A beautiful mix of data structures + reverse simulation + problem insight — one of those problems that truly sharpen algorithmic thinking. ⚡ #LeetCode #UnionFind #DSU #ProblemSolving #AlgorithmDesign #DataStructures #CodingChallenge #100DaysOfCode #LearningEveryday

📌 Day 39/150 – Rotate List (LeetCode #61) Today’s problem was a brilliant exploration of how subtle linked list operations can completely change the shape of a data structure! 🔁✨ The task? Given a linked list, rotate it to the right by k positions. Instead of shifting values, we must carefully adjust the links — no cheating with arrays! 😄 This problem reinforces how pointer manipulation and structural thinking work hand-in-hand in linked list questions. 🧠 🔹 Brute Force Idea A naive thought would be: 👉 Rotate one step at a time 👉 Move the last node to the front Repeat this k times. ✅ Easy to visualize ❌ Too slow (k rotations × n operations = inefficient!) ❌ Not scalable for large k 🔹 Optimal Approach – Smart Pointer Manipulation The elegant approach lies in understanding patterns: 👉 First, compute the length of the list. 👉 Connect the tail to the head — forming a temporary circle! 🔄 👉 Reduce k using modulo (k = k % length) 👉 Traverse to the correct breaking point. 👉 Break the circle to form the rotated list. You handle: 🔸 Circular linked list logic 🔸 Tail–head reattachment 🔸 Precise pointer breaking Very clean, very efficient! ✨ 🧠 Example Visualization Input: 1 → 2 → 3 → 4 → 5, k = 2 After rotation: 4 → 5 → 1 → 2 → 3 Only the links change — the magic of pointers! 🔧 ⏱️ Time & Space Complexity ComplexityValueTimeO(n) — just one traversalSpaceO(1) — done in-place 💡 Key Learning: This problem helps build confidence in: ✅ Recognizing patterns ✅ Using circular logic ✅ Efficient pointer manipulation ✅ Avoiding unnecessary extra space It’s one of those linked list questions that feels intimidating at first, but becomes satisfying once you see the strategy. Solving this opens the door to related problems like: 📍 Rotate Array 📍 Reverse Nodes in K-Group 📍 Swap Nodes in Pairs Linked lists may bend… but they don't break your confidence anymore. 💪😄 #150DaysOfCode #LeetCode #RotateList #LinkedLists #Pointers #DSA #CodingChallenge #SoftwareEngineering #LearningJourney #ProblemSolving 🚀🔥

🚀 LeetCode #168: Excel Sheet Column Title Ever wondered how Excel maps numbers to column titles? It's a bit like converting numbers to letters! Let's break it down. 🧩 Given a column number, we need to return the corresponding title in an Excel sheet. Check out how it works: Examples: Input: 1 -> Output: "A" Input: 28 -> Output: "AB" Input: 701 -> Output: "ZY" Input: 703 -> Output: "AAA" Key Idea: It’s not just a simple base-26 problem. Excel starts with 1 (not 0) for "A", so the logic needs a slight adjustment! Instead of the usual base-26 approach, think of each column as being an extra step in a “base-26” system where each character is shifted by 1. The Process: 1. Subtract 1 from the column number to shift it into a 0-based system. 2. Find the remainder when the number is divided by 26, which gives us the corresponding letter. 3. Divide the number by 26 and repeat the process until the number is 0. 4. Reverse the string at the end to get the final column title. Example Walkthrough: For N = 2002, after applying the steps above, we get the column title BXZ. Ready for more coding challenges? Join me on my journey to solve LeetCode problems! #LeetCode #ExcelColumnTitle #CodingChallenge #Algorithm #Tech #DataStructures #ProblemSolving #SoftwareDevelopment

#Day17 of #100DaysOfCoding Challenge 🧮 Problem: Perfect Sum Problem (Count subsets with given sum) 🧠 Problem Statement: Given an array arr[] of non-negative integers and an integer target, count all subsets of the array whose sum equals the target. 🧮 Examples: Input: arr = [5, 2, 3, 10, 6, 8], target = 10 Output: 3 Explanation: Subsets {5,2,3}, {2,8}, and {10} sum to 10. Input: arr = [2, 5, 1, 4, 3], target = 10 Output: 3 Explanation: {2,1,4,3}, {5,1,4}, {2,5,3}. Input: arr = [5,7,8], target = 3 Output: 0 Input: arr = [35,2,8,22], target = 0 Output: 1 Explanation: Only the empty subset sums to 0. ⚙️ Constraints: 1 ≤ n = arr.size() ≤ 10^3 0 ≤ arr[i] ≤ 10^3 0 ≤ target ≤ 10^3 💡 Approach (Dynamic Programming — Count of subset sums) Use a DP array dp[0..target] where dp[s] = number of subsets using processed items that sum to s. Initialization: dp[0] = 1 (empty subset gives sum 0) Transition for each number num: iterate s from target down to num: dp[s] += dp[s - num] Use reverse iteration to avoid reusing the same element multiple times in one iteration (0/1 subset). This gives O(n * target) time and O(target) space.

🔹 Day 66 of #100DaysOfLeetCodeChallenge 🔹 Problem: Subsets (Power Set) Focus: Backtracking + Recursion 💡 The Challenge: Generate all possible subsets of an array with unique elements. This includes the empty set and the complete set itself! 🧠 My Approach: Implemented backtracking to build subsets incrementally: Start with an empty subset and add it to results For each element, make a choice: include it or skip it Recursively explore all combinations from current index onwards Backtrack by removing the last added element to explore other paths 📊 Complexity Analysis: ⏳ Time: O(n × 2ⁿ) — 2ⁿ subsets, each taking O(n) to copy 💾 Space: O(n) — recursion depth 📌 Example: Input: nums = [1,2,3] Output: [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] 🎯 Key Takeaway: The power set problem elegantly demonstrates how backtracking can systematically explore all combinations. Each recursive call branches into two possibilities: include or exclude the current element. Classic decision tree visualization! 🌳 Pro tip: This pattern appears in many combinatorial problems — master it once, use it everywhere! Day 66/100 complete. Two-thirds through the journey! 🚀 #LeetCode #Algorithms #Backtracking #PowerSet #DSA #CodingChallenge #TechInterview #SoftwareEngineering #100DaysOfCode #LearnInPublic

🔥 Day 75 — “Arrays × DP: The Peaks of Precision.” 🌲⚙️ Theme: When structure meets optimization — arrays and dynamic programming align to reach new heights. 💻 What I Solved: 🔹 Highest Trees — (Hard) ✅ 150/150 — constructing balanced growth patterns through DP. 🔹 Weird Bitwise Queries — (Hard) ⏳ 88/150 — decoding binary puzzles with logical layering. 🔹 Product Identifier — (Hard) ✅ 150/150 — unique mapping of values with optimal traceability. 🔹 Maximizing Nutritional Value — (Hard) ✅ 150/150 — dynamic optimization meets real-world modeling. 🎯 Key Learnings: * Arrays give structure; DP adds memory — together they define 'efficiency with foresight'. * Bitwise logic often hides elegant mathematical simplicity. * Breaking big problems into smaller recurrences sharpens clarity and confidence. 📊 Progress Update: 🏆 Points: 33,440+ 🏅 Rank: 112 💬 From the coder’s desk: > “The deeper you dive into DP, the clearer logic becomes — > it’s not just about solving, it’s about *seeing patterns before they emerge*.” 🌊✨ Join me on Unstop 👉 https://lnkd.in/gRFmWUyA #100DaysOfCode #Day75 #CodingJourney #Unstop

2. Write a program to Print different number System in Rust. fn main() {   let number = 45; //let is a keyword to declare the Variable in Rust   println!("Decimal {}", number);   println!("Binary {:b}", number); // Just for comparison Purpose this act as a Format Speicifier as in C   println!("Hexadecimal {:x}", number);   println!("Octal {:o}", number);   println!("Right Aligned {:>5}", number);   println!("Zero Padded {:05}", number); } represented in different formats: {:b} → Binary format {:x} → Hexadecimal (lowercase) {:o} → Octal {:>5} → Right-aligned with width 5 {:05} → Zero-padded, width 5 O/p: Decimal 45 Binary 101101 Hexadecimal 2d Octal 55 Right Aligned  45 Zero Padded 00045

🚀 LeetCode Problem Spotlight: Rotate Image (90° Clockwise) I recently revisited one of my favorite matrix manipulation problems — “Rotate Image” (LeetCode #48) — and it reminded me how elegant simple logic can be when used effectively. 🧩 The Challenge Given an n x n matrix representing an image, the goal is to rotate it 90° clockwise — in place, without using any extra space. 💡 The Insight The trick lies in realizing that a rotation doesn’t require rebuilding the matrix — just transforming it cleverly. Here’s how: 1️⃣ Transpose the matrix — swap rows and columns. 2️⃣ Reverse each row — and just like that, the image is rotated! Two small transformations, one clean solution. ⚙️ Complexity ⏱ Time: O(n²) 💾 Space: O(1) 🧠 Takeaway This problem is a great reminder that complex outcomes often come from simple, well-structured steps. It’s less about memorizing algorithms and more about understanding the data flow behind them. How would you approach this problem — any creative twists or optimizations you’ve tried? Let’s discuss 👇

🔗 Day 75 of #100DaysOfCode 🔗 🌳 Problem: Binary Tree Postorder Traversal – LeetCode ✨ Approach: Implemented a recursive depth-first traversal that processes the left subtree, then right subtree, and finally the root node — perfectly matching the postorder pattern (Left → Right → Root). The solution is clean, intuitive, and highlights the elegance of recursion in tree traversal! 🌿 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — each node is visited exactly once 💾 Space Complexity: O(n) — recursion stack in the worst case (skewed tree) ✅ Runtime: 0 ms (Beats 100% 🚀) ✅ Memory: 43.07 MB 💡 Key Insight: Recursion beautifully mirrors the natural hierarchy of trees — by trusting the call stack, we achieve simplicity and clarity in solving even complex traversal problems. 🌱 #LeetCode #100DaysOfCode #ProblemSolving #DSA #BinaryTree #Recursion #AlgorithmDesign #CodeJourney #ProgrammingChallenge #LogicBuilding #Efficiency #CodingDaily

10 LeetCode 'hard' problems you can try solving (only attempt if you are good at the medium level) : 1. N-Queens (problem 51) Tests you on: Backtracking, recursion, and managing state in constraint problems. 2. Trapping Rain Water (problem 42) Tests you on: Two pointers, array manipulation, and maximizing values with constraints. 3. Merge k Sorted Lists (problem 23) Tests you on: Priority queues (heaps), linked list manipulation, and merging data streams. 4. Word Ladder (problem 127) Tests you on: Breadth-first search (BFS), graph traversal, and shortest path calculations. 5. Sliding Window Maximum (problem 239) Tests you on: Monotonic queues/deques, sliding window technique, and efficient window aggregation. 6. First Missing Positive (problem 41) Tests you on: In-place array manipulation, cyclic sort, and using indices as hash maps. 7. Text Justification (problem 68) Tests you on: String formatting, edge case handling, and clean code structure. 8. Integer to English Words (problem 273) Tests you on: Recursive decomposition, string manipulation, and case-by-case logic building. 9. Largest Rectangle in Histogram (problem 84) Tests you on: Monotonic stacks, area calculation, and optimal solution strategies. 10. Median of Two Sorted Arrays (problem 4) Tests you on: Binary search, partitioning logic, and cross-array median finding. What's one LeetCode hard problem you have tried solving or solved? Share it below. Follow for more!