From 66f1e01434de9f06a32abfab05c1012e0c0e8755 Mon Sep 17 00:00:00 2001
From: alex <alexrafael10@gmail.com>
Date: Sat, 30 Apr 2022 23:48:03 -0300
Subject: [PATCH] Sort Integers by The Power Value

---
 power-value/README.md     | 43 +++++++++++++++++++++++++++++++++++++++
 power-value/index.test.ts | 11 ++++++++++
 power-value/index.ts      | 35 +++++++++++++++++++++++++++++++
 3 files changed, 89 insertions(+)
 create mode 100644 power-value/README.md
 create mode 100644 power-value/index.test.ts
 create mode 100644 power-value/index.ts

diff --git a/power-value/README.md b/power-value/README.md
new file mode 100644
index 0000000..198ada0
--- /dev/null
+++ b/power-value/README.md
@@ -0,0 +1,43 @@
+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.
+```
+ 
+
+**Constraints:**
+
+- `1 <= lo <= hi <= 1000`
+- `1 <= k <= hi - lo + 1`
\ No newline at end of file
diff --git a/power-value/index.test.ts b/power-value/index.test.ts
new file mode 100644
index 0000000..d6f8643
--- /dev/null
+++ b/power-value/index.test.ts
@@ -0,0 +1,11 @@
+import { getKth } from "./index";
+
+describe("Power Value", () => {
+  test("Input: lo = 12, hi = 15, k = 2 | Output: 13", () => {
+    expect(getKth(12, 15, 2)).toBe(13);
+  });
+
+  test("Input: lo = 7, hi = 11, k = 4 | Output: 7", () => {
+    expect(getKth(7, 11, 4)).toBe(7);
+  });
+})
\ No newline at end of file
diff --git a/power-value/index.ts b/power-value/index.ts
new file mode 100644
index 0000000..125b69a
--- /dev/null
+++ b/power-value/index.ts
@@ -0,0 +1,35 @@
+export const getKth = (lo: number, hi: number, k: number): number => {
+  const getPowerOfX = (x: number): number => {
+    let steps = 0;
+    let remaining = x;
+
+    while (remaining != 1) {
+      if (remaining % 2 === 0) {
+        remaining = remaining / 2;
+      } else {
+        remaining = 3 * remaining + 1;
+      }
+      steps++;
+
+    }
+
+    return steps;
+  }
+
+  const intervalMap: { [key: number]: number } = {};
+
+  for (let i = lo; i <= hi; i++) {
+    intervalMap[i] = getPowerOfX(i);
+  }
+
+  const sortedInterval: number[] = Object.keys(intervalMap).map(key => parseInt(key)).sort((keyA, keyB) => {
+    const a = intervalMap[keyA];
+    const b = intervalMap[keyB];
+
+    if (a === b) return keyA - keyB;
+
+    return a - b;
+  })
+
+  return sortedInterval[k - 1];
+}