Add solution, readme and test-cases for problem 1387

leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/README.md

@@ -0,0 +1,45 @@
+# [1387.Sort Integers by The Power Value][title]
+
+## Description
+The power of an integer `x` is defined as the number of steps needed to transform `x` into `1` using the following steps:
+
+- if `x` is even then `x = x / 2`
+- if `x` is odd then `x = 3 * x + 1`
+
+For example, the power of `x = 3` is `7` because `3` needs `7` steps to become `1` `(3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1)`.
+
+Given three integers `lo`, `hi` and `k`. The task is to sort all integers in the interval `[lo, hi]` by the power value in **ascending order**, if two or more integers have **the same** power value sort them by **ascending order**.
+
+Return the k<sup>th</sup> integer in the range `[lo, hi]` sorted by the power value.
+
+Notice that for any integer `x` `(lo <= x <= hi)` it is **guaranteed** that `x` will transform into `1` using these steps and that the power of `x` is will **fit** in a 32-bit signed integer.
+
+**Example 1:**
+
+```
+Input: lo = 12, hi = 15, k = 2
+Output: 13
+Explanation: The power of 12 is 9 (12 --> 6 --> 3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1)
+The power of 13 is 9
+The power of 14 is 17
+The power of 15 is 17
+The interval sorted by the power value [12,13,14,15]. For k = 2 answer is the second element which is 13.
+Notice that 12 and 13 have the same power value and we sorted them in ascending order. Same for 14 and 15.
+```
+
+**Example 2:**
+
+```
+Input: lo = 7, hi = 11, k = 4
+Output: 7
+Explanation: The power array corresponding to the interval [7, 8, 9, 10, 11] is [16, 3, 19, 6, 14].
+The interval sorted by power is [8, 10, 11, 7, 9].
+The fourth number in the sorted array is 7.
+```
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me]
+
+[title]: https://leetcode.com/problems/sort-integers-by-the-power-value
+[me]: https://github.com/kylesliu/awesome-golang-algorithm

leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/Solution.go

@@ -1,5 +1,33 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+import (
+	"sort"
+)
+
+func power(x int, cache map[int]int) int {
+	if x == 1 {
+		return 1
+	}
+	if v, ok := cache[x]; ok {
+		return v
+	}
+	var ans int
+	if x&1 == 0 {
+		ans = power(x/2, cache) + 1
+	} else {
+		ans = power(x*3+1, cache) + 1
+	}
+	cache[x] = ans
+	return ans
+}
+func Solution(lo, hi, k int) int {
+	cache := make(map[int]int)
+	x := make([][2]int, hi-lo+1)
+	for i := lo; i <= hi; i++ {
+		x[i-lo] = [2]int{power(i, cache), i}
+	}
+	sort.SliceStable(x, func(i, j int) bool {
+		return x[i][0] < x[j][0]
+	})
+	return x[k-1][1]
 }

leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/Solution_test.go

@@ -9,31 +9,30 @@ import (
 func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
-		name   string
-		inputs bool
-		expect bool
+		name      string
+		lo, hi, k int
+		expect    int
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", 12, 15, 2, 13},
+		{"TestCase2", 7, 11, 4, 7},
 	}
 
 	//	开始测试
 	for i, c := range cases {
 		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := Solution(c.inputs)
+			got := Solution(c.lo, c.hi, c.k)
 			if !reflect.DeepEqual(got, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, got, c.inputs)
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v %v %v",
+					c.expect, got, c.lo, c.hi, c.k)
 			}
 		})
 	}
 }
 
-//	压力测试
+// 压力测试
 func BenchmarkSolution(b *testing.B) {
 }
 
-//	使用案列
+// 使用案列
 func ExampleSolution() {
 }