Java Binary Search: Finding Peak Element

Day 4 of Java with DSA Journey 🚀 📌 Topic: Search Insert Position (LeetCode 35) 💬 Quote: "Binary Search is about more than finding a needle in a haystack; it's about knowing exactly where to put a new needle." ✨ What I Learned: 🔹 Power of the low Pointer: If the target isn’t found, low directly gives the correct insertion index. 🔹 Finding Position Even When Missing: Binary Search doesn’t just search — it tells you where the element belongs. 🔹 Efficient Gap Detection: Even for missing values, we maintain O(log n) efficiency. 🔹 Complexity: ⏱ Time: O(log n) 📦 Space: O(1) 🧠 Problem Solved: ✔️ Search Insert Position 💡 Key Insight: Binary Search helps determine the rank/position of a number in a sorted array — whether it exists or not ⚡ ⚡ Interview Insight (Post-Loop Behavior): 👉 When the loop ends (low > high): low → first index greater than target high → last index smaller than target 🎯 That’s why low = insert position 🔑 Takeaway: Binary Search is not just about finding — it's about positioning. Consistency is the real key 🔑 #DSA #LeetCode #Java #CodingJourney #BinarySearch #ProblemSolving #100DaysOfCode #Algorithms #TechLearning #Day4 #Array #MCA #lnct

🚀 Mastering Java Through LeetCode 🧠 Day 21 of My DSA Journey 📌 Problem Solved: Q.1657 – Determine if Two Strings Are Close 💡 Problem Insight: At first glance, this problem looks like a simple string comparison… But it actually tests your understanding of patterns, hashing, and transformations. We are allowed to: ✔ Swap characters (change order) ✔ Transform characters (swap frequencies) 🧠 Key Learning: Two strings are "close" if: ✅ They have the same set of characters ✅ Their frequency distribution matches (order doesn’t matter) 👉 That means: Order is irrelevant Only character presence + frequency pattern matters 🔍 Approach I Used: 1️⃣ Checked if lengths are equal 2️⃣ Counted frequency using arrays 3️⃣ Verified both strings have same unique characters 4️⃣ Sorted frequency arrays and compared ⚡ Example: word1 = "cabbba" word2 = "abbccc" ✔ Same characters → {a, b, c} ✔ Frequencies match after sorting → [1,2,3] 👉 Result: true Tech Stack: Java Concepts Covered: Hashing | Arrays | Frequency Count Takeaway: This problem taught me how to: Think beyond direct comparison Focus on data patterns instead of structure Consistency + Practice = Growth #LeetCode #DSA #Java #CodingJourney #100DaysOfCode #ProblemSolving #Developers #SoftwareEngineer #Learning #Growth #CDAC #PlacementPreparation #Tech

🚀 Mastering Time & Space Complexity in Java DSA When I started learning Data Structures & Algorithms in Java, the biggest mindset shift wasn’t coding… it was thinking in complexity. 📌 Time Complexity (⏱️) It tells how fast your code runs as input grows. O(1) → Constant (Best 👍) O(log n) → Logarithmic O(n) → Linear O(n log n) → Efficient sorting O(n²) → Slow (avoid when possible ⚠️) 📌 Space Complexity (💾) It tells how much memory your code uses. Efficient programs don’t just run fast — they also use less memory. 💡 Key Learnings: ✔️ Always analyze before optimizing ✔️ Nested loops ≠ always bad, but be careful ✔️ Trade-offs exist between time & space ✔️ Practice problems to build intuition 🔥 Current Focus: Improving problem-solving by writing optimized Java solutions and analyzing their complexity. Consistency > Motivation 💯 #Java #DSA #CodingJourney #TimeComplexity #SpaceComplexity #Programming #SoftwareEngineering

🚀 Day 40 / 180 – DSA with Java 🚀 📘 Topic Covered: Binary Exponentiation (Fast Power) 🧩 Problem Solved: Pow(x, n) Problem: Implement a function to calculate x raised to the power n, handling both positive and negative values of n. Approach: Used Binary Exponentiation to reduce time complexity. Repeatedly squared the base and halved the exponent, multiplying the result only when needed. Also handled negative powers by taking the reciprocal. Key Learning: ✔️ Optimizing from O(n) to O(log n) ✔️ Understanding divide-and-conquer in exponentiation ✔️ Handling edge cases like negative powers If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #ProblemSolving #Consistency 

🚀 Learning Java the Right Way Today, I practiced a popular DSA problem 👉 Container With Most Water 📌 Problem: Given an array of heights, find two lines that together can store the maximum amount of water. Example: Array → {1, 8, 6, 2, 5, 4, 8, 3, 7} Output → 49 ✅ 🔹 Key Learning: Instead of using brute force (O(n²)), I used the Two Pointer approach to solve it in O(n) time. 📌 Approach: Start with two pointers (left & right) Calculate area = min(height) × width Move the pointer with smaller height Repeat to find maximum area This problem helped me understand: ✔ Two Pointer technique ✔ Optimization over brute-force ✔ Logical decision making ✔ Real interview-level problem solving Learning when and how to optimize is what truly improves coding skills 💪 📌 Think smart • Optimize logic • Solve efficiently 🚀 #java #javafullstack #javadeveloper #corejava #codingjourney #coding

