How to solve 3318. Find X-Sum of All K-Long Subarrays I

🔥 Day 23 | LeetCode Challenge – Clone Graph (Problem #133) Today’s problem focused on graph traversal and deep copying, a classic challenge testing the understanding of graph data structures and recursion. 💡 Concept Overview: Given a node from a connected undirected graph, the goal is to create a deep clone — meaning every node and its corresponding neighbors must be copied into a completely new graph without referencing the original nodes. 📘 Approach Used: Utilized Depth-First Search (DFS) and a HashMap to keep track of already cloned nodes. For each node, a clone was created and stored in the map. Recursively cloned all neighbors, ensuring that shared nodes are referenced properly in the new graph. This approach guarantees correct replication while preventing infinite recursion due to cyclic references. ⚙️ Algorithm Used: Depth-First Search (DFS) 🧾 Language: Java ⚡ Runtime: 25 ms (Beats 65.16%) 💾 Memory Usage: 44.06 MB 🧩 Key Insight: When cloning complex structures like graphs, maintaining a visited map is essential to handle cyclic dependencies efficiently and avoid redundant computations. #Day23 #LeetCode #CloneGraph #GraphTheory #DepthFirstSearch #JavaDeveloper #ProblemSolving #100DaysOfCode #DataStructuresAndAlgorithms #CodingChallenge #ProgrammingJourney #TechLearning #InterviewPreparation

#Day9 of my #100DaysCodingChallenge 💻 Today’s problem pushed my reasoning around frequency analysis and window-based computation — a brilliant mix of hashmaps and sliding window logic! 🧮⚙️ 🔍 Problem Explored: Find X-Sum of All K-Long Subarrays — where for every subarray of length k, you need to compute the sum of the top x most frequent (and largest, if tied) elements. 💡 Approach: For each subarray, counted element frequencies using a HashMap, then sorted entries by frequency (and value on ties) to pick the top x contributors. Finally, optimized the logic with sliding windows to reuse previous computations efficiently. ⏱ Time Complexity: O(n × k log k) (initial) → optimizable using ordered maps or heaps 🧠 Space Complexity: O(k) ✅ Result: Implemented a clear and correct Java solution that balances frequency tracking with subarray iteration — a great hands-on dive into map manipulation and priority-based logic. 📘 Learning: When dealing with frequency-based problems, structuring data efficiently is half the battle. A well-placed map or heap can turn a brute-force approach into an elegant one. 🙌 Special thanks to K.R. Mangalam University and Abhishek Kumar Sir for continuously motivating me to refine my logic and efficiency. #Java #CodingChallenge #100DaysOfCode #ProblemSolving #LeetCode #CompetitiveProgramming #DSA #InterviewPrep #SlidingWindow #HashMap #FrequencyAnalysis #CodingJourney #LearningEveryday

Day 40 of #100daysOfCode Problem: 2654. Minimum Number of Operations to Make All Array Elements Equal to 1 Difficulty: Medium Language: Java Status: Solved Problem Summary: You're given an array of positive integers nums. In one operation, you can choose an index i (where 0 ≤ i < n - 1) and replace either nums[i] or nums[i+1] with gcd(nums[i], nums[i+1]). You need to find the minimum number of operations to make all elements equal to 1. If it’s not possible, return -1. Key Insight: If there’s at least one 1 in the array → we can convert all other elements to 1 in n - count(1) operations. Otherwise, find the shortest subarray whose GCD = 1. Once found, it takes (j - i) operations to create one 1 and (n - 1) more to make the entire array 1. Algorithm Steps: Count how many elements are 1. If any exist → answer = n - ones. If not → iterate all subarrays, compute GCD until it becomes 1. Keep track of the smallest subarray length that reaches GCD = 1. If none found → return -1. Else return minLength + (n - 1). Time Complexity: O(n² * log(max(nums[i]))) Space Complexity: O(1) Learning Takeaway: Classic GCD reduction logic—search for minimal segment that can “spread” ones across the array. Efficiently reuses math logic in algorithmic reasoning. #Day40 #100DaysOfCode #LeetCode #Math #GCD #Greedy #Java #Algorithms #CodingChallenge #ProblemSolving #DSA

✅ Day 73 of LeetCode Medium/Hard Edition Today’s challenge was “K Inverse Pairs Array” — an elegant Dynamic Programming problem that combines combinatorics, recurrence optimization, and modular arithmetic ⚡💡 📦 Problem: Given two integers n and k, return the number of different arrays consisting of numbers from 1 to n such that there are exactly k inverse pairs. An inverse pair is [i, j] where 0 ≤ i < j < n and nums[i] > nums[j]. 🔗 Problem Link: https://lnkd.in/eqt3zX_D ✅ My Submission: https://lnkd.in/eX2ZyCCu 💡 Thought Process: This problem generalizes the concept of counting inversions across all permutations of 1..n. The key idea is to express dp[n][k] in terms of previously computed states using prefix-sum logic to reduce time complexity. We use the recurrence: dp[n][k] = dp[n][k - 1] + dp[n - 1][k] - (k >= n ? dp[n - 1][k - n] : 0) This formula cleverly builds on smaller subproblems by considering where the nth element can be inserted in permutations of size n-1. 🎯 Base Cases: dp[n][0] = 1 (sorted array, no inverse pairs) dp[1][k] = 0 for all k > 0 ⚙️ Complexity: ⏱ Time: O(n × k) 💾 Space: O(n × k) 🧩 Key Learnings: Deepened understanding of prefix-sum optimization in DP. Reinforced modular arithmetic handling (MOD = 10⁹ + 7). Learned how combinatorial recurrence can reduce nested loops. Strengthened recursive + memoized DP formulation in Java. #LeetCodeMediumHardEdition #100DaysChallenge #DynamicProgramming #Recursion #Combinatorics #Java #DSA #ProblemSolving #KeepCoding #LearnEveryday

💻 Day 63 of #LeetCode100DaysChallenge Solved LeetCode 290: Word Pattern — a great problem for strengthening hash mapping and bijection logic between characters and words. 🧩 Problem: Given a pattern and a string s, determine if s follows the same pattern. Each letter in the pattern maps to exactly one unique word in s, and each unique word in s maps to exactly one letter in the pattern. No two letters map to the same word, and no two words map to the same letter. 💡 Approach — HashMap + Set: 1️⃣ Split s into words. If pattern length ≠ word count, return false. 2️⃣ Use two data structures: A HashMap<Character, String> to map pattern → word. A HashSet<String> to track if a word is already mapped. 3️⃣ Iterate through both: If the character was seen before, check if it maps to the same word. If it’s new, ensure the word isn’t already mapped to another letter. 4️⃣ Return true if all pairs match consistently. ⚙️ Complexity: Time: O(N) — one pass through all words. Space: O(N) — for the map and set. ✨ Key Takeaways: ✅ Strengthened understanding of bijections and hash-based pattern matching. ✅ Improved clarity on how to manage two-way mapping between characters and strings. ✅ Practiced clean iteration and map validation logic — crucial for real-world parsing and pattern-matching problems. #LeetCode #100DaysOfCode #Java #HashMap #PatternMatching #DSA #ProblemSolving #WomenInTech #CodingChallenge

🗓 Day 8 / 100 – #100DaysOfLeetCode 📌 Problem 474: Ones and Zeroes The task was to determine the largest subset of binary strings that can be formed using at most m zeros and n ones — essentially a two-dimensional 0/1 Knapsack problem. 🧠 My Approach (in Java): Counted the number of zeros and ones in each string. Used a 2D DP array dp[m][n] to store the maximum subset size possible with given zeros and ones. Iterated in reverse order to ensure each string is only used once (knapsack-style update). Updated states using dp[i][j] = max(dp[i][j], dp[i - zeros][j - ones] + 1). ⏱ Time Complexity: O(len(S) × M × N) 💾 Space Complexity: O(M × N) 💡 Key Learning: This problem strengthened my understanding of multi-dimensional DP — especially how to translate real-world constraints into DP states. It’s a great reminder that mastering DP isn’t about memorizing patterns but about building intuition on state transitions and decisions. Consistent effort. Deep learning. Step by step 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Java #DynamicProgramming #Knapsack #Algorithms #ProblemSolving #DataStructures #DSA #CodingJourney #CompetitiveProgramming #SoftwareEngineering #LearningInPublic #DeveloperJourney #TechStudent #LogicBuilding #CodingCommunity #CodeEveryday #CareerGrowth #Optimization #KeepLearning

💻 Day 57 of #LeetCode100DaysChallenge Solved LeetCode 166: Fraction to Recurring Decimal — a problem that tests mathematical precision, string construction, and use of hashing to detect cycles. 🧩 Problem: Given two integers, numerator and denominator, return their fractional result as a string. If the decimal part repeats, enclose the repeating portion in parentheses. Example: Input: numerator = 1, denominator = 2 Output: "0.5" Input: numerator = 2, denominator = 3 Output: "0.(6)" 💡 Approach — Long Division with Remainder Tracking: 1️⃣ Handle edge cases like zero numerator and sign of the result. 2️⃣ Perform integer division for the whole part (numerator / denominator). 3️⃣ For the fractional part: Use a HashMap to store remainders and their positions in the result string. Multiply remainder by 10 at each step and find the next digit. If a remainder repeats, insert parentheses around the repeating sequence. 4️⃣ Combine the integer and fractional parts to form the final result. ⚙️ Complexity: Time: O(N) — where N is the length of the repeating cycle. Space: O(N) — for storing remainders in the HashMap. ✨ Key Takeaways: ✅ Strengthened understanding of long division logic. ✅ Learned how to detect repeating patterns using hashing. ✅ Reinforced precision handling and string manipulation in math-based problems. #LeetCode #100DaysOfCode #Java #HashMap #Math #StringManipulation #DSA #CodingJourney #WomenInTech #FractionToRecurringDecimal

💻 Day 44 of my DSA Journey: Searching in a Nearly Sorted Array (Modified Binary Search Approach) 🔍 🔗 The task was to: ✅ Given a nearly sorted array, where each element may be misplaced by at most one position from its correct place, find the index of a given key efficiently. ✅ Use a modified binary search instead of a simple linear search. ✅ Achieve O(log n) time complexity with O(1) extra space. 🔹 Example Usage: int[] arr = {10, 3, 40, 20, 50, 80, 70}; int key = 40; // Output: // Element 40 found at index 2 🔑 Key Learnings: 💡 In a nearly sorted array, an element at index i could be found at: i (its actual position), i - 1 (one place left), or i + 1 (one place right). Hence, instead of checking only mid, we must check mid, mid - 1, and mid + 1. ⚡ Time Complexity: O(log n) ⚡ Space Complexity: O(1) 🌱 Takeaway: This problem strengthened my understanding of binary search adaptations — how slight variations in sorted data can be handled efficiently with small logical tweaks. It’s a great reminder that pattern recognition is key to mastering binary search-based problems 🚀🔥 📌 Hashtags #DSA #Java #BinarySearch #NearlySortedArray #ProblemSolving #CodingJourney #100DaysOfCode #Day414#InterviewPreparation