LeetCode 796: Rotate String Validation

#PostLog92 LeetCode 1704: Determine if String Halves Are Alike 🧵🔍 Another problem locked in, another concept strengthened ✅ This one leaned on clean string handling and a neat two-pointer approach to compare both halves efficiently ⚙️📊 Key takeaways from this problem: 🧩 Breaking problems into helper functions 🔍 Case normalization for simpler logic 🔄 Traversing from both ends with clarity Writing readable and maintainable code #LeetCode1704 #DetermineIfStringHalvesAreAlike #DSA #Java #ProblemSolving #LearningInPublic #CodingJourney

🚀 LeetCode Problem Solved: Two Sum II (Input Array is Sorted) Implemented an optimized solution in Java using the Two Pointer technique. Since the array is already sorted, we can efficiently adjust pointers based on the current sum and find the required pair without using extra space. ✅ Time Complexity: O(n) ✅ Space Complexity: O(1) Source Code : https://lnkd.in/ew2_GMw9 This problem is a great example of how understanding constraints (sorted input) helps in designing efficient solutions. #LeetCode #Java #DSA #TwoPointers #ProblemSolving #CodingJourney

🚀 LeetCode 1662 – Check If Two String Arrays are Equivalent Combine two string arrays using String.join("", array) and compare with .equals() — solves the problem in just one line! 💡 Returns false if any array is empty. #LeetCode #Java #DSA #ProblemSolving #CodingJourney #LearnToCode #SoftwareEngineer #DailyCoding

Day 8/30 – LeetCode #14 (Longest Common Prefix) | Java The challenge here wasn’t complexity, but handling edge cases cleanly. My initial thought was to compare characters column by column, but managing bounds made the logic harder to read. Using the first string as a reference prefix and gradually shrinking it with substring() until it matched all other strings simplified the solution. The startsWith() check kept the code readable while maintaining correctness. This problem reinforced how clarity in string manipulation often matters more than clever logic. #LeetCode #Java #DSA #Strings #ProblemSolving #Consistency #LearningInPublic

#day280 of #1001daysofcode problem statement (0085): Maximal Rectangle. For each row, I converted the matrix into a histogram of consecutive 1s and didn't change the Largest Rectangle in Histogram code which i uploaded earlier. Key takeaway: -> Break problems into familiar subproblems   -> Reusability of concepts matters more than memorizing solutions   -> In histogram-based solutions, resetting height on '0' is crucial   #DSA #Java #LeetCode #ProblemSolving Shivam Mahajan #leetcode #1001daysofcode

Day 3 of #120DaysOfCode🚀 📌Problem: Replace Elements with Greatest Element on Right Side 📌Language: Java 🔍Approach 1. Maintain a variable maxRight 2. Initially set it to -1 (for last element) 3. Traverse from the end 4. For each element . Save current value . Replace it with maxRight . Update maxRight ⏱️Time & Space Complexity Time Complexity: O(n) Space complexity: O(1) #120DaysOfCode #Day3 #Java #Arrays #DSA #ProblemSolving #Consistenncy #LearningEverday #LearninhPublic #Leetcode

🚀 Day 66 of #100DaysOfCode | Top K Frequent Elements Solved Top K Frequent Elements using an efficient Bucket Sort–based approach in Java. Approach used: Count the frequency of each element using a HashMap Create a bucket array where the index represents frequency Traverse the buckets from highest to lowest frequency to collect the top k elements Why this approach is efficient: No need to sort the entire array Makes use of the frequency range (1 → n) Works well even for large inputs Time & Space Complexity: Time: O(n) Space: O(n) Key takeaways: Bucket Sort is extremely useful for frequency-based problems Understanding constraints leads to optimal solutions Clean logic beats overcomplicated code Consistency is the real win. On to Day 68 💪 #Day67 #DSA #Java #LeetCode #ProblemSolving #CodingJourney #Consistency

Day 8/100 – LeetCode Challenge 🚀 Problem: Implement strStr() Approach: Checked every possible starting index in haystack Matched characters one by one with needle Time Complexity: O(n × m) Space Complexity: O(1) Key takeaway: Brute-force solutions are fine when constraints allow them. Understanding the basic approach comes before optimization. #LeetCode #100DaysOfCode #DSA #Java #ProblemSolving #100DaysOfLeetCode

#day283 of #1001daysofcode problem statement (0150): Evaluate Reverse Polish Notation. //Worked on Reverse Polish Notation today. This problem stays simple because of one key constraint: “The input represents a valid arithmetic expression in a reverse polish notation.” Key takeaway: -> Constraints can drastically simplify logic   -> Stack is the natural fit for RPN   -> Read constraints carefully   #DSA #Java #LeetCode #ProblemSolving Shivam Mahajan #leetcode #1001daysofcode

🚀Day 5 of #120DaysOfCode 📌 Problem: Height Checker 📌 Language: Java 🔍Approach(Two Pointer Technique) 1. make a copy of heights 2. Sort the copy --> this becomes expected 3. Traverse both arrays 4. Count indices where values differ 🔥 Key Insight 1. Create the expected order by sorting a copy of heights 2. Compare both arrays index by index 3. Count mismatches ⏱️ Time and Space Complexity Time Complexity: O(n log n) Space complexity: O(n) 🔥One problem closer to mastery #120DaysOfCode #Day5 #Java #Array #Leetcode #ProblemSolving #Consistency #LearningEveryday #LearningPublic #DSA