Gray Code Generation using Reflection Method

🚀 Day 8 of #100DaysOfDSA Today’s problem: Longest Substring Without Repeating Characters 🧠 Problem Statement: Given a string, find the length of the longest substring without repeating characters. 💡 Approach: Sliding Window Technique Used two pointers (left & right) Maintained a HashSet to track characters Expanded window when unique Shrunk window when duplicate found ⚡ Key Learning: Efficient use of the sliding window helps reduce time complexity to O(n), which is crucial for optimizing string-based problems. 💻 Example: Input: "abcabcbb" Output: 3 ("abc") 🔥 This problem strengthened my understanding of: ✔️ Two-pointer technique ✔️ Hashing (Set/Map) ✔️ Optimizing brute force solutions Consistency is the key — small steps every day lead to big results 💪 #DSA #Java #CodingJourney #LeetCode #ProblemSolving #100DaysOfCode 🍁 Saidhanya Sree

🔥 DSA Challenge – Day 136/360 🚀 📌 Topic: Bit Manipulation 🧩 Problem: Number of 1 Bits (Hamming Weight) Problem Statement: Given an integer, return the number of set bits (1’s) present in its binary representation. 🔍 Example: Input: 6 Output: 2 Explanation: Binary of 6 → 110 → 2 set bits 💡 Optimized Approach (Brian Kernighan’s Algorithm): Instead of checking each bit one by one, we use a smart trick: n & (n - 1) removes the rightmost set bit in each iteration This reduces the number of operations to the number of set bits only ⚡ Time Complexity: O(k) (k = number of set bits) ⚡ Space Complexity: O(1) 🚀 Key Takeaway: Using bit manipulation can drastically optimize performance compared to brute force approaches. Always look for patterns in binary operations! #DSA #Coding #Java #BitManipulation #136DaysOfCode #LeetCode #ProblemSolving #SoftwareEngineering

Day 37 of showing up consistently 💻🔥 Solved Arithmetic Subarrays — a problem that really sharpened my understanding of subarrays and sequence patterns. 💡 Insight: Instead of checking order directly, sorting the subarray and verifying a constant difference makes the solution clean and efficient. ⚡ Runtime: 4 ms (100% 💯) 📊 Small optimizations → Big impact Every day = 1 step closer to mastery. #Day37 #LeetCode #DSA #Java #CodingJourney #Consistency #KeepGrinding

🚀 DSA Journey: 15/75 Completed 📌 Problem: Maximum Number of Vowels in a Substring of Given Length Today’s problem was a great example of the Sliding Window technique. 🔍 Key Idea: Instead of checking every substring (which is inefficient), we maintain a window of size k and: Add the next character to the window Remove the previous character Track the maximum number of vowels 💡 This reduces time complexity to O(n) — much better than brute force! 🧠 What I Learned: How to efficiently manage a fixed-size window Importance of updating values while sliding Avoiding unnecessary recalculations 🔥 Progress: 15 / 75 problems done — consistency is the real key! #DSA #CodingJourney #Java #LeetCode #100DaysOfCode #ProblemSolving

Day 32 of #50DaysLeetCode Challenge 💻🔥 Today I solved the “Rotate Image” problem using Java. 🔹 Problem: Given an n × n matrix, rotate the image 90° clockwise in-place (no extra matrix allowed). 🔹 Where people mess up: Trying to simulate rotation directly with extra space. That defeats the whole point of the problem. 🔹 Optimal Approach: 1. Transpose the matrix (swap rows & columns) 2. Reverse each row That’s it. Two clean steps. No overthinking. 🔹 Key Insight: Rotation isn’t magic — it’s just a combination of simple transformations. 🔹 Time Complexity: O(n²) 🔹 Space Complexity: O(1) 📌 What I learned: Most matrix problems look complicated until you break them into small predictable operations. If your approach feels messy, you’re probably doing it wrong. Simple > Clever. #Day32#LeetCode #Java #Matrix #DSA #CodingChallenge #ProblemSolving

