# Nth Ugly numbers puesudo code using min heap

## 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 = 
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: