Rotate Image in-place with Matrix Transpose and Reverse

hi connections I just moved from Maximum Subarrays to LeetCode 167: Two Sum II. The challenge? Find two numbers that hit a target sum. The "cheat code"? The input array is already sorted. When you see "Sorted Array," your mind should immediately go to Two Pointers. The Strategy: Left Pointer: Starts at the beginning (smallest values). Right Pointer: Starts at the end (largest values). The Logic: If the sum is too low, nudge the left pointer up. If it’s too high, slide the right pointer down. Why I love this approach: Zero Extra Space: Unlike the original Two Sum, you don’t need a Hash Map. O(1) space. Speed: You only pass through the data once. O(n) time. Simplicity: It’s clean, readable, and highly optimized. Programming isn't just about solving the problem; it's about finding the most elegant way to do it by leveraging the constraints you're given. #Coding #DataStructures #Algorithms #TwoSum #Python #LeetCode #SoftwareEngineering #TwoPointers

❄️ takeUforward — Day 22 ✅ Rearrange Array by Sign | Two Pointer Approach | LeetCode Today I solved the Rearrange Array Elements by Sign problem, which focuses on array manipulation and index control — a common interview pattern. 📌 Problem Statement Given an array nums containing equal number of positive and negative integers, rearrange the array such that: Positive numbers are placed at even indices Negative numbers are placed at odd indices Maintain the relative order of elements 🚀 Optimal Approach — Index Placement (Two Pointer Style) 💡 Idea • Use two pointers: pos starting at index 0 for positive numbers neg starting at index 1 for negative numbers • Traverse the array once • Place elements directly at correct indices in a new array ⏱ Complexity • Time: O(n) • Space: O(n) 📌 Key Learning This problem reinforces how index-based placement can simplify logic and avoid unnecessary swaps or nested loops. 🚀 Day 22 completed — strengthening array traversal and positioning logic #DSA #LeetCode #Python #ProblemSolving #CodingJourney #RestartDSA #100DaysOfCode #DailyCoding #Arrays Yaswanth Kumar D takeUforward

💻 Day 17: Multiple Approaches to Problem Solving Today I practiced solving the same problems using different approaches to improve my problem-solving depth. 🔹 Union of Two Sorted Arrays(Codestudio) • Brute force approach T.C.=>O(n+m) S.C.->O(m) • Optimal approach: two-pointer T.C.=>O(n+m) S.C.->O(1) 🔹 Missing Number Problem(Leetcode-268 ,Code Studio) • Brute force T.C.=>O(N*N) S.C.->O(1) • Approach: Hashing T.C.=>O(2N) S.C.->O(N) • Approach: Sum formula T.C.=>O(N) S.C.->O(1) • Approach: XOR approach T.C.=>O(2N) S.C.->O(1) 🧠 Key takeaways: • Brute force helps understand the problem clearly • Optimized solutions reduce time and space complexity • Different approaches sharpen interview thinking 🚀 Next up: More array problems using patterns #striversa2zdsasheet #leetcode #takeuforward #rajvikramaditya #LearningInPublic #DSA #ProblemSolving #Arrays #Python

Day 76 of #100DaysOfLeetCode Today’s challenge focused on matrix optimization using prefix sums — a great example of turning brute force into an efficient solution. 🟨 Maximum Side Length of a Square with Sum ≤ Threshold (LeetCode 1292) We need to find the largest square submatrix such that: ✔ The sum of all its elements ≤ threshold ✔ Return the maximum possible side length 🧠 My Approach Built a 2D prefix sum array Used it to calculate any submatrix sum in O(1) Checked square sizes efficiently to find the maximum valid one This problem shows how preprocessing can drastically reduce complexity. 💡 What I Learned Prefix sums are extremely powerful for grid problems Brute force becomes practical after optimization Many matrix problems reduce to smart range queries 📊 Complexity Analysis Time Complexity: O(m × n × min(m, n)) Space Complexity: O(m × n) ✅ Day 76 Summary Simple idea. Strong technique. Clean implementation. Progressing steadily toward 100. 🚀 On to Day 77. #100DaysOfLeetCode #Day75 #LeetCode #PrefixSum #Matrix #DynamicProgramming #DSA #ProblemSolving #Python #CodingJourney #AdityaCodes

Day 75 of #100DaysOfLeetCode Today’s challenge focused on matrix optimization using prefix sums — a great example of turning brute force into an efficient solution. 🟨 Maximum Side Length of a Square with Sum ≤ Threshold (LeetCode 1292) We need to find the largest square submatrix such that: ✔ The sum of all its elements ≤ threshold ✔ Return the maximum possible side length 🧠 My Approach Built a 2D prefix sum array Used it to calculate any submatrix sum in O(1) Checked square sizes efficiently to find the maximum valid one This problem shows how preprocessing can drastically reduce complexity. 💡 What I Learned Prefix sums are extremely powerful for grid problems Brute force becomes practical after optimization Many matrix problems reduce to smart range queries 📊 Complexity Analysis Time Complexity: O(m × n × min(m, n)) Space Complexity: O(m × n) ✅ Day 75 Summary Simple idea. Strong technique. Clean implementation. Progressing steadily toward 100. 🚀 On to Day 76. #100DaysOfLeetCode #Day75 #LeetCode #PrefixSum #Matrix #DynamicProgramming #DSA #ProblemSolving #Python #CodingJourney #AdityaCodes

