Rotating Array in-place with O(1) space complexity

🕵️♀️ Day 67 of #100DaysOfCode 🕵️♀️ 🔹 Problem: The Two Sneaky Numbers of Digitville – LeetCode ✨ Approach: Designed a simple nested loop comparison to uncover the two “sneaky” duplicate numbers hiding in the array. By checking every pair and exiting early once both are found, the solution ensures clarity and efficiency with minimal extra logic! ⚡ 📊 Complexity Analysis: Time Complexity: O(n²) — double traversal for pair comparison Space Complexity: O(1) — constant space for result storage ✅ Runtime: 1 ms (Beats 100.00%) ✅ Memory: 45.58 MB 🔑 Key Insight: Sometimes, the best detective work in code isn’t about fancy tricks — it’s about precision, early exits, and keeping things simple yet sharp. 🕶️ #LeetCode #100DaysOfCode #ProblemSolving #DSA #AlgorithmDesign #Array #LogicBuilding #CodingDaily #CodeJourney #Efficiency #ProgrammingChallenge

🚀 Day 5/100 of #100DaysOfCode Challenge – DSA Edition Today I solved: 🔹 Subarray Product Less Than K – LeetCode (Medium) Explanation: 1️⃣ Start with two pointers, left and right, representing the current subarray window. 2️⃣ Maintain the product of elements within this window. 3️⃣ Expand right to include more elements. 4️⃣ If the product becomes equal to or exceeds k, shrink the window from the left until the product is less than k. 5️⃣ For each valid window, add the number of subarrays ending at right (which is right - left + 1). 6️⃣ Return the total count of such subarrays. This approach is efficient with time complexity O(n) because each element is processed at most twice (once when expanded and once when shrunk). #DSA #Arrays #Leetcode

Today I Learned: Floyd’s Cycle Detection (Tortoise & Hare) 🐢🐇 While solving the Happy Number problem on LeetCode, I came across one of the most elegant techniques — Floyd’s Cycle Detection. 🔹 What it does: Detects if there’s a loop in a sequence using two pointers — one slow, one fast. If they meet → a cycle exists. 🔹 Why it’s clever: No extra memory needed. Just pointer movement → O(1) space and O(n) time. 🔹 Where it’s used: - Detecting loops in Linked Lists - Avoiding infinite routing in network topologies - Tracking state repetitions in simulations - Identifying periodic system logs It’s a fundamental pattern that reappears in real-world systems — just hidden under different names. 💬 So, what did you learn today? #TodayILearned #LeetCode #DSA #FloydsCycleDetection #Algorithms #CodingJourney #ProblemSolving #TIL

💡 Day 77 of #100DaysOfCode 💡 🔹 Problem: Majority Element – LeetCode ✨ Approach: Used a sorting-based strategy to quickly identify the majority element. By sorting the array, the middle element naturally becomes the majority — simple, clean, and surprisingly powerful! 🌟 📊 Complexity Analysis: ⏱ Time Complexity: O(n log n) — due to sorting 💾 Space Complexity: O(1) — constant auxiliary space ✅ Runtime: 7 ms (Beats 39.33%) ✅ Memory: 55.75 MB 🔑 Key Insight: Sometimes the smartest solution is also the simplest — a little ordering can reveal the dominant pattern hiding in plain sight. ✨ #LeetCode #100DaysOfCode #ProblemSolving #DSA #AlgorithmDesign #CodingDaily #ProgrammingChallenge #Sorting #LogicBuilding #CodeJourney

🌟 Day 84 of #100DaysOfCode 🌟 🔹 Problem Solved: Check If All 1's Are at Least K Places Away – LeetCode Today’s challenge was all about precision, pattern detection, and distance validation within a binary array. The goal? Ensure every 1 is properly spaced and respects the minimum distance k. ✨ Approach: I iterated through the array, tracked the position of each 1, and checked the gap before encountering the next one. A simple but effective two-pointer style logic! 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — single pass through the array 💾 Space Complexity: O(1) — constant extra memory 🚀 Performance: ✔ Runtime: 1 ms (Beats 99.71%) ✔ Memory: 65.68 MB 🔑 Key Insight: Even a straightforward problem can sharpen your ability to detect patterns and handle constraints efficiently. Small details—like distances between bits—can make or break logic. #LeetCode #DSA #CodingChallenge #100DaysOfCode #ProblemSolving #BinaryArray #Algorithms #TechJourney #CodeEveryday #JavaCoding

