**Efficient Generation of Ugly numbers puesudo code using min heap**

Ugly numbers are a sequence of numbers where each number is the product of 2, 3, or 5. The first few ugly numbers are 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, and so on. The idea behind ugly numbers is to find a way to generate them efficiently, as they have several applications in computer science and mathematics.

One approach to finding ugly numbers is to use a min heap data structure. In this approach, we keep track of the ugly numbers that have been found so far and use them to generate the next ugly number by multiplying by 2, 3, or 5. We can then add the new ugly number to the list and repeat the process until we have found the “nth” ugly number.

**SOLUTION**

Here is a sample pseudo code for finding the “nth” **Ugly numbers puesudo code using min heap**:

```
def nth_ugly_number(n):
if n <= 0:
return None
ugly_numbers = [1]
i2, i3, i5 = 0, 0, 0
while len(ugly_numbers) < n:
m2, m3, m5 = ugly_numbers[i2] * 2, ugly_numbers[i3] * 3, ugly_numbers[i5] * 5
ugly_number = min(m2, m3, m5)
if ugly_number == m2:
i2 += 1
if ugly_number == m3:
i3 += 1
if ugly_number == m5:
i5 += 1
ugly_numbers.append(ugly_number)
return ugly_numbers[n-1]
```

This implementation uses a min heap-like data structure to keep track of the ugly numbers that have been found so far. The **ugly_numbers** list stores the ugly numbers, and **i2, i3,** and **i5** are indices into the **ugly_numbers** list that are used to generate the next ugly number by multiplying by **2, 3, **and **5** respectively. The **m2, m3,** and **m5** variables store the next ugly number that would be generated by multiplying the current ugly numbers by **2, 3,** and **5** respectively. The **ugly_number** variable stores the smallest of these three values, and this is added to the **ugly_numbers** list. The indices **i2, i3,** and **i5** are updated as needed to keep track of which ugly numbers have been used.

The time complexity of this algorithm is O(n), as we need to generate n ugly numbers. The space complexity is also O(n), as we need to store the ugly numbers that have been found.

In conclusion, the min heap approach to finding ugly numbers is an efficient and simple solution to the problem. It provides a fast way to generate the “nth” ugly number, and is easy to implement and understand.

**Related:**