🚀 #DAY74 LeetCode Problem #1200 – Minimum Absolute Difference 🧩 Problem Summary Given a list of distinct integers, the goal is to find all element pairs whose absolute difference is the minimum possible and return them in sorted order. 🧠 How It Works First, sort the array to bring close values together Scan once to compute the minimum difference between adjacent elements Scan again to collect all pairs that match this minimum difference This approach leverages the fact that in a sorted array, the smallest difference must occur between neighboring elements. 📘 What I Learned ✔ Why sorting simplifies difference-based problems ✔ How breaking the task into two passes improves clarity ✔ Turning mathematical observations into efficient logic ✔ Writing clean and readable solutions even when performance isn’t maxed 📊 Performance ⏱ Runtime: 95 ms 💾 Memory: 21.57 MB ✅ 38 / 38 testcases passed 📌 Small optimizations, big clarity — consistency is the real win. #LeetCode #DSA #Algorithms #ProblemSolving #Python #CodingPractice #DataStructures #TechJourney #100DaysOfDSA #LearningByDoing #Consistency #InterviewPrep #CompetitiveProgramming

Day 37 of 365 days of code I tried solving a problem that I couldn't solve during the recent leetcode contest. The mistake I made was overthinking about what approach to use while solving the problem that I struggled with. literally I was bruteforcing my brain to find a soln🗿. after the contest i realised it was a simple problem lol, let me explain what the question is Qn 1) Merge adjacent equal elements You must repeatedly apply the following merge operation until no more changes can be made: If any two adjacent elements are equal, choose the leftmost such adjacent pair in the current array and replace them with a single element equal to their sum. After each merge operation, the array size decreases by 1. Repeat the process on the updated array until no more changes can be made. Return the final array after all possible merge operations. Example 1: Input: nums = [3,1,1,2] Output: [3,4] Explanation: The middle two elements are equal and merged into 1 + 1 = 2, resulting in [3, 2, 2]. The last two elements are equal and merged into 2 + 2 = 4, resulting in [3, 4]. No adjacent equal elements remain. Thus, the answer is [3, 4]. #365daysOfCode #NeetCode #leetcode #DSA #python #LeetCode #ProblemSolving #Algorithms

hi connections I just tackled LeetCode 53: Maximum Subarray using Kadane’s Algorithm. There’s something so satisfying about mapping out the logic by hand before hitting the keyboard. The core decision at every index? ✅ Start fresh: Is the current number bigger than the total sum so far? ✅ Keep going: Does adding the current number improve the streak? My logic: maxSum: Decides whether to restart or continue the subarray. maxSumSoFar: Tracks the "all-time high" score. Quick Tip: Watch out for variable names! I spent a minute debugging a NameError because my notes said a, but the function expected nums. Even the best logic needs a bit of syntax TLC. Efficiency: Time: O(n) Space: O(1) #SoftwareEngineering #LeetCode #Coding #Python #Algorithms #ProblemSolving

DSA Daily — Hashing Pattern LeetCode 349: Intersection of Two Arrays Day 14 of staying consistent with problem solving Today’s problem was a simple but important example of how sets simplify array problems when uniqueness is a requirement. We’re given two arrays and asked to return their intersection — with no duplicate elements in the result. This problem clearly signals the use of hashing. Key observations: - The result must contain unique elements only - Order does not matter - Fast lookup is more important than maintaining positions Core idea: - Convert one array into a set to remove duplicates and enable O(1) lookup - Traverse the second array - If an element exists in the set, add it to the result set - Using a set for the result automatically ensures uniqueness. Complexity: Time: O(n + m) Space: O(n + m) (sets for lookup and result) Sets are especially useful for intersection-type problems on arrays. This problem fits well with earlier hashing-based questions and reinforces how choosing the right data structure can make solutions both cleaner and more efficient. On to the next one 🚀 #DSADaily #Hashing #LeetCode #ProblemSolving #Python

Today’s focus was a LeetCode Easy problem that tests real logical discipline, not tricks. 🔹 LeetCode #9 – Palindrome Number At first glance, this looks trivial. It isn’t. The task is simple: Check whether a number reads the same forward and backward. What actually matters while solving it: Negative numbers must be rejected immediately The original value must be preserved before mutation Digits must be extracted and rebuilt correctly Loop termination has to be precise The approach I used: Reverse the number digit by digit using modulo and integer division Compare the reversed value with the original number The logic is straightforward, but any missed condition silently breaks the solution. Key takeaway: Easy problems don’t fail because of complexity. They fail because of careless edge-case handling. Alongside this, I’m also solving smaller logic-building problems focused on: Conditional branching Boundary validation Correct ordering of conditions These reinforce the same thinking from a different angle. 🔗 GitHub Repository (all solutions): 👉https://lnkd.in/d5J4MA8q #LeetCode #Python #ProblemSolving #LogicBuilding #BackendDevelopment #LearningInPublic