🎯 Day 81 of #100DaysOfCode 🎯 🔹 Problem: Reverse Only Letters – LeetCode ✨ Approach: Used a two-pointer strategy to reverse only the alphabetic characters while keeping all non-letter characters in their original positions. By moving pointers inward and swapping only when both characters are letters, the solution stays efficient and elegant! 🔄✨ 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — each character visited at most once 💾 Space Complexity: O(n) — due to character array construction ✅ Runtime: 0 ms (Beats 100% 🚀) ✅ Memory: 42.96 MB 🔑 Key Insight: Sometimes, all you need is smart pointer movement — not everything needs to be reversed, only the right pieces. #LeetCode #100DaysOfCode #DSA #TwoPointers #StringManipulation #ProblemSolving #CleanCode #AlgorithmDesign #CodingChallenge

🎯 Day 9 of my #120DaysCodingChallenge 💡 Problem: Palindrome Number (LeetCode – Easy) Given an integer x, the task is to determine whether it reads the same backward as forward. For example: 121 → ✅ Palindrome -121 → ❌ Not a palindrome 10 → ❌ Not a palindrome 🧠 My Approach: I solved this problem using the string conversion method in C for clarity and simplicity. 🔹 First, I handled negative numbers since they can’t be palindromes. 🔹 Then, I converted the integer into a string using sprintf(). 🔹 Using two-pointer logic, I compared characters from the start and end of the string — moving inward until all pairs matched. 🔹 If all corresponding digits matched, the number was a palindrome. ⚙️ Time Complexity: O(n) ⚙️ Space Complexity: O(n) 💬 Takeaway: This problem reinforced how string manipulation and two-pointer logic can simplify palindrome checks. In future, I’ll explore the mathematical approach (without converting to string) for better space efficiency. #Day9 #CodingChallenge #LeetCode #CProgramming #PalindromeNumber #100DaysOfCode #LearningInPublic #ProblemSolving

🚀 Day 8 of My LeetCode Journey 🔢 Problem #167: Two Sum II - Input Array Is Sorted Today’s challenge was all about leveraging array properties efficiently. The task: given a sorted array, find two numbers that add up to a specific target and return their 1-based indices. 💡 Approach: Two Pointers Since the array is already sorted, we can avoid brute-force and use a two-pointer technique for O(n) time complexity. 🧠 Intuition Start with two pointers: ➡️ left at the beginning and right at the end. If the sum of the two numbers is greater than the target → move right left. If the sum is smaller → move left right. Continue until we find the exact pair. ⏱️ Time Complexity: O(n) 💾 Space Complexity: O(1)

🔥 Day 4 of #100DaysOfCode Today’s problem pushed me deeper into the world of hash maps and frequency analysis in C++ 💻⚙️ 🧩 Challenge: Given an array nums, return the total frequencies of all elements that occur with the maximum frequency. In simple terms — find which elements appear most often, and sum up all their occurrences. 💡 Key Learnings: Mastered the use of unordered_map for efficient frequency counting Learned how to identify and sum elements with the highest frequency Focused on clean, optimized, and readable code for better performance It’s fascinating how maps make complex counting problems so elegant and efficient! 🧠✨

Subtree of Another Tree: 2 Key Approaches! 🌳🔍 I cover the two main solutions for checking if one binary tree is a subtree of another: 1. DFS + Comparison: The straightforward O(N * M) approach. 2. String Serialization + KMP: The optimal, elegant O(N + M) solution that turns tree comparison into efficient string matching. Read the full article here: https://lnkd.in/d7_iR-94 #algorithms #leetcode #stringmatching #kmp #coding #binarytree