Heap clarifying rehearsal problems (#180)

Author: spring1843

heap/README.md

@@ -14,27 +14,27 @@ When pushing an element to a heap, because of the structure property, the new el
 ```ASCII
 [Figure 1] Minimum heap push operation
 
-  20	    20		  15			 15		15		5
- /  \	   /  \		 /  \			/  \	      	/  \	      /   \
-25  30	  25  30  	20  30	               20  30	      5   30	    15     30
-         /	       /      	              /  \	     / \           /  \
-        15	      25	             25   5	   25  20	 25    20
+  20	    20	     20          15			 15		 15		5
+ /  \	   /  \	    /  \        /  \			/  \	      	/  \	      /   \
+25  30	  25  30   15  30      20  30	               20  30	      5   30	    15     30
+         /	      /	      /      	              /  \	     / \           /  \
+        15	     25	     25                      25   5	   25  20	 25    20
 										
-	(A) Add 15		     	    (B) Add 5
+	(A) Push 15		     	    (B) Push 5
 ```
 
-The pop operation in a heap starts by replacing the root with the rightmost leaf. Then the root is swapped with the smaller child in a min heap (and the larger child in a max heap). The root is removed and the new root is percolated down until the heap property is achieved.
+The pop operation in a heap starts by taking the root out and replacing its value with the rightmost leaf. Then the new root is swapped with the smaller child in a min heap (and the larger child in a max heap). The root is removed and the new root is percolated down until the heap property is achieved.
 
 ```ASCII
 [Figure 2] Minimum heap pop operation
 
-       5	    20	       15		  25	   20		  30
-     /   \	   /  \	      /  \		 /  \	  /  \		 /
-    15   30	  15  30     20  30		20  30   25  30		25
+        5	    20	       15		  25	   20		  30
+      /   \	   /  \	      /  \		 /  \	  /  \		 /
+    15    30	  15  30     20  30		20  30   25  30		25
    /  \		 /	    /
   25  20	25	   25
 
-	(A) Remove				(B) Remove		(C) Remove
+	       (A) Pop				    (B) Pop		(C) Pop
 ```
 
 An example implementation of this is provided as a [solution](./heap_sort.go) to the [heap sort](./heap_sort_test.go) rehearsal.
@@ -59,9 +59,8 @@ func main() {
 		heap.Push(h, i)
 	}
 	for i := 1; i <= 10; i++ {
-		fmt.Println(heap.Pop(h))
+		fmt.Println(heap.Pop(h)) // Prints 10,9,8,...1
 	}
-
 }
 
 func (m maxHeap) Len() int           { return len(m) }
