add the regular numbers problem (#116)

Author: spring1843

README.md

@@ -8,10 +8,10 @@
 
 Welcome to **Data Structures and Algorithms in Go**! 🎉 This project is designed as a dynamic, hands-on resource for learning and practicing data structures and algorithms in the Go programming language.
 
-* At least six problems and solutions for each of the fourteen topics
-* Completely free, community-driven, and continuously evolving
-* Executes and comes with 100% test coverage, ensuring a high level of quality
-* Ability to use in your favorite IDE, editor, or web browser
+* More than one hundred rehearsal problems, at least six problems for each of the fifteen topics
+* Executable and comes with 100% test coverage, ensuring correctness and quality
+* Completely free, community-editable, and continuously evolving
+* Ability to study and practice in your favorite IDE, editor, or web browser
 * Pure Go, no third-party libraries, Guaranteed forward compatibility
 
 ## 📚 Table of Contents
@@ -75,6 +75,7 @@ Welcome to **Data Structures and Algorithms in Go**! 🎉 This project is design
         * [Kth Largest Element](./heap/kth_largest_element_test.go)
         * [Merge Sorted Lists](./heap/merge_sorted_list_test.go)
         * [Median in a Stream](./heap/median_in_a_stream_test.go)
+        * [Regular Numbers](./heap/regular_numbers_test.go)
         * [Kth Closest Points to the Center](./heap/k_closest_points_to_origin_test.go)
         * [Sliding Maximum](./heap/sliding_maximum_test.go)
         * [Heap Sort](./heap/heap_sort_test.go)

heap/README.md

@@ -97,5 +97,6 @@ Priority queues implemented as heaps are commonly used in job scheduling, for ex
 * [Kth Largest Element](./kth_largest_element_test.go), [Solution](./kth_largest_element.go)
 * [Merge Sorted Lists](./merge_sorted_list_test.go), [Solution](./merge_sorted_list.go)
 * [Median in a Stream](./median_in_a_stream_test.go), [Solution](./median_in_a_stream_test.go)
+* [Regular Numbers](./regular_numbers_test.go), [Solution](./regular_numbers_test.go)
 * [Kth Closest Points to the Center](./k_closest_points_to_origin_test.go), [Solution](./k_closest_points_to_origin.go)
 * [Sliding Maximum](./sliding_maximum_test.go), [Solution](./sliding_maximum.go)

heap/regular_numbers.go

@@ -0,0 +1,26 @@
+package heap
+
+import "container/heap"
+
+// RegularNumbers solves the problem in O(n*log n) time and O(n) space.
+func RegularNumbers(n int) []int {
+	output := []int{}
+	minHeap := &minHeap{}
+	heap.Push(minHeap, 1)
+
+	last, count := 0, 0
+
+	for count < n {
+		current := heap.Pop(minHeap).(int)
+		if current > last {
+			output = append(output, current)
+			last = current
+			count++
+			heap.Push(minHeap, current*2)
+			heap.Push(minHeap, current*3)
+			heap.Push(minHeap, current*5)
+		}
+	}
+
+	return output
+}

heap/regular_numbers_test.go

@@ -0,0 +1,37 @@
+package heap
+
+import (
+	"reflect"
+	"testing"
+)
+
+/*
+TestRegularNumbers tests solution(s) with the following signature and problem description:
+
+	func RegularNumbers(n int) []int
+
+Regular numbers are numbers whose only prime divisors are 2, 3, and 5.
+For example 24 is a regular number because it can be factored into 2^3 * 3^1 * 5^0.
+Given a positive integer n, write a function that returns the first n regular numbers.
+*/
+func TestRegularNumbers(t *testing.T) {
+	tests := []struct {
+		n              int
+		regularNumbers []int
+	}{
+		{0, []int{}},
+		{1, []int{1}},
+		{2, []int{1, 2}},
+		{3, []int{1, 2, 3}},
+		{4, []int{1, 2, 3, 4}},
+		{5, []int{1, 2, 3, 4, 5}},
+		{10, []int{1, 2, 3, 4, 5, 6, 8, 9, 10, 12}},
+		{15, []int{1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24}},
+	}
+
+	for i, test := range tests {
+		if got := RegularNumbers(test.n); !reflect.DeepEqual(got, test.regularNumbers) {
+			t.Fatalf("Failed test case #%d. Want %v got %d", i, test.regularNumbers, got)
+		}
+	}
+}