Eugene Kovko’s Post

🔍 Day 66 of #100DaysOfCode 🔍 🔹 Problem: Binary Search – LeetCode ✨ Approach: Implemented an iterative binary search to efficiently locate the target element within a sorted array. By halving the search range each time — adjusting low and high around the mid-point — the algorithm achieves blazing-fast lookups! ⚡ 📊 Complexity Analysis: Time Complexity: O(log n) — array size halves with each iteration Space Complexity: O(1) — constant extra space ✅ Runtime: 0 ms (Beats 100.00%) ✅ Memory: 46.02 MB 🔑 Key Insight: Binary Search is proof that efficiency isn’t about doing more — it’s about eliminating what’s unnecessary. 🚀 #LeetCode #100DaysOfCode #ProblemSolving #DSA #AlgorithmDesign #BinarySearch #LogicBuilding #Efficiency #ProgrammingChallenge #CodeJourney #CodingDaily

🔥 Day 92 of My LeetCode Journey — Problem 28: Find the Index of the First Occurrence in a String 💡 Problem Insight: Today’s problem was about finding the first occurrence of a substring (needle) inside another string (haystack). Essentially, it’s like implementing your own version of the strStr() function — a classic problem in string searching. 🧠 Concept Highlight: This challenge sharpens understanding of string traversal and pattern matching. The intuitive solution uses simple iteration and substring comparison, while the optimized approach can involve algorithms like KMP (Knuth-Morris-Pratt) for efficient searching. 💪 Key Takeaway: Sometimes, even built-in functions hide deep logic beneath simplicity — mastering these fundamentals builds confidence for more advanced string algorithms. ⚙️ Daily Reflection: Every search begins with clarity — whether in code or in life. Precision and patience always lead to the right match. #Day92 #LeetCode #100DaysOfCode #StringSearch #PatternMatching #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

🧩 LeetCode Challenge – Day 72 ✅ Dived into a string decoding problem today — a perfect blend of stacks, recursion, and pattern tracking. 🔗 LeetCode 394 – Decode String This challenge revolves around decoding expressions like 3[a2[c]], requiring careful handling of nested patterns and character reconstruction. It’s a great exercise in managing multiple layers of logic — keeping track of counts, substrings, and the overall decoded output step by step. 💡 Key Takeaways: • Stack-based parsing builds precision in handling nested structures. • Breaking problems into layers simplifies even the most complex logic. • Attention to detail is everything — one misplaced index can change the entire output. #Day72 #LeetCodeChallenge #100DaysOfCode #DSA #CodingJourney #ProblemSolving #Stack #Strings #Parsing #Recursion

🌟 Day 105 of My LeetCode Journey — Problem 138: Copy List with Random Pointer 💡 Problem Insight: Today’s problem took linked lists to a new level — each node had not just a next pointer but also a random pointer that could point to any node (or null). The challenge was to create a deep copy of such a list, preserving both connections perfectly. 🧠 Concept Highlight: The efficient approach involves three smart steps: Clone each node and insert it right next to the original node. Set up random pointers for the cloned nodes. Detach the two lists to restore the original and extract the copy. This clever interleaving technique avoids extra space (no hash map needed) and runs in O(n) time — an elegant display of pointer manipulation. 💪 Key Takeaway: Duplication isn’t about copying blindly — it’s about understanding the relationships and structure beneath the surface. ✨ Daily Reflection: This problem reinforced that clean logic and visualization make even the most pointer-heavy tasks simple and satisfying. #Day105 #LeetCode #100DaysOfCode #LinkedList #ProblemSolving #RandomPointer #DeepCopy #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

#Day 24: #100DaysOfCodingChallenge 🔍✨ Back to fundamentals today with the classic Binary Search! Sometimes revisiting core algorithms reinforces why they're foundational—elegant, efficient, and essential for any programmer's toolkit. Every problem solved adds another brick 🧱 to the foundation! 🟢 LeetCode 704: Binary Search 🔹 Difficulty: Easy ⏱️ Time Complexity: O(log n) 💾 Space Complexity: O(1) 🕒 Time Taken: 0 ms 💡 Approach: Used two pointers (left and right) to define the search space. In each iteration, calculated mid and compared it with target—if equal, returned mid; otherwise, eliminated half the search space by updating pointers. The beauty lies in halving possibilities with each comparison!

