How to Maximize Element Frequency with Operations

🧩 Day 38 — Intersection of Two Arrays (LeetCode 349) 📝 Problem -Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must be unique, and you may return the result in any order. 🔁 Approach -Convert the first array into a set to remove duplicates and enable fast lookup. -Iterate through the second array and check if each element is in the set. -If present, add it to the result and remove it from the set to maintain uniqueness. -Return the result in any order. 📊 Complexity -Time Complexity: O(n + m) -Space Complexity: O(n) 🔑 Concepts Practiced -Hash Set operations -Array intersection logic -Handling duplicates efficiently #Leetcode #Python #DSA #ProblemSolving

💡 Merge Sorted Array — LeetCode #88 Today I practiced one of the most common array problems — Merge Sorted Array, a great example of the two-pointer technique and in-place manipulation. Problem: You’re given two sorted arrays: nums1 with extra space at the end nums2 with n elements The goal is to merge them into a single sorted array inside nums1, without using extra space. Key Idea (Pattern): ➡️ Instead of merging from the front, we start from the back. This avoids overwriting elements in nums1 and lets us fill it from the largest to smallest. Approach: Use three pointers: p1 → end of valid elements in nums1 p2 → end of nums2 p → last index of nums1 Compare elements from both arrays and insert the larger one at the end of nums1. Copy any remaining elements from nums2. Time Complexity: O(m + n) Space Complexity: O(1) Pattern Learned: Two Pointers (backward traversal for in-place merging) Related Problems: Move Zeroes, Sort Colors, Merge Intervals Every time I solve one of these classic problems, I realize how much coding interviews are about recognizing patterns — not memorizing solutions. 💭 #LeetCode #DSA #CodingInterview #Python #Arrays #TwoPointers #ProblemSolving

🚀 Day 3 of #100DaysofDSA Today’s focus was on the “Set Matrix Zeroes” problem — a classic array-matrix question that tests both logic and optimization thinking It began with the brute-force idea: storing all zero positions and then marking corresponding rows and columns later. It works but takes O(m × n) time and O(m + n) extra space. Next, then explored a better approach using two auxiliary arrays to track which rows and columns should be zeroed. This improved the clarity but still consumed additional memory and space. Finally, then to reduce the complexity I tackled the optimal solution, which achieves O(1) extra space by using the first row and first column of the matrix itself as markers. A small Boolean flag handles the edge case when the first row contains a zero. This subtle observation transforms the logic completely — turning a memory-heavy method into a clean in-place algorithm. It was a good reminder that optimization isn’t just about speed — it’s about finding elegance in constraints. #100DaysOfDSA #MatrixProblems #Optimization #SpaceComplexity #Python #ProblemSolving

🧩 Day 41 — Count Primes (LeetCode 204) 📝 Problem -Given an integer n, return the number of prime numbers that are strictly less than n. 🔁 Approach -Use the Sieve of Eratosthenes algorithm: -Create a boolean array arr of size n, initialized to True. -Mark arr[0] and arr[1] as False (since 0 and 1 are not prime). -Iterate i from 2 to √n: -If arr[i] is True, mark all multiples of i as False. -Count all True values in arr — that count gives the number of primes. 📊 Complexity -Time Complexity: O(n log log n) -Space Complexity: O(n) 🔑 Concepts Practiced -Prime number sieving -Optimization using mathematical properties -Boolean array manipulation #LeetCode #Python #DSA #ProblemSolving

Floyds Triangle: You are given an integer n. Your task is to return the first n rows of Floyd’s Triangle, represented as a list of strings. Floyd's Triangle is a triangular array of natural numbers where the first row contains 1, the second row contains 2 and 3, the third row contains 4, 5, and 6, and so on. Example Input: 5 Output: ['1', '2 3', '4 5 6', '7 8 9 10', '11 12 13 14 15'] Solution def generate_floyds_triangle(n):   last_val=0   l=[]   for i in range(1,n+1):     result=''     for j in range(i):       result+=str(last_val+1)+' '       last_val+=1           result=result[:-1]     l.append(result)   return l #Python #DataEngineering #DSA