✅ Solved LeetCode 217 — Contains Duplicate! Given an integer array nums, return true if any value appears at least twice. 🧠 My Approach: Sort + Linear Scan → Sort the array → adjacent duplicates are guaranteed to be neighbors → One pass to check if nums[i] == nums[i-1] → Time: O(n log n) | Space: O(1) 💡 Key Insight: Sorting brings duplicates side by side — no need for extra space like a HashSet. Trade time for space! ```java Arrays.sort(nums); for (int i = 1; i < nums.length; i++) { if (nums[i] == nums[i - 1]) return true; } return false; ``` 🔄 Alternative approaches: • HashSet → O(n) time, O(n) space • Brute force → O(n²) time (avoid!) Every problem teaches you a new trade-off. Keep grinding! 💪 #LeetCode #DSA #CodingInterview #Java #ProblemSolving #SoftwareEngineering #100DaysOfCode #Programming

📊 DSA Progress Update – Week 5 Over the past few days, I’ve been practicing array problems and improving my approach step by step. What I learned: • Starting with a brute force solution helps in understanding the problem clearly • Optimization becomes easier once the pattern is identified • Key techniques : - Two Pointers - Sliding Window - Prefix Sum - Kadane’s Algorithm Something new: Started learning Binary Search and understanding its basic approach. Plan: Continue practicing and get more comfortable with these concepts. Taking it one step at a time. #DSA #Java #LeetCode #Consistency #CodingJourney

🔥 Day 142/360 – Learning Something New Today 🚀 Most people miss this simple trick… But once you understand it, problems become much easier 👇 📌 Topic: Bit Manipulation 🧩 Problem: Single Number II 📝 Problem Statement: Find the element that appears once when all others appear three times 🔍 Example: Input: [2, 2, 3, 2] Output: 3 💡 Approach: Bit Manipulation (Bit Counting) ✔ Step 1 – Traverse all 32 bit positions ✔ Step 2 – Count how many numbers have that bit set ✔ Step 3 – If count % 3 == 1, set that bit in answer ⚡ Key Idea: Duplicate numbers contribute bits in multiples of 3, so taking modulo 3 isolates the unique number ⏱ Complexity: Time → O(n) Space → O(1) 📚 What I Learned: Bit-level thinking can simplify problems that look complex with normal counting 💬 Question for You: Can you solve this problem using XOR without counting bits? 🤔 #DSA #Java #Coding #ProblemSolving #InterviewPrep #LeetCode #TechJourney #142DaysOfCode

“Most people try to overcomplicate this one… but the simplest approach wins.” Day 69 — LeetCode Progress Problem: Height Checker Required: Given an array of student heights, return the number of indices where the heights are not in the expected non-decreasing order. Idea: If we sort the array, we get the expected order. Now just compare the original array with the sorted version — mismatches are the answer. Approach: Create a copy of the original array Sort the copied array Traverse both arrays: Compare elements at each index If they differ → increment count Return the count Time Complexity: O(n log n) Space Complexity: O(n) #LeetCode #DSA #Java #Arrays #Sorting #ProblemSolving #CodingJourney

✅ Solved: Anagram Palindrome Another step forward in sharpening problem-solving skills 🚀 🔍 Problem Insight: A string can be rearranged into a palindrome if at most one character has an odd frequency. Simple idea, but powerful when applied efficiently. 💡 Implemented using an optimized approach in Java: - Time Complexity: O(n) - Space Complexity: O(1) 📊 Result: ✔️ Test Cases Passed: 1113 / 1113 ✔️ Accuracy: 100% ✔️ Time Taken: 0.52s Small problem, but a good reminder that the right observation beats brute force every time ⚡ #DataStructures #Algorithms #Java #ProblemSolving #CodingJourney #DSA #TechGrowth