Java Arrays Construction and Concatenation

🚀 Day 36 / 180 – DSA with Java 🚀 📘 Topic Covered: Binary Search (Peak Finding) 🧩 Problem Solved: Find Peak Element Problem: Given an array, find a peak element (an element greater than its neighbors) and return its index. Approach: Used Binary Search by comparing the middle element with its neighbors. Based on the increasing or decreasing slope, moved towards the side where a peak must exist, reducing the search space efficiently. Key Learning: ✔️ Applying binary search on unsorted arrays using patterns ✔️ Understanding how slope direction guides decisions ✔️ Solving peak problems in O(log n) time If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #BinarySearch #ProblemSolving #Consistency

🚀 Day 38 / 180 – DSA with Java 🚀 📘 Topic Covered: Strings & Two-Pointer Technique 🧩 Problem Solved: Is Subsequence Problem: Given two strings s and t, check whether s is a subsequence of t. Approach: Used two pointers to traverse both strings. Moved the pointer in s only when characters matched, and always moved the pointer in t, ensuring order is maintained. Key Learning: ✔️ Applying two-pointer technique on strings ✔️ Understanding subsequence vs substring ✔️ Writing clean and efficient O(n) solutions If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #Strings #ProblemSolving #Consistency

🚀 Day 41 / 180 – DSA with Java 🚀 📘 Topic Covered: Matrices & Marking Technique 🧩 Problem Solved: Set Matrix Zeroes Problem: Given a matrix, if an element is 0, set its entire row and column to 0. Approach: Used two auxiliary arrays to mark rows and columns that contain zeroes. In a second pass, updated the matrix by setting elements to zero based on the marked rows and columns. Key Learning: ✔️ Handling matrix-based transformations ✔️ Using extra space for clarity and simplicity ✔️ Breaking the problem into marking and updating phases If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #Arrays #ProblemSolving #Consistency

🚀 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 

🚀 Java DSA Progress Update I’ve solved 125/310 problems (~40%) as part of my structured Java DSA roadmap. ✔️ Strong in: Arrays, Strings, Linked Lists, Binary Search ⚡ Focusing next on: Heap, Graphs, Dynamic Programming, Sliding Window 📌 Approach: Pattern-based problem solving Time & space analysis Learning from mistakes Re-solving for retention 🎯 Goal: Become interview-ready in 30 days with strong problem-solving fundamentals. Consistent progress > perfection. #Java #DSA #LeetCode #ProblemSolving #SoftwareEngineering

🚀 100 Days Java + DSA Challenge | Day 2 Today’s focus was on strengthening my programming fundamentals by covering: 🔹 Operators in Java (Arithmetic, Relational, Logical, Assignment) 🔹 Conditional Statements (if, if-else, nested if, switch) Understanding how operators work and how decisions are made in code is essential for building strong logic. These concepts are the backbone of problem-solving in Data Structures and Algorithms. 💡 Practiced writing multiple programs using conditions and improved my logical thinking step by step. Consistency is the key — small progress every day leads to big results. #100DaysOfCode #Java #DSA #LearningJourney #Coding #SoftwareDevelopment

🚀 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 

🚀 DSA Learning Journey | Day 9 | Java Solved “125. Valid Palindrome.” 💡 Key Idea: Used Two Pointers while ignoring non-alphanumeric characters and comparing characters in a case-insensitive way. ⚙ Implementation • Language: Java • Time Complexity: O(n) • Space Complexity: O(1) 📚 Learning how two-pointer technique simplifies string validation problems. #Java #DSA #LeetCode #ProblemSolving #TwoPointers #JavaDeveloper

🚀 Day 39 / 180 – DSA with Java 🚀 📘 Topic Covered: Math & Simulation 🧩 Problem Solved: Count Operations to Obtain Zero Problem: Given two integers, repeatedly subtract the smaller number from the larger one until one of them becomes zero. Return the number of operations performed. Approach: Simulated the process by comparing both numbers and subtracting the smaller from the larger in each step, counting the number of operations until one becomes zero. Key Learning: ✔️ Understanding simulation-based problem solving ✔️ Applying basic math logic efficiently ✔️ Breaking problems into simple iterative steps If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #ProblemSolving #Consistency

✨ DSA in Java – Day 83 🚀 Today I solved an interesting problem on Binary Trees: 👉 Sum of Root to Leaf Binary Numbers 🌱 What I Learned: How to traverse a binary tree using DFS (Depth First Search) Building numbers along the path using: ➤ current = current * 2 + node.val Identifying leaf nodes and calculating final values Improving recursion understanding in tree problems 💡 Approach: Start from root with value 0 At each node, update the current number If it's a leaf node → add it to the final sum Traverse left and right recursively 📌 Key Insight: Binary tree problems become easier when you think of them as path-based problems rather than node-based problems. 💻 Consistency is the key! Day by day, step by step, getting stronger in DSA 💪 #DSA #Java #BinaryTree #CodingJourney #LeetCode #100DaysOfCode #WomenInTech #Consistency