🔥 HyperRevision with Structure – Day 88 🔥 🧩 Problem solved today: 1️⃣ Graph Valid Tree (LeetCode 261) 💭 Thoughts: This problem helped me understand what actually makes a graph a tree — it needs to be connected and have no cycles. Really important concept for graph foundations; I think it’ll help a lot in the advanced graph problems later. ⏱️ Time Complexity: O(V + E) 💾 Space Complexity: O(V + E) 📌 GitHub link in comments #HyperRevision #NeetCode150 #GraphTraversal

🚀 Day 61 | Recursion & Balanced BST Construction Today’s problem focused on building a height-balanced Binary Search Tree from a sorted array — a perfect use case for divide-and-conquer. 🧩 Problem Solved: 108. Convert Sorted Array to Binary Search Tree • Approach: Used recursion — picked the middle element as the root, recursively built left and right subtrees from the halves. • Insight: Balanced trees naturally emerge when you divide sorted data around the midpoint — a great illustration of symmetry in recursion. ✨ Key Takeaway: Recursion mirrors structure — when you trust the process, complex problems unfold with simple, elegant logic. 📚 Topics: Binary Search Tree · Recursion · Divide and Conquer 💻 Platform: LeetCode #DSA #LeetCode #ProblemSolving #DailyCoding #Recursion #BinarySearchTree #Consistency

🚀 LeetCode Daily Challenge – Day 8 (November 2025) 🧩 Problem: 1611. Minimum One Bit Operations to Make Integers Zero 📚 Topic: Bit Manipulation | Math | Gray Code 🔍 Approach: Recognized that each operation flips bits following a pattern identical to Gray code transitions. Converted the given number n (which represents a Gray code) back to its corresponding binary index — the count of operations needed to reach zero. Used prefix XOR to iteratively decode n into its original binary form, achieving an O(log n) time complexity. ✅ Time Complexity: O(log n) ✅ Space Complexity: O(1) 💡 Key Takeaway: Bit manipulation problems often hide elegant mathematical patterns — here, the connection between Gray codes and bit-flip operations unlocks a clean and optimal solution ⚡

💻 Day 12 of My #120DaysOfLeetCode Challenge 🧩 Problem: Integer to Roman (LeetCode #12) Today’s problem was about converting an integer into a Roman numeral representation. 🧠 Problem Understanding Roman numerals are based on seven symbols: SymbolValueI1V5X10L50C100D500M1000 To convert an integer (from 1 to 3999) into Roman numerals, we follow certain rules: If the value doesn’t start with 4 or 9 → keep appending the largest possible Roman symbol. If it starts with 4 or 9 → use the subtractive notation (like IV = 4, IX = 9, XL = 40, XC = 90, etc.). Symbols like I, X, C, and M can repeat up to 3 times, but symbols like V, L, and D cannot. ⚙️ Approach I Used I created a mapping of integers to their Roman numeral strings in descending order, including all special subtractive cases (like 900 = CM, 400 = CD). Then, I repeatedly subtracted the largest possible value from the number and appended its corresponding Roman symbol to the result until the number became 0. This greedy approach ensures that we always pick the highest value first — resulting in an accurate Roman numeral representation. 🧩 Example Input: 1994 Output: "MCMXCIV" Breakdown: 1000 → M 900 → CM 90 → XC 4 → IV Hence, 1994 = MCMXCIV 🧠 Time & Space Complexity Time Complexity: O(1) (since the number range is limited) Space Complexity: O(1) 💬 My Thoughts This problem helped me strengthen my understanding of greedy algorithms and how to handle structured conversions through mapping and iteration. It’s a beautiful mix of logic and pattern recognition! 🚀 #Day12 #LeetCode #Cplusplus #ProblemSolving #CodingChallenge #100DaysOfCode #GreedyAlgorithm

🧩 LeetCode Challenge – Day 70 ✅ Dove into one of the more challenging divide-and-conquer problems — counting reverse pairs in an array. 🔗 LeetCode 493 – Reverse Pairs This problem takes the concept of inversions a step further, combining sorting logic with counting conditions. The key insight lies in leveraging a modified merge sort, where you track valid pairs while merging. It’s a great reminder of how algorithmic tweaks can unlock major efficiency gains. 💡 Key Takeaways: • Divide and conquer remains one of the most powerful paradigms in algorithm design. • Optimized counting teaches how to merge logic and efficiency seamlessly. • Understanding problem patterns often matters more than brute implementation. #Day70 #LeetCodeChallenge #100DaysOfCode #DSA #CodingJourney #ProblemSolving #DivideAndConquer #MergeSort #BinarySearch