Rotate Linked List to Right by K Positions

🚀 LeetCode #Potd 1895. Largest Magic Square 🧩✨ Problem in one line: Find the largest k×kk \times kk×k subgrid where every row, every column, and both diagonals sum to the same value — a true magic square hidden inside the grid. 🧠 Core Strategy (what actually worked): The winning move was prefix sums. Precompute row-wise and column-wise prefix sums to query any row or column sum in O(1). Then, for every possible top-left cell, try the largest possible square first and validate it efficiently by checking all rows, columns, and both diagonals against a single target sum. Early pruning saves time; math does the heavy lifting. ⚙️ Why this solution matters: Brute force alone would choke here. Prefix sums turn repeated summation into constant-time checks, making the solution scalable and clean. This approach balances correctness with performance — exactly what grid-based interview problems demand. 📊 Performance Snapshot: Runtime: 6 ms (Beats 85.88%) Memory: 46.55 MB Time Complexity: O(m · n · min(m, n)) Space Complexity: O(m · n) 💡 Takeaway: Magic squares aren’t about tricks — they’re about structure. When grids are involved, prefix sums are a power tool, not an optimization. Master them, and half of 2D DSA problems start looking very manageable. #LeetCode #LeetCodeDaily #MediumProblems #DataStructures #Algorithms #PrefixSum #GridProblems #DSA #ProblemSolving #Java #JavaDeveloper #CompetitiveProgramming #CodingInterview #SoftwareEngineering #ComputerScience #TechCareers #InterviewPreparation #DeveloperJourney #DailyCoding

✏️ DSA Diary Day 17/100 📐📊: Solving LeetCode’s “Separate Squares” 🚀✨ Today I worked on a Binary Search + Geometry Optimization problem on LeetCode 🔥👇 👉 Separate Squares This problem beautifully shows how binary search on answers can be used to balance geometric areas efficiently 🧠💡 🔹 My Approach 🛠️🧠 I used Binary Search on the Y-axis to find the line that splits the total square area into two equal halves 🔽👇 🔸 Step 1: Define the Search Space 📌 I searched between: L = 0 and R = 1e9 Each mid value represents a horizontal cutting line on the Y-axis. 🔸 Step 2: Area Calculation 🔍 For every square: 1️⃣ If the square is completely below the line → Add its full area to Lower Area (LA) 2️⃣ If the square is completely above the line → Add its full area to Upper Area (UA) 3️⃣ If the line passes through the square → Split the area proportionally using geometry This ensures accurate area distribution 📐 🔸 Step 3: Binary Search Decision 🧮 If: LA ≥ UA → Move the search downward Else → Move the search upward After enough iterations, we get the exact Y-coordinate that balances both areas 🎯 #LeetCode 🚀 #Java ☕ #DSA 🧠 #BinarySearch 📊 #ProblemSolving 💡 #CodingChallenge 💻 #100DaysOfCode 🔥 #DSADiaryByRethanya ✨ #Geometry 📐 #Optimization 🧩 #LearnInPublic 📢 #TechJourney 🚀

🚀LeetCode Daily Challenge 🧩 Problem: Number of Ways to Paint N × 3 Grid You are given an integer n, representing the number of rows in a 3-column grid. You need to paint the grid using 3 different colors such that: ✔ No two adjacent cells in the same row have the same color ✔ No two adjacent cells in the same column have the same color 🎯 Goal: Return the total number of valid ways to paint the grid, modulo 10⁹ + 7. 🧠 Key Intuition Each row can be painted in only 12 valid color patterns that satisfy the row constraint. The problem becomes a row-by-row transition problem: A pattern in the current row is valid only if no column color matches the pattern in the previous row. This forms a classic Dynamic Programming with State Transitions problem: State → (row, previousPattern) Transition → Try all compatible patterns for the next row Memoization avoids recomputing overlapping subproblems, making the solution efficient. 🛠 Approach Predefine all 12 valid color patterns for a single row. Use DP + recursion: dp[row][prevPattern] stores the number of ways to paint from row onward. For each row: Try all patterns different from the previous one. Ensure no column color clashes with the previous row. Base case: When all rows are painted → return 1. Sum all valid configurations starting from row 0. 📈 Complexity Analysis Time Complexity: O(n × 12 × 12) ≈ O(n) Space Complexity: O(n × 12) 🔗 Problem https://lnkd.in/dk9hb-m7 💻 Solution https://lnkd.in/dA6cvig8 #LeetCode #Cpp #DSA #DynamicProgramming #Memoization #Recursion #Grids #Combinatorics #ProblemSolving #CodingChallenge #LeetCodeDailyChallenge #Algorithms