@@ -77,7 +76,7 @@ func (m *maxHeap) Pop() any {
 }
 ```
 
-To utilize a heap to store a particular type, certain methods such as len and less must be implemented for that type to conform to the heap interface. By default, the heap is a min heap, with each node smaller than its children. However, the package provides the flexibility to define what "being less than" means. For instance, changing `m[i] > m[j]` to `m[i] < m[j]` would transform the heap into a minimum heap.
+To utilize a heap to store a particular type, certain methods such as len and less must be implemented for that type to conform to the heap interface. The package provides the flexibility to define what "being less than" means. For instance in the above example to changing `m[i] > m[j]` to `m[i] < m[j]` would transform the heap into a max heap.
 
 In Go, heaps are implemented with slices. The heap property is maintained such that the left child of the node at index `i` (where i is greater than or equal to 1) is always located at `2i`, and the right child is at `2i+1`. If the slice already contains elements before pushing, the heap must be initialized using `heap.Init(h Interface)` to establish the order.
 

heap/heap_sort_test.go

@@ -11,7 +11,12 @@ TestSort tests solution(s) with the following signature and problem description:
 
 	func HeapSort(list []int) []int
 
-Given a list of integers like {3,1,2}, return a sorted set like {1,2,3} using Heap Sort.
+Given a slice of integers, return a sorted slice using Heap Sort.
+
+For example given {3,1,2}, return {1,2,3}.
+
+Heap sort works by inserting all items to a heap and then popping them one by. As heap returns the minimum
+element with each pop the outcome is a sorted list of items..
 */
 func TestSort(t *testing.T) {
 	tests := []struct {

heap/k_closest_points_to_origin_test.go

@@ -11,6 +11,8 @@ TestKClosestPointToOrigin tests solution(s) with the following signature and pro
 	func KClosestPointToOrigin(points [][]int, k int) [][]int
 
 Given coordination of a point on an x,y axis and an integer k, return k closest points to the origin.
+
+For example given {1,1}, {2,2}, {3,3}, {4,4} and k=2, return {1,1}, {2,2}.
 */
 func TestKClosestPointToOrigin(t *testing.T) {
 	tests := []struct {

heap/kth_largest_element_test.go

@@ -7,8 +7,10 @@ TestKthLargestElement tests solution(s) with the following signature and problem
 
 	func KthLargestElement(elements []int, k int) int
 
-Given an array of integers like {3,5,6,3,1,2,9} and k an integer like 3 return the kth
-largest element like 5.
+Given a slice of integers and an integer k, return the kth largest element.
+
+For example given {3,5,6,3,1,2,9} and k=3 return 5, because largest integers are 9, 6, 5 and
+the 3rd largest is 5.
 */
 func TestKthLargestElement(t *testing.T) {
 	tests := []struct {

heap/median_in_a_stream_test.go

@@ -8,8 +8,9 @@ TestMedianInAStream tests solution(s) with the following signatures and problem
 	func newMedianKeeper() medianKeeper
 	func (m *medianKeeper) addNumber(num int)
 
-Given a stream of integers like {1,2,3,4}, output the median after each input
-like {1, 1.5, 2, 2.5}.
+Given a stream of integers, return the median of the set after each input.
+
+For example given {1,2,3,4}, return {1, 1.5, 2, 2.5} after each input respectively.
 */
 func TestMedianInAStream(t *testing.T) {
 	tests := []struct {

heap/merge_sorted_list_test.go

@@ -11,8 +11,9 @@ TestMergeSortedLists tests solution(s) with the following signature and problem
 
 	func MergeSortedLists(lists []*linkedlist.Node) *linkedlist.Node
 
-Given multiple sorted linked lists like {1->2, 1->3->4, 4->5}, join them into one
-like 1->1->2->3->4->4->5.
+Given multiple sorted linked lists, join them together into one sorted linked list.
+
+For example given {1->2, 1->3->4, 4->5} return 1->1->2->3->4->4->5.
 */
 func TestMergeSortedLists(t *testing.T) {
 	tests := []struct {

heap/regular_numbers_test.go

@@ -12,7 +12,17 @@ TestRegularNumbers tests solution(s) with the following signature and problem de
 
 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.
+
+Given a positive integer n, return first n regular numbers.
+
+For example given n=4:
+
+	1 = 2^0
+	2 = 2^1
+	3 = 3^1
+	4 = 2^2
+
+So the first 3 regular numbers are {1, 2, 3, 4}.
 */
 func TestRegularNumbers(t *testing.T) {
 	tests := []struct {

heap/sliding_max_test.go

@@ -11,9 +11,18 @@ TestMaxSlidingWindow tests solution(s) with the following signature and problem
 
 	func MaxSlidingWindow(numbers []int, k int) []int
 
-Given a list of integers like {1, 4, 5, -2, 4, 6}, and a positive integer k like 3, return
-the maximum of each slice of the array when a window of length k is moved from left to the
-right in the array like {5, 5, 5, 6}.
+Given a slice of integers and a positive integer k, return the maximum of each sub-slice of the
+slice when a window of length k is moved from left to right and we can only see k elements that
+are in the window.
+
+For example given {1,4,5,-2,4,6} and k=3, we will have the following windows:
+
+	{1,4,5} -> 5
+	{4,5,-2} -> 5
+	{5,-2,4} -> 5
+	{-2,4,6} -> 6
+
+So return {5,5,5,6}.
 */
 func TestMaxSlidingWindow(t *testing.T) {
 	tests := []struct {