From 22e0d26e58916ecce36ecb600c19d3d701951739 Mon Sep 17 00:00:00 2001 From: 0xff-dev Date: Sat, 23 Sep 2023 22:33:19 +0800 Subject: [PATCH] Add solution, readme and test-cases for problem 1387 --- .../README.md | 45 +++++++++++++++++++ .../Solution.go | 32 ++++++++++++- .../Solution_test.go | 21 +++++---- 3 files changed, 85 insertions(+), 13 deletions(-) create mode 100644 leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/README.md diff --git a/leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/README.md b/leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/README.md new file mode 100644 index 000000000..6d182d583 --- /dev/null +++ b/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 kth 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 diff --git a/leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/Solution.go b/leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/Solution.go index d115ccf5e..98ef93e8c 100755 --- a/leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/Solution.go +++ b/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] } diff --git a/leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/Solution_test.go b/leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/Solution_test.go index 14ff50eb4..8430bca2b 100755 --- a/leetcode/1301-1400/1387.Sort-Integers-by-The-Power-Value/Solution_test.go +++ b/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() { }