Binary Search on Rotated Arrays Preserves O(log n) Complexity

🚀 Optimized Solution: Search in Rotated Sorted Array II Solved the problem "Search in Rotated Sorted Array II" using an optimized Binary Search approach! 🔍 Key Idea: Instead of using linear search, I applied a modified binary search to handle: ✔️ Rotated sorted array ✔️ Presence of duplicates ⚙️ Approach: Used binary search to divide the array Identified sorted halves even with duplicates Carefully handled edge cases where duplicates make it hard to decide the sorted side 📈 Complexity: ⏱️ Time Complexity: O(log n) (Worst case O(n) due to duplicates) 💾 Space Complexity: O(1) ✅ Result: ✔️ All test cases passed ⚡ Efficient and scalable solution This problem really helped me strengthen my understanding of edge cases in binary search and real-world problem-solving 💡 #leetcode #binarysearch #algorithms #coding #python #datastructures #softwaredeveloper #problemSolving

Why can’t we just search embeddings with a Python script instead of using a vector database? While working with RAG systems, this question came to mind. A simple approach would be to compare a query embedding with every vector using linear search. But that takes O(n) time — which becomes very slow when you have millions of vectors. Vector databases solve this using Approximate Nearest Neighbor (ANN) algorithms like HNSW and LSH. These structures allow fast similarity search by navigating the vector space efficiently instead of checking every vector. That’s why most modern RAG pipelines rely on vector databases. Interesting how much engineering goes into making retrieval fast. #MachineLearning #GenAI #RAG #VectorDB

🚀 DSA Practice Update! Solved Remove Duplicates from Sorted Array on LeetCode with an optimized approach. Brute Force: O(n log n) time | O(n) space Optimized (Two Pointer):O(n) time | O(1) space Choosing the right approach matters more than just solving the problem. The Brute Force approach removes duplicates by using extra data structures like a set and then sorting the array again. Because of sorting, its time complexity becomes O(n log n) and it also requires O(n) extra space. Additionally, it is not in-place, which makes it less efficient and not ideal for optimized solutions. “I used a two-pointer approach where one pointer tracks the position of unique elements and the other scans the array. This gives O(n) time and O(1) space complexity.” Consistency + Optimization = Growth 📈 #DSA #LeetCode #InterviewPrep #Python #CodingJourney

🚀 Day 10 – DSA Daily Series Today’s Problem: Search in Rotated Sorted Array (LeetCode 33) Today I solved an interesting problem where a sorted array is rotated, and we still need to find the target efficiently. 🧠 Problem You are given a sorted array that has been rotated at an unknown pivot. The task is to find the index of the target element. If the target is not present, return -1. Example: Input: nums = [4,5,6,7,0,1,2], target = 0 Output: 4 💡 Approach This problem is solved using a modified Binary Search. Key idea: • Even though the array is rotated, one half will always remain sorted • Check which half is sorted (left or right) • Determine whether the target lies in that sorted half • Adjust the search range accordingly By doing this, we can still achieve logarithmic time complexity. ⏱ Complexity Time Complexity: O(log n) Space Complexity: O(1) 🔎 Key Learning This problem helped me understand how Binary Search can be adapted for slightly complex scenarios like rotated arrays. Continuing the DSA Daily Series — solving and learning one problem at a time. 🚀 #DSA #LeetCode #Python #Algorithms #BinarySearch #CodingJourney #ProblemSolving

Day16-Problem of the day Given the root of a binary tree and an integer k, determine the number of downward-only paths where the sum of the node values in the path equals k. Why it works: By keeping track of the cumulative sums we've seen so far, we can determine if a sub-path summing to $k$ exists in $O(1)$ time at each node. It transforms a potential $O(N^2)$ bottleneck into a sleek $O(N)$ linear traversal. 🚀 Key Takeaway: Data structures like Hash Maps aren't just for flat arrays; they are incredibly powerful for optimizing recursive traversals by "remembering" the history of a branch. #CodingChallenge #DataStructures #Algorithms #Python #GFG #Learning

