## 1387. Sort Integers by The Power Value

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-th`

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 32 bit signed integer.

**Example 1:**

Input:lo = 12, hi = 15, k = 2Output:13Explanation: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 = 1, hi = 1, k = 1Output:1

**Example 3:**

Input:lo = 7, hi = 11, k = 4Output:7Explanation: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.

**Example 4:**

Input:lo = 10, hi = 20, k = 5Output:13

**Example 5:**

Input:lo = 1, hi = 1000, k = 777Output:570

**Constraints:**

`1 <= lo <= hi <= 1000`

`1 <= k <= hi - lo + 1`

## Rust Solution

```
struct Solution;
use std::collections::BinaryHeap;
impl Solution {
fn get_kth(lo: i32, hi: i32, k: i32) -> i32 {
let k = k as usize;
let mut pq: BinaryHeap<(i32, i32)> = BinaryHeap::new();
for i in lo..=hi {
pq.push((Self::power(i), i));
if pq.len() > k {
pq.pop();
}
}
pq.pop().unwrap().1
}
fn power(mut num: i32) -> i32 {
let mut res = 0;
while num != 1 {
res += 1;
if num % 2 == 0 {
num /= 2;
} else {
num = 3 * num + 1;
}
}
res
}
}
#[test]
fn test() {
let lo = 12;
let hi = 15;
let k = 2;
let res = 13;
assert_eq!(Solution::get_kth(lo, hi, k), res);
let lo = 1;
let hi = 1;
let k = 1;
let res = 1;
assert_eq!(Solution::get_kth(lo, hi, k), res);
let lo = 7;
let hi = 11;
let k = 4;
let res = 7;
assert_eq!(Solution::get_kth(lo, hi, k), res);
let lo = 10;
let hi = 20;
let k = 5;
let res = 13;
assert_eq!(Solution::get_kth(lo, hi, k), res);
let lo = 1;
let hi = 1000;
let k = 777;
let res = 570;
assert_eq!(Solution::get_kth(lo, hi, k), res);
}
```

Having problems with this solution? Click here to submit an issue on github.