Day 10 of Java DSA Journey 🚀 📌 Problem: Power of Two (LeetCode 231) Most people solve this using loops: ➡️ Keep dividing by 2 until you reach 1 But today I learned something better: 👉 You can solve it in ONE line using bit manipulation 🤯 💡 Core Idea A number is a power of two if: ✔️ It has only one ‘1’ in its binary form Examples: 1 → 0001 2 → 0010 4 → 0100 16 → 10000 🧠 The Magic Trick 👉 n & (n - 1) This removes the rightmost set bit So: If result = 0 → only one bit was set → ✅ Power of Two Else → ❌ Not a power of two ⚡ Complexity ⏱ Time: O(1) 📦 Space: O(1) 🔥 Pro Tips (Interview Level) 💡 Tip 1: Always Check Positivity First n > 0 is mandatory — bit tricks fail for negative numbers. 💡 Tip 2: Understand, Don’t Memorize n - 1 flips: the rightmost 1 → 0 all bits after it → 1 That’s why the trick works. 💡 Tip 3: This Pattern Appears Everywhere The same trick is used in: Counting set bits Subset generation Low-level optimizations 👉 Learn it once, reuse forever. 💡 Tip 4: Alternative Trick (Even Cleaner) Another way: 👉 (n & -n) == n This isolates the lowest set bit. If it's equal to n, only one bit exists. 💡 Tip 5: Bitwise = Senior-Level Thinking Using bit manipulation shows: ✔️ You understand how data is stored ✔️ You can optimize beyond brute force 🔥 Real Insight This problem is not about checking powers… It’s about recognizing: 👉 Patterns in binary representation Once you see that, the solution becomes obvious. Consistency builds mastery 🔑 #DSA #LeetCode #Java #BitManipulation #CodingJourney #ProblemSolving #InterviewPrep #Day10 #BitManipulation #InterviewPrep #CleanCode #Array #Optimization #MCA #lnct #100DaysOfCode #SoftwareEngineering #Algorithms #InPlaceAlgorithms #TechLearning #JavaDeveloper

🚀 Day 26/45 – Exploring Searching Algorithms in Java On Day 26 of my Java learning journey, I focused on Searching Algorithms, which are essential for finding data efficiently. Searching is widely used in real-world applications, from simple programs to complex systems. 📚 What I Learned Today Today I learned: ✔ Linear Search and how it works step by step ✔ Binary Search and its efficiency ✔ Importance of sorted data in binary search ✔ Difference between linear and binary search 💻 Practice Work To apply my learning, I implemented: • Linear search to find elements in an array • Binary search using divide-and-conquer approach 🎯 Key Takeaway Understanding searching algorithms helps improve efficiency and performance in applications. Binary search, in particular, is very powerful when working with large datasets.Daily practice is helping me build strong problem-solving skills. #Java #Programming #LearningInPublic #CodingJourney #ProblemSolving #SoftwareDevelopment

🚀 Day 37 / 180 – DSA with Java 🚀 📘 Topic Covered: Arrays & Two-Pointer Technique 🧩 Problem Solved: Squares of a Sorted Array Problem: Given a sorted array of integers (including negatives), return a new array of the squares of each number, also sorted in non-decreasing order. Approach: Used a two-pointer approach from both ends of the array. Compared squares of elements and filled the result array from the end to maintain sorted order efficiently. Key Learning: ✔️ Handling negative values in sorted arrays ✔️ Using two-pointer technique for optimal solutions ✔️ Avoiding extra sorting to achieve O(n) time complexity If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #Arrays #ProblemSolving #Consistency 

🚀 Day 6/30 – Java + DSA :>> After a small 5-day gap, I restarted my learning journey today. Breaks can happen, but the important thing is to get back on track and keep moving forward. I’ll be recovering this gap very soon by staying consistent in the coming days. Today’s Topic: Time Complexity & Space Complexity (Theory) Today I focused on understanding how we measure the efficiency of algorithms in terms of time and memory. Key Concepts I Learned: • Time Complexity – How the running time of an algorithm grows as the input size increases. • Space Complexity – How much memory a program needs while running. :Three Important Notations in Time Complexity: • Big-O Notation (O) – Represents the worst case scenario, meaning the maximum time an algorithm can take. Example: Linear search in an array → O(n) • Omega Notation (Ω) – Represents the best case scenario, meaning the minimum time an algorithm can take. Example: Element found at the first position → Ω(1) • Theta Notation (Θ) – Represents the average case scenario, meaning the typical running time of an algorithm. ~Key Takeaway: Writing code that works is important, but writing efficient code is what really matters in Data Structures and Algorithms. #Java #DSA #CodingJourney #LearningInPublic #Consistency

Learning Java DSA: My Journey into Recursion 🚀 Recursion is one of those concepts that feels confusing at first… until it suddenly clicks. While learning Data Structures & Algorithms in Java, I recently spent time understanding recursion — and here’s what stood out to me: 🔹 Recursion is simply a function calling itself 🔹 Every recursive solution has two key parts: • Base Case (when to stop) • Recursive Case (how to move toward the solution) At first, problems like factorial, Fibonacci, or reversing an array felt tricky. But once I started visualizing the function call stack, things became much clearer. 💡 Key lesson: “If you can break a problem into smaller versions of itself, recursion might be the answer.” It’s still a work in progress, but I’m getting more comfortable with: ✔️ Dry running recursive calls ✔️ Understanding stack flow ✔️ Identifying base conditions Next goal: Mastering backtracking and optimizing recursion 🚀 If you’ve got tips, resources, or favorite recursion problems, feel free to share — always open to learning! #Solve 12 question #Java #DSA #Recursion #CodingJourney #LearningInPublic #SoftwareDevelopment