Sort Integers by The Power Value - Practice Coding Problems

Sort Integers by The Power Value - Problem

The power of an integer is a fascinating concept based on the famous Collatz Conjecture! 🎯

Given any positive integer x, its power value is defined as the number of steps needed to transform it into 1 using these simple rules:

If x is even: x = x / 2
If x is odd: x = 3 * x + 1

Example: The power of x = 3 is 7 because: 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 (7 steps)

Your task is to:

Calculate the power value for all integers in the range [lo, hi]
Sort them by power value in ascending order
If two numbers have the same power, sort them by their numeric value
Return the k-th number in this sorted list

🔥 Challenge: Can you optimize this using memoization to avoid recalculating the same power values?

Input & Output

example_1.py — Basic Range

$ Input: lo = 12, hi = 15, k = 2

› Output: 13

💡 Note: Powers: 12→6→3→10→5→16→8→4→2→1 (9 steps), 13→40→20→10→5→16→8→4→2→1 (9 steps), 14→7→22→11→34→17→52→26→13→40→20→10→5→16→8→4→2→1 (17 steps), 15→46→23→70→35→106→53→160→80→40→20→10→5→16→8→4→2→1 (17 steps). Sorted: [(9,12), (9,13), (17,14), (17,15)]. The 2nd element is 13.

example_2.py — Small Range

$ Input: lo = 7, hi = 11, k = 4

› Output: 7

💡 Note: Powers: 7 (16 steps), 8 (3 steps), 9 (19 steps), 10 (6 steps), 11 (14 steps). Sorted by power: [(3,8), (6,10), (14,11), (16,7), (19,9)]. The 4th element is 7.

example_3.py — Single Element

$ Input: lo = 1, hi = 1, k = 1

› Output: 1

💡 Note: Only one number in range [1,1]. The power of 1 is 0 (already at target). The 1st and only element is 1.

Constraints

1 ≤ lo ≤ hi ≤ 1000
1 ≤ k ≤ hi - lo + 1
All integers will eventually transform to 1
Power values fit in 32-bit signed integer

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Each number begins its transformation journey following the rules

Place Signposts

As we calculate paths, we place signposts (memoization) at key points

Reuse Signposts

Future hikers can use existing signposts to skip calculations

Sort by Distance

Rank all hikers by their total journey length to base camp

Key Takeaway

🎯 Key Insight: Memoization transforms individual calculations into a collaborative effort where each computation benefits future ones, dramatically improving efficiency!

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 25

The optimal solution uses memoization to cache power calculations, avoiding redundant work when multiple numbers share common transformation paths. This reduces time complexity from O(n*m) to O(n*log(max_value)) where many calculations are reused through the dynamic programming cache.

Common Approaches

Approach	Time	Space	Notes
✓ Memoization with Hash Table (Optimal)	O(n * log(max_value) + n log n)	O(n + cache_size)	Use memoization to cache power calculations and avoid redundant work
Brute Force (Calculate Each Power Separately)	O(n * m + n log n)	O(n)	Calculate power for each number individually, then sort and find k-th element

Memoization with Hash Table (Optimal) — Algorithm Steps

Create a memoization cache (hash table) to store computed powers
For each number in range, calculate its power using memoization
During calculation, if we hit a cached value, add it to current steps
Store all (power, number) pairs and sort them
Return the k-th element from sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Cache

Set up memoization with base case memo[1] = 0

Calculate with Cache

For each number, check cache before calculating

Store Path

Save intermediate values during calculation

Backtrack & Memoize

Cache all values in the path for future use

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

#define HASH_SIZE 100000

typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

typedef struct {
    int power;
    int num;
} PowerPair;

HashNode* hashTable[HASH_SIZE];

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

void put(int key, int value) {
    int index = hash(key);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    node->key = key;
    node->value = value;
    node->next = hashTable[index];
    hashTable[index] = node;
}

int get(int key, int* found) {
    int index = hash(key);
    HashNode* node = hashTable[index];
    while (node) {
        if (node->key == key) {
            *found = 1;
            return node->value;
        }
        node = node->next;
    }
    *found = 0;
    return -1;
}

int getPower(int x) {
    int found;
    int cached = get(x, &found);
    if (found) return cached;
    
    int originalX = x;
    int steps = 0;
    int path[1000]; // Assuming max path length
    int pathLen = 0;
    
    // Follow sequence until we hit a memoized value
    while (1) {
        int val = get(x, &found);
        if (found) break;
        
        path[pathLen++] = x;
        if (x % 2 == 0) {
            x = x / 2;
        } else {
            x = 3 * x + 1;
        }
        steps++;
    }
    
    // Backtrack and memoize
    int basePower = get(x, &found);
    for (int i = pathLen - 1; i >= 0; i--) {
        int stepsFromHere = steps - i;
        put(path[i], basePower + stepsFromHere);
    }
    
    return get(originalX, &found);
}

int compare(const void *a, const void *b) {
    PowerPair *pairA = (PowerPair *)a;
    PowerPair *pairB = (PowerPair *)b;
    if (pairA->power == pairB->power) {
        return pairA->num - pairB->num;
    }
    return pairA->power - pairB->power;
}

int getKth(int lo, int hi, int k) {
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    put(1, 0); // Base case
    
    int n = hi - lo + 1;
    PowerPair *powers = (PowerPair *)malloc(n * sizeof(PowerPair));
    
    // Calculate power for each number
    for (int i = 0; i < n; i++) {
        int num = lo + i;
        powers[i].power = getPower(num);
        powers[i].num = num;
    }
    
    // Sort by power, then by number
    qsort(powers, n, sizeof(PowerPair), compare);
    
    int result = powers[k - 1].num;
    free(powers);
    return result;
}

int main() {
    int lo, hi, k;
    scanf("%d %d %d", &lo, &hi, &k);
    printf("%d\n", getKth(lo, hi, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * log(max_value) + n log n)

Each power calculation becomes much faster with memoization, plus sorting

⚡ Linearithmic

Space Complexity

O(n + cache_size)

Space for result array plus memoization cache

⚡ Linearithmic Space

47.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Memoization with Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler