Implementing K Queues in a Single Array with O(1) Time Complexity

#Day - 32 LeetCode #334 – Increasing Triplet Subsequence (Medium) In this problem, the goal was to determine whether an array contains an increasing triplet subsequence in O(n) time and O(1) space complexity. 🔹 Approach Used: Maintained two variables (first and second) initialized to infinity. Iterated through the array once. Updated first and second dynamically. Returned True when a valid third element was found. This problem strengthened my understanding of: ✅ Greedy algorithms ✅ Optimized space complexity ✅ Efficient single-pass solutions ✅ Logical thinking for edge cases Under the Guidance of : Rudra Sravan kumar #LeetCode #ProblemSolving #Python #DataStructures #Algorithms #CodingJourney #SoftwareDeveloper

Cracked the Max Circular Subarray Sum problem today! The challenge: Find the maximum sum in an array where elements can wrap around from the end back to the beginning. The Approach: Instead of using a naive O(n^2) solution, I used a modified Kadane’s Algorithm. The key is realizing that the maximum sum is either a standard contiguous subarray or the total sum of the array minus the minimum contiguous subarray. By calculating both the maximum and minimum subarray sums in a single pass, we can determine if wrapping around provides a better result. Just remember to handle the edge case where all elements are negative! Efficiency: Time Complexity: O(n) Space Complexity: O(1) Coding challenges like this are a great reminder that sometimes looking at what to exclude is just as important as what to include. Implementation: https://htmlify.me/r/q03x #Algorithms #CodingLife #Python #DataStructures #ProblemSolving

feb-21-26 LeetCode 762 – Prime Number of Set Bits in Binary Representation Solved today’s problem focused on bit manipulation and prime checking! 🔹 Problem: Given two integers left and right, count how many numbers in that range have a prime number of set bits (1s) in their binary representation. 💡 Approach: Iterate through each number in the range. Count set bits using bitwise operations (& and right shift). Check whether the count of set bits is a prime number. Keep track of valid cases. 🧠 Concepts Used: Bit Manipulation Prime Number Checking Mathematical Optimization Simple problem on the surface, but a great way to strengthen understanding of binary representation and efficient computation. Consistency + Daily Practice = Growth 📈🔥 #LeetCode #BitManipulation #PrimeNumbers #Python #CodingPractice #ProblemSolving

Day 74 of #180DaysOfCode Today I 𝗶𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁𝗲𝗱 𝗮 𝗠𝗶𝗻𝗦𝘁𝗮𝗰𝗸 that supports push, pop, top, and retrieving the minimum element in constant time. The trick: store each element as a tuple (value, current_min). When pushing, compute new min as min(previous_min, new_value). This way, every stack element knows the minimum up to that point. All operations remain O(1) - a clever space-time tradeoff. Useful for problems needing constant-time min/max queries in a stack. #Python #Stack #DataStructures #Algorithms #O1Operations

Day 2/100 – #100DaysOfCode Problem Solved: Merge Sorted Array (Python) Instead of using extra space, I applied the three-pointer technique to merge arrays in-place. Pointers Used: i → Last valid element of nums1 j → Last element of nums2 k → Last position of merged array By filling the array from the back, we avoid overwriting important values. Efficient. Clean. Interview-ready. 🚀 #PythonDeveloper #DataStructures #TechInterviewPrep

I recently tackled an interesting sliding window problem: given a binary array, what is the maximum number of consecutive 1's you can get if you are allowed to flip at most k zeros? The Logic: Instead of trying every possible flip (which would be O(n^2) or worse), I used the Sliding Window (Two Pointers) technique. ✅ Expand: Move the right pointer to grow the window. ✅ Constraint Check: If we hit more than 'k' zeros, it's time to shrink the window from the left. ✅ Maximize: Keep track of the largest window size we've seen that satisfies the condition. Efficiency: By only passing through the array once, the solution hits an optimal O(n) time complexity and O(1) space complexity. It’s a classic example of how a dynamic window can turn a complex search into a streamlined linear process. Implementation: https://htmlify.me/r/6uhp #DataStructures #Algorithms #Python #CodingChallenge #SlidingWindow #ProblemSolving

Spent some time working through array pattern problems and revisited the Two Pointer technique using the “Valid Mountain Array” problem. 🧩 Problem Insight: A valid mountain array must: - Strictly increase - Have a peak that is not at the beginning or end - Then strictly decrease 💡 Approach: Instead of checking every possible peak, I used two pointers: - One is moving from the left while the elements increase - One moving from the right while elements decrease - If both pointers meet at the same index (and not at boundaries), the array forms a valid mountain ⚙️ Complexity: Time: O(n) Space: O(1) What I like about this pattern is how it simplifies traversal problems without extra space — clean logic, efficient execution. Always interesting to see how small structural patterns make array problems much clearer. #LeetCode #Python #DataStructures #TwoPointers #ProblemSolving

This solution solves LeetCode 3013: Divide an Array Into Subarrays With Minimum Cost II by applying a sliding window technique with balanced data structures to efficiently track the smallest possible starting elements. Since the first subarray always begins at index 0, its cost is fixed, and the problem reduces to selecting the remaining k−1 starting indices within the given distance constraint such that their values sum to the minimum. By continuously maintaining the smallest k−1 elements as the window moves, the approach achieves optimal performance and avoids time-limit issues common with brute-force methods. #LeetCode #HardProblem #Python #SlidingWindow #DataStructures #Algorithms #CompetitiveProgramming #CodingInterview #Optimization

Few think about memory. In high-scale systems, memory efficiency matters more than micro-speed gains. Small habits that scale: Use generators instead of large lists Avoid unnecessary object copies Understand mutable vs immutable types Be careful with default mutable arguments Efficient memory usage = predictable systems. That’s engineering maturity. #Python #Performance #ScalableSystems #SoftwareEngineering

Happy to share that 𝗥𝗲𝗮𝘅𝗞𝗶𝘁 is now officially published ReaxFF reactive force field simulations are widely used across academia and industry and are integrated into major platforms such as LAMMPS, AMS, and Materials Studio. Yet, until now, there has been no dedicated Python toolkit for systematically handling ReaxFF input/output files and enabling clean pre- and post-processing workflows. ReaxKit fills this gap as a modular, extensible Python toolkit for 𝗽𝗿𝗲-𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴, 𝗽𝗼𝘀𝘁-𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴, 𝗮𝗻𝗱 𝗮𝗻𝗮𝗹𝘆𝘀𝗶𝘀 𝗼𝗳 𝗥𝗲𝗮𝘅𝗙𝗙 𝗺𝗼𝗹𝗲𝗰𝘂𝗹𝗮𝗿 𝗱𝘆𝗻𝗮𝗺𝗶𝗰𝘀 𝘀𝗶𝗺𝘂𝗹𝗮𝘁𝗶𝗼𝗻𝘀, offering both Python APIs and a CLI to bridge raw ReaxFF files to publication-ready results. 🔗 Code: https://lnkd.in/eV5hiN2e 📘 Docs: https://lnkd.in/eixukshu I would like to thank Yun Kyung Shin and Ali Sepehri for their contributions, and Adri van Duin for his guidance, support, and contributions to this work. Any feedback, usage, and suggestions from the community are very welcome and will help guide ReaxKit’s future development. #ReaxFF #ReaxKit #MolecularDynamics #OpenSource #Python #ComputationalMaterials