LeetCode 1343 – Number of Sub-arrays of Size K and Average ≥ Threshold looks easy… day 5 until performance matters. What clicked for me 👇 Instead of recalculating the sum every time: Maintain a running window sum Add the new element Remove the left element Compare in O(1) Why this matters: ❌ Brute force → O(n²) → TLE ✅ Sliding Window → O(n) → Accepted This problem forced me to stop thinking like a beginner and start thinking in patterns. If you’re preparing for: Product-based companies Interviews where optimization matters 👉 Sliding Window is non-negotiable I’m documenting my DSA journey daily — not for motivation, but for discipline.#LeetCode #DataStructures #Algorithms #SlidingWindow #DSA #JavaDeveloper #CodingInterview #ProblemSolving #SoftwareEngineering #100DaysOfCode #LearnInPublic #CodingJourney

🔥 Day 289 - Daily DSA Challenge! 🔥 Problem: ✏️ Edit Distance Given two strings word1 and word2, return the minimum number of operations required to convert word1 into word2. Allowed operations: • Insert a character • Delete a character • Replace a character 💡 Key Insights: 🔹 This is a classic Dynamic Programming problem on strings. 🔹 We compare prefixes of both strings to build the solution. 🔹 At each step, we choose the minimum cost among insert, delete, and replace. 🔹 If characters match → no operation needed. ⚡ Optimized Plan (DP): 1️⃣ Create a DP table dp[m+1][n+1].  • dp[i][j] = minimum edits to convert word1[0…i-1] → word2[0…j-1]. 2️⃣ Base cases:  ✔ Converting to empty string → only deletions or insertions. 3️⃣ For each character pair: if word1[i-1] == word2[j-1] dp[i][j] = dp[i-1][j-1] else dp[i][j] = 1 + min( dp[i-1][j-1], // replace dp[i-1][j], // delete dp[i][j-1] // insert ) 4️⃣ Final answer → dp[m][n]. 🔥 A foundational DP problem that appears in many real-world applications. ✅ Time Complexity: O(m × n) ✅ Space Complexity: O(m × n) 💬 Challenge for you: 1️⃣ Can you optimize this to O(n) space using a rolling array? 2️⃣ How would you modify it to print the actual sequence of edits? #DSA #DynamicProgramming #Strings #LeetCode #EditDistance #CodingChallenge #ProblemSolving #KeepCoding #100DaysOfCode

Headline: Keep It Simple: The Power of Sorting! 📉🚀 LeetCode #1464 – Maximum Product of Two Elements #DSAwithEdSlash | edSlash | LeetCode | Day 8/100 Week 2 is here! 🚀 For today’s problem, I focused on writing clean, readable code using C++ STL (Standard Template Library). The goal was to find the maximum product of two elements, which logically means finding the two largest numbers. 💡 Technical Approach: Instead of managing complex conditional logic, I used a Sorting Approach: Sort: Utilized std::sort() to arrange the array in ascending order. Access: Immediately accessed the last two elements (nums[n-1] and nums[n-2]) since they are guaranteed to be the maximums. Compute: Applied the required formula (max-1) * (second_max-1) and returned the result. 📊 Complexity Analysis: Time: O(N log N) — Dominated by the sorting algorithm, but extremely efficient to write. Space: O(1) — Solved in-place without using extra arrays. 🧠 Key Takeaways: Readability: Sometimes the best code is the one that is easiest to read and debug. STL Power: Mastering built-in functions like sort() is a superpower in C++. 👇 Discussion: Do you prefer the raw speed of a linear scan O(N) or the readability of sorting O(N log N) for Easy problems? Let me know! #LeetCode #DataStructures #Algorithms #Cpp #ProblemSolving #100DaysOfCode #CodingLife #edSlash #CareerGrowth

🚀LeetCode Daily Challenge 🧩Problem: Max Dot Product of Two Subsequences You are given two integer arrays nums1 and nums2. You need to choose non-empty subsequences from both arrays such that their dot product is maximized. 🎯 Goal: Return the maximum dot product that can be obtained from any valid pair of subsequences. 🧠 Key Intuition This is a Dynamic Programming problem with choices at each index: We can either pair nums1[i] with nums2[j] Or skip an element from either array Important observation: Since subsequences must be non-empty, we cannot default to 0 Negative values matter, so we initialize invalid states with a very small number At each state (i, j), we consider: Taking both elements → nums1[i] × nums2[j] Extending a previous subsequence Skipping an element from either array 🛠 Approach Use recursion + memoization Define dp[i][j] as the maximum dot product starting from indices i and j Transitions: Take current pair and continue Skip from nums1 Skip from nums2 Base case ensures at least one pair is chosen 📈 Complexity Analysis Time Complexity: O(m × n) Space Complexity: O(m × n) 🔗 Problem https://lnkd.in/d4EJeckq  💻 Solution https://lnkd.in/dgxyD7Uy #LeetCode #Cpp #DSA #DynamicProgramming #Memoization #Recursion #Arrays #ProblemSolving #CodingChallenge #LeetCodeDailyChallenge #Algorithms

🚀 𝗗𝗮𝘆 𝟳𝟯 𝗼𝗳 𝗺𝘆 #𝟭𝟬𝟭𝗗𝗮𝘆𝘀𝗢𝗳𝗖𝗼𝗱𝗶𝗻𝗴 𝗷𝗼𝘂𝗿𝗻𝗲𝘆 Explored the 𝗙𝗹𝗼𝘆𝗱–𝗪𝗮𝗿𝘀𝗵𝗮𝗹𝗹 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺, an elegant dynamic programming approach to find all-pairs shortest paths in a graph. What I focused on today: 🧠 Understanding the DP state: shortest path from i → j via intermediate nodes 🔁 Triple loop intuition: fixing an intermediate node k before updating all (i, j) pairs 📊 Building and updating the distance matrix step by step ⚖️ Comparing Floyd–Warshall with Dijkstra and Bellman–Ford for different graph scenarios This algorithm really highlights how DP + graphs come together beautifully for dense graphs. 𝘘𝘶𝘰𝘵𝘦 𝘰𝘧 𝘵𝘩𝘦 𝘋𝘢𝘺: “𝘚𝘰𝘮𝘦𝘵𝘪𝘮𝘦𝘴 𝘴𝘰𝘭𝘷𝘪𝘯𝘨 𝘦𝘷𝘦𝘳𝘺 𝘱𝘢𝘵𝘩 𝘢𝘵 𝘰𝘯𝘤𝘦 𝘪𝘴 𝘴𝘪𝘮𝘱𝘭𝘦𝘳 𝘵𝘩𝘢𝘯 𝘴𝘰𝘭𝘷𝘪𝘯𝘨 𝘰𝘯𝘦 𝘱𝘢𝘵𝘩 𝘢𝘵 𝘢 𝘵𝘪𝘮𝘦.” Big thanks to Akshay Saini 🚀 for breaking down complex graph algorithms with crystal-clear intuition 🙌 #Day73 #101DaysOfCoding #DSA #Graphs #FloydWarshall #DynamicProgramming #ShortestPath #JavaScript #ProblemSolving #CodingJourney

🚀 Day 41/100 of My LeetCode Challenge: Mastering Graph Traversal with Edge Reversal! 🎯 Today’s Problem: A clever graph traversal challenge where each node has a one-time switchthat can reverse an incoming edge—then traverse it immediately at double the cost. 🧠 Key Insights: Each node can use its switch at most once to reverse one incoming edge Reversed edges cost 2 × original weight Need to find the minimum cost path from node 0 to node n-1 🔧 My Approach: I modeled this as a Dijkstra's algorithm variant with an extra state dimension: dist[node][used] where used ∈ {0,1} tracks whether we've used the node's switch Maintain both outgoing edges (normal traversal) and incoming edges (if switch not used yet) Priority queue ensures we always expand the lowest-cost path first ⚡ Complexity: Time: O((V + E) log V) — Dijkstra's with modified state Space: O(V + E) — graph representation and distance matrix 📈 The Challenge: This problem beautifully combines: State-space search (tracking switch usage) Graph traversal optimization (Dijkstra's adaptation) Edge manipulation (dynamic reversal mechanics) 🔗 Why This Matters: Problems like these appear in: Network routing with one-time reconfiguration options Resource-constrained pathfinding Real-time strategy games with limited special moves Fault-tolerant network design #LeetCodeChallenge #100DaysOfCode #GraphTheory #Algorithms #DataStructures #ProblemSolving #Dijkstra #Java #CodingInterview #TechCommunity #SoftwareEngineering #Programming

Built 𝗙𝗖𝗘𝗙 (𝗙𝗶𝗹𝗲 𝗖𝗼𝗺𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 & 𝗘𝘅𝗽𝗼𝗿𝘁 𝗙𝗼𝗿𝗺𝗮𝘁𝘀) → a desktop application focused on 𝗿𝘂𝗹𝗲-𝗯𝗮𝘀𝗲𝗱 𝗳𝗶𝗹𝗲 𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴 𝗮𝗻𝗱 𝗱𝗲𝘁𝗲𝗿𝗺𝗶𝗻𝗶𝘀𝘁𝗶𝗰 𝗼𝘂𝘁𝗽𝘂𝘁𝘀, not just image compression. link for more details: https://lnkd.in/gq-x3k4j The idea was simple: take one input file → apply predefined compression rules → generate 𝗺𝘂𝗹𝘁𝗶𝗽𝗹𝗲 𝗼𝗽𝘁𝗶𝗺𝗶𝘇𝗲𝗱 𝗼𝘂𝘁𝗽𝘂𝘁𝘀 in a single run. What FCEF does: - Converts images into 𝗝𝗣𝗚, 𝗣𝗡𝗚, 𝗪𝗘𝗕𝗣, 𝗮𝗻𝗱 𝗣𝗗𝗙 - Applies 𝘁𝗵𝗿𝗲𝗲 𝗰𝗼𝗺𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 𝘁𝗶𝗲𝗿𝘀 (high / mid / low) with clearly defined rules - Performs 𝘀𝗺𝗮𝗿𝘁 𝗿𝗲𝘀𝗶𝘇𝗶𝗻𝗴 based on compression tier while preserving aspect ratio - Generates a 𝗽𝗿𝗲𝗱𝗶𝗰𝘁𝗮𝗯𝗹𝗲 𝗱𝗶𝗿𝗲𝗰𝘁𝗼𝗿𝘆 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 so outputs are easy to reason about and debug Each compression tier is treated as a deterministic configuration: - High → no resizing, max quality - Mid → balanced quality with controlled resizing - Low → aggressive compression with smaller dimensions Internally, the project is structured around 𝗳𝗼𝗿𝗺𝗮𝘁 𝗵𝗮𝗻𝗱𝗹𝗲𝗿𝘀 and a centralized processor, making it easy to extend with new formats or rules (PDF compression is next). This project reinforced how much clarity you gain when you treat file operations as a 𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲 rather than UI-driven actions. Tech: Python, Pillow, CustomTkinter More than a desktop app -> this was an exercise in 𝘀𝘆𝘀𝘁𝗲𝗺 𝗱𝗲𝘀𝗶𝗴𝗻, 𝗲𝘅𝘁𝗲𝗻𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝘆, 𝗮𝗻𝗱 𝗰𝗼𝗿𝗿𝗲𝗰𝘁𝗻𝗲𝘀𝘀. #BackendDevelopment #Python #SystemDesign #SoftwareEngineering #DeveloperProjects #FullStackDevelopment