DSA With TheAbbie

Lazy Deletion in Heap: A Wrapper for Python heapq Lazy Deletion in Heap: A Wrapper for Python heapq In many programming scenarios, we often encounter situations where we need to maintain a heap data structure and perform operations such as insertion, deletion, and retrieval of the minimum element efficiently. Python provides a built-in module called heapq that offers heap operations. However, the standard heapq module does not provide direct support for lazy deletion, which can be useful in certain cases. In this article, we will explore a wrapper class, Heap , that extends the functionality of the Python heapq library to support lazy deletion in a heap. The Heap Class The Heap class is a wrapper that encapsulates the heapq module to enable lazy deletion in a heap. Let's go through its main methods and their functionalities: __init__(self) : Initializes the Heap instance by creating an empty heap and a defaultdict to track the deleted elements

Efficient Generation of Nth Row of Binomial Coefficient Modulo M Efficient Generation of Nth Row of Binomial Coefficient Modulo M Introduction Calculating the binomial coefficient (also known as the combinatorial coefficient) is a common task in mathematics and programming. However, when the modulo M is not prime, finding an efficient method becomes more challenging. In this article, we will explore a technique that allows us to efficiently generate the Nth row of the binomial coefficient modulo M, even when M is not necessarily prime. This technique utilizes prime factorization and a sieve algorithm to achieve efficient computation. The Implementation Let's take a look at the implementation of the technique: from collections import Counter N = 1 + 10 ** 6 v = [False] * N spf = [1] * N for i in range(2, N, 2): spf[i] = 2 for i in range(3, N, 2): if not v[i]: spf[i] = i j = i while j * i < N: if not

Special Queue: A Queue Implemented Using Two Stacks Special Queue: A Queue Implemented Using Two Stacks Introduction Queues and stacks are fundamental data structures used in computer science and programming. However, what if we could combine the benefits of both data structures into a single efficient data structure? In this article, we will explore a special Queue implementation that utilizes two stacks. This special Queue leverages the Last-In-First-Out (LIFO) property of stacks to store the value of some operation on the elements, allowing us to perform various operations on the Queue efficiently. The Queue Implementation Let's take a look at the implementation of the special Queue using two stacks: class Queue: def __init__(self, init = float('inf'), func = min): self.func = func self.f = Stack(init, func) self.s = Stack(init, func) def push(self, val): sel

Counting Solutions to Linear Inequalities: Exploring the Floorsum Technique Introduction: In many mathematical and programming problems, there is a need to count the number of non-negative integer solutions to a linear inequality of the form ax + by ≤ c. The coefficients a, b, and c can be quite large, up to 10^9. In this blog post, we will explore a new technique called "Floorsum" that efficiently calculates the number of solutions to such inequalities. The Floorsum Function: The key to solving this problem lies in the implementation of the floorsum function: def floorsum(n, m, a, b): ans = 0 while True: if a >= m: ans += n * (n - 1) // 2 * (a // m) a %= m if b >= m: ans += n * (b // m) b %= m y_max = a * n + b if y_max < m: break n = y_max // m b = y_max % m m, a = a, m return ans The floorsum function is a clever implementation t

Exploring a Number Conversion Algorithm Exploring a Number Conversion Algorithm Category: algorithms Description In this blog post, we will explore an interesting number conversion algorithm that utilizes the Counter data structure from the collections module. We will walk through the provided code snippet and understand its functionality. Code Snippet from collections import Counter def convert(n): if n <= 0: return Counter() x = 1 while pow(x + 1, x + 1) <= n: x += 1 return convert(n - pow(x, x)) + Counter({x: 1}) print(convert(38748358348)) Explanation The code begins by importing the Counter class from the collections module. The Counter class is a powerful tool for counting elements in an iterable. It allows us to easily keep track of the frequency of elements in a collection. The convert function takes an integer n as input and returns a Counter object. Let's dive into the implementation of the convert function: def conv

Count Largest Equal Pairs Count Largest Equal Pairs Category: algorithms Description Given a 0-indexed integer array nums of length n, return the number of pairs (i, j) where 0 <= i <= j < n, such that nums[i] == nums[j] and nums[k] <= nums[i] for i <= k <= j Solutions The O(N^2) solution is simple as we traverse every pair and keep track of the maximum value between them, thus, we count pairs where the maximum between the pairs is less than or equal to the equal pair. But the constraints of the problems won't allow O(N^2), to optimize we make use of the fact that we are only interested in indexes such that the maximum up to that index is at most nums[i] for each i, ie. if j is the first index to the right of i such that nums[j] > nums[i] then we only need to count equal pairs from index i to index j - 1. So, we need the next greater element for each index, which is a well-known monotonic stack problem possible in O(N) https://leetcode.com/problem