Junaid Arshad’s Post

Day 43/100 – #100DaysOfCode 🚀 Solved LeetCode #2610 – Convert an Array Into a 2D Array With Conditions (Python). Today I practiced hashmap (frequency counting) to construct a 2D array based on given conditions. Approach: 1) Create a frequency map to count occurrences of each element. 2) Initialize an empty result list. 3) While the frequency map is not empty: 4)  Create a new row. 5)  Iterate through keys and add each number once to the row. 6)  Decrease its frequency and remove it if it becomes zero. 7) Add the row to the result. 8) Return the final 2D array. Time Complexity: O(n) Space Complexity: O(n) Learning how frequency maps help in structuring data efficiently 💪 #LeetCode #Python #DSA #HashMap #Arrays #ProblemSolving #100DaysOfCode

💧 Max Water Problem — Two Pointer Optimization Solved Container With Most Water using the Two Pointer technique in O(n) time. Key Idea: Move the pointer with the smaller height, since it limits the water capacity. 📈 Complexity: Time → O(n) Space → O(1) Small logic shift, big optimization. #DSA #Python #TwoPointers #CodingInterview #Algorithms

Day 32 / #120DaysOfCode – LeetCode Challenge Today’s focus: Arrays & Majority Voting Algorithm ✅ Problem Solved: • Majority Element II 💻 Language: Python 📚 Key Learnings: • Applied Boyer-Moore Voting Algorithm (extended version) • Learned how to track two candidates for n/3 majority • Understood the importance of validation step after candidate selection • Improved ability to handle edge cases in frequency problems Consistency builds confidence 🚀 Every day = 1% better 💪 🔗 LeetCode Profile: https://lnkd.in/gbeMKcv5 #LeetCode #Python #DSA #Arrays #Algorithms #Consistency #CodingJourney #120DaysOfCode

K Closest Points: Min-Heap for Efficient Selection Sorting all points costs O(n log n). Min-heap achieves same complexity but enables early termination — build heap with distances, extract k smallest. Squared distance avoids expensive sqrt while preserving ordering. Optimization Note: Max-heap of size k would be O(n log k) versus O(n log n) here. For small k, bounded heap beats full sorting. This solution works but isn't optimal for k << n. Time: O(n log n) | Space: O(n) #Heap #KClosest #DistanceCalculation #PriorityQueue #Python #AlgorithmDesign #SoftwareEngineering

🚀 Day 62 of #100DaysOfCode Solved “Remove Nth Node From End of List” 🔗 💡 Today’s focus: Two Pointer Technique (Fast & Slow pointers) Instead of calculating length, I used an efficient one-pass approach to remove the target node. 🧠 Key Learnings: Dummy node helps handle edge cases (like removing head) Fast pointer moves n steps ahead Then move both pointers until fast reaches the end Slow pointer lands just before the node to delete ⚡ Clean, efficient & optimal solution (O(n) time, O(1) space) Consistency is starting to feel powerful now 💪 #DSA #LeetCode #CodingJourney #LinkedInLearning #100DaysOfCode #Day62 #Python #ProblemSolving

🚀 Day 48 – LeetCode Journey Today’s challenge: Substring with Concatenation of All Words ✔️ Solved using sliding window + hashmap ✔️ Processed string in fixed-length chunks ✔️ Tracked word frequency efficiently 💡 Key Insight: Instead of checking every substring blindly, splitting the string into word-sized pieces and using a hashmap helps validate matches efficiently. Sliding window keeps the solution optimized. This problem was a great exercise in string manipulation, hashing, and window techniques 🧠 Consistency is the real game changer 🚀 #LeetCode #Day48 #SlidingWindow #HashMap #Strings #Python #ProblemSolving #CodingJourney #100DaysOfCode https://lnkd.in/gxf4RBT6

Search Insert Position: Left Pointer as Natural Insertion Index When binary search terminates without finding target, left pointer automatically points to correct insertion position. No special handling needed — the loop invariant guarantees left is where target belongs to maintain sorted order. Termination Property: When l >= r, left has crossed to insertion position. This binary search property eliminates need for post-loop calculation. Time: O(log n) | Space: O(1) #BinarySearch #InsertPosition #LoopInvariant #SortedArrays #Python #AlgorithmDesign #SoftwareEngineering

Day 55/100 – #100DaysOfCode 🚀 Solved LeetCode #205 – Isomorphic Strings (Python). Today I practiced hashmap (dictionary) usage to check whether two strings follow the same pattern. Approach: 1) Create two hashmaps to store character mappings in both directions. 2) Traverse both strings together using zip(). 3) Check if the current mapping is consistent in both maps. 4) If any mismatch is found, return False. 5) Otherwise, update the mappings and continue. 6) If all mappings are valid, return True. Time Complexity: O(n) Space Complexity: O(n) Understanding how bidirectional mapping ensures consistency 💪 #LeetCode #Python #DSA #HashMap #Strings #ProblemSolving #100DaysOfCode

Last Stone Weight: Max-Heap via Negation for Collision Simulation Python's heapq is min-heap only. Simulate max-heap by negating values. Repeatedly extract two largest stones (most negative), compute difference, reinsert. Continue until one/zero stones remain. Max-Heap Workaround: Negating values transforms min-heap to max-heap. This pattern applies whenever max-heap needed in Python. Remember to negate back when extracting final values. Time: O(n log n) | Space: O(n) #Heap #MaxHeap #NegationTrick #PriorityQueue #Python #AlgorithmDesign #SoftwareEngineering

Group Anagrams: Frequency Signature Beats Sorting for Keying Sorting each string as key costs O(k log k) per string. Character frequency array is O(k) and creates same signature for anagrams. Fixed 26-element array converted to tuple serves as hashable HashMap key — cleaner, faster grouping. Frequency as Key: Character counts uniquely identify anagram groups. Tuple conversion enables using array as dict key (lists aren't hashable). This pattern applies to document clustering, duplicate detection. Time: O(n × k) vs O(n × k log k) with sorting | Space: O(n × k) #FrequencySignature #HashMap #Anagrams #KeyOptimization #Python #AlgorithmDesign #SoftwareEngineering