Most people solve the Palindrome Number problem by converting the integer to a string and reversing it. It’s simple, readable, and honestly works perfectly in many real-world situations. But there’s another fast method that doesn’t use strings at all. Instead, you reverse the number mathematically — extracting digits one by one using division and modulo, then rebuilding the number in reverse order. This approach uses constant extra space and is often preferred in algorithm-focused environments. Both methods are efficient. The difference is mostly about tradeoffs: • String reversal → cleaner and more readable • Mathematical reversal → more optimal and lower-level Nice reminder that sometimes there’s a straightforward solution… and a slightly more “algorithmic” one — and knowing both makes you a stronger problem solver. 🚀 #Algorithms #ProblemSolving #Python #LeetCode #SoftwareEngineering

✅ Day 78 of 100 Days LeetCode Challenge Problem: 🔹 #3110 – Score of a String 🔗 https://lnkd.in/g9jgxcdK Learning Journey: 🔹 Today’s problem involved calculating the score of a string based on the absolute differences between ASCII values of adjacent characters. 🔹 I iterated through the string starting from index 1 and computed the difference between the current and previous character using ord(). 🔹 For each pair, I added the absolute difference to a running total. 🔹 This approach efficiently accumulates the score in a single pass. Concepts Used: 🔹 String Traversal 🔹 ASCII Value Conversion (ord()) 🔹 Absolute Difference Calculation Key Insight: 🔹 The problem reduces to comparing adjacent elements, making it a straightforward linear scan. 🔹 Using ord() allows direct access to ASCII values, simplifying the computation. Complexity: 🔹 Time: O(n) 🔹 Space: O(1) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

Day 88 of my #100DaysOfCode journey 🚀 Today I implemented Depth First Search (DFS) on Graphs using recursion. Unlike BFS, DFS explores as deep as possible along a branch before backtracking. It follows a recursive approach (or stack-based) and is fundamental for many advanced graph problems. Approach: • Start from a source node (0 in this case) • Mark it as visited • Recursively visit all unvisited neighbors Key concepts reinforced: • Graph traversal using DFS • Recursion in graphs • Using a visited set to avoid infinite loops (cycles) Time Complexity: • O(V + E) → where V = vertices, E = edges DFS is widely used in: • Cycle detection • Topological sorting • Connected components • Backtracking problems Now having covered both BFS and DFS, the core graph traversal foundation is in place. Graphs officially unlocked. 🔓 #100DaysOfCode #DSA #Graphs #DFS #Algorithms #Python #CodingJourney #ProblemSolving #TechLearning #SoftwareEngineering

Building an LLM-based extraction service taught me one important lesson: Hardcoding prompts doesn’t scale. Moving from prototype to production, I realized the system around the model matters as much as the model itself. What actually helped make it usable across different use cases: • Decoupling prompts from code using a MongoDB-backed configuration layer • Supporting project-specific prompts instead of one fixed prompt design • Designing the service to handle varying extraction requirements without code changes • Using models like Mistral-7B for extracting structured outputs (JSON/fields) from unstructured documents The real challenge wasn’t prompt design — it was making prompt iteration safe, flexible, and maintainable in a production system. #GenAI #LLMs #SystemDesign #Python #AIEngineering

Subtree Detection: Composing Helper Functions for Nested Recursion Subtree validation requires two operations — traverse main tree to find candidates, then validate exact match at each. Composing separate functions (isSubtree calls isSameTree) keeps logic modular and enables reusing isSameTree across problems. Composition Benefit: Separate concerns for testability and reuse. Cost: function call overhead (negligible vs algorithmic complexity). Prefer composition unless profiling shows bottlenecks. Time: O(m × n) | Space: O(h) #FunctionComposition #ModularRecursion #SubtreeDetection #CodeReuse #Python #AlgorithmDesign #SoftwareEngineering