Day 68: Search in 2D Sorted Matrix (Search Space Reduction) 🔎 I'm continuing the streak on Day 68 of #100DaysOfCode with a challenging matrix search problem! The task is to find a target value in an $m \times n$ matrix where both rows and columns are sorted in ascending order. The key to solving this efficiently is Search Space Reduction. Instead of performing a standard search, my solution uses a smart traversal technique: Starting Point: I begin the search at the top-right corner of the matrix. Decision Logic: If the current value equals the target, we stop. If the current value is greater than the target, the entire current column can be eliminated, so we move left. If the current value is less than the target, the entire current row can be eliminated, so we move down. This strategy eliminates one row or one column in every step, guaranteeing an optimal O(m + n) time complexity and O(1) extra space. #Python #DSA #Algorithms #Matrix #Search #100DaysOfCode #ProblemSolving

🚀 Day 82 of #100DaysOfDSA 🚀 Solved LeetCode 8 — String to Integer (atoi) 🔹 Problem: Implement the atoi function which converts a string to a 32-bit signed integer, handling whitespace, optional signs, and overflow conditions. 🔹 Approach: Used String Manipulation + Edge Case Handling 1️⃣ Trim leading and trailing whitespaces using strip(). 2️⃣ Check for optional '+' or '-' sign and store it. 3️⃣ Iterate through the string, building the integer digit by digit until a non-digit character appears. 4️⃣ Clamp the result to fit within 32-bit integer bounds [-2³¹, 2³¹−1]. ✨ Key Insight: Careful handling of edge cases and boundaries is crucial in string-to-integer problems — it’s all about precision and attention to detail. #LeetCode #DSA #Python #ProblemSolving #StringManipulation #CodingJourney #100DaysOfCode 🚀

🧩 Day 45 — Remove Duplicates from Sorted Array II (LeetCode 80) 📝 Problem Given an integer array nums sorted in non-decreasing order, remove some duplicates in-place such that each unique element appears at most twice. The relative order of the elements should be kept the same. Return the number of valid elements remaining after modification. 🔁 Approach -Use the two-pointer technique to modify the array in-place. -If the array length ≤ 2, return its length (since all are valid). -Start checking from index 2 because the first two elements can always stay. -For each element, compare it with the element two positions before. -If they differ, keep the current element; otherwise, skip it. -The count of valid elements represents the final result. 📊 Complexity -Time Complexity: O(n) -Space Complexity: O(1) 🔑 Concepts Practiced -Two-pointer technique -In-place array modification -Working with sorted arrays #Leetcode #Sorting #DSA #Python

✅ Day 90 Completed – Fixing Two Nodes of a BST (Binary Search Tree) 🌳 Today’s challenge was to fix two nodes that were swapped by mistake in a BST — without altering the structure of the tree. 🔹 Concept Used: The solution uses inorder traversal, which should ideally produce a sorted sequence for BSTs. When two nodes are swapped, this order is disrupted. During traversal, the algorithm identifies the misplaced nodes and swaps them back to restore the BST’s correctness. 🔹 Key Steps: Perform inorder traversal to track the order of nodes. Identify the two misplaced nodes (first, middle, and last). Swap the correct pair to restore BST order. 🔹 Result: All 1111 test cases passed ✅ with 100% accuracy and O(n) efficiency. 📘 This problem reinforced deep understanding of tree traversal and inorder property in BSTs — an elegant mix of logic and precision! #100DaysOfCode #Day90 #GeeksforGeeks #Python #BinarySearchTree #CodingJourney #ProblemSolving

🧩 Day 42 — Add Digits (LeetCode 258) 📝 Problem Given an integer num, repeatedly add all its digits until the result has only one digit, and return it. 🔁 Approach -Continuously sum the digits of the number until a single-digit result remains. -Alternatively, use the digital root formula: -If num == 0, return 0. -Else, return 1 + (num - 1) % 9. 📊 Complexity -Time Complexity: O(1) -Space Complexity: O(1) 🔑 Concepts Practiced -Mathematical optimization -Modulo operation -Digital root pattern #Leetcode #python #DSA #ProblemSolving #Math #Optimization