Keep Multiplying Found Values by Two - Practice Coding Problems

Keep Multiplying Found Values by Two - Problem

You are given an array of integers nums and an integer original representing your starting value. Your task is to implement a value doubling simulation that follows these rules:

Search Phase: Look for the current value of original in the array
Double Phase: If found, multiply original by 2 (i.e., original = 2 * original)
Repeat Phase: Continue the process with the new doubled value
Stop Phase: If the current value is not found in the array, stop the process

Return the final value of original after the simulation completes.

Example: If nums = [5,3,6,1,12] and original = 3, we find 3 → double to 6 → find 6 → double to 12 → find 12 → double to 24 → can't find 24, so return 24.

Input & Output

example_1.py — Basic Doubling

$ Input: nums = [5,3,6,1,12], original = 3

› Output: 24

💡 Note: Start with 3 → found, double to 6 → found, double to 12 → found, double to 24 → not found, return 24

example_2.py — Not Found Initially

$ Input: nums = [2,7,9], original = 4

› Output: 4

💡 Note: Start with 4 → not found in array, so return 4 immediately without any doubling

example_3.py — Single Element

$ Input: nums = [8], original = 8

› Output: 16

💡 Note: Start with 8 → found, double to 16 → not found, return 16

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i], original ≤ 1000
All integers in nums are distinct
At most 10 doubling operations will occur

Visualization

Tap to expand

Understanding the Visualization

Map the Treasure Island

First, create a treasure map (hash set) of all chest contents for instant lookups

Start Your Quest

Begin with your original coin count and check if it exists in any chest

Magic Doubling

If found, your coins magically double and you search for the new amount

End of Adventure

When no chest contains your coin count, the quest ends

Key Takeaway

🎯 Key Insight: Converting the array to a hash set enables instant O(1) treasure chest lookups, making the doubling adventure efficient even with many treasures!

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a hash set to achieve O(1) lookup time for each value in the doubling sequence. Convert the array to a set in O(n) time, then perform constant-time checks while doubling the value. This approach has O(n + k) time complexity where k is the number of doublings (typically small).

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set (Optimal)	O(n + k)	O(n)	Build hash set once, then perform O(1) lookups for each doubled value
Brute Force (Linear Search)	O(n × k)	O(1)	Search through the entire array for each value in the doubling sequence

Hash Set (Optimal) — Algorithm Steps

Convert the nums array into a hash set for O(1) lookup time
Start with the original value as current
While current exists in the hash set, double it
Return the final value when current is not found in the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Set

Convert array [5,3,6,1,12] into hash set {1,3,5,6,12}

Check original=3

O(1) lookup: 3 exists in set → double to 6

Check 6

O(1) lookup: 6 exists in set → double to 12

Check 12

O(1) lookup: 12 exists in set → double to 24

Check 24

O(1) lookup: 24 doesn't exist → return 24

Code -

solution.c — C

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

// Simple hash set implementation for integers
#define HASH_SIZE 1000

typedef struct Node {
    int value;
    struct Node* next;
} Node;

typedef struct {
    Node* table[HASH_SIZE];
} HashSet;

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

void insert(HashSet* set, int value) {
    int index = hash(value);
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->value = value;
    newNode->next = set->table[index];
    set->table[index] = newNode;
}

bool contains(HashSet* set, int value) {
    int index = hash(value);
    Node* current = set->table[index];
    while (current) {
        if (current->value == value) return true;
        current = current->next;
    }
    return false;
}

int findFinalValue(int* nums, int numsSize, int original) {
    HashSet set = {0};
    
    // Build hash set
    for (int i = 0; i < numsSize; i++) {
        insert(&set, nums[i]);
    }
    
    int current = original;
    // Keep doubling while current value exists
    while (contains(&set, current)) {
        current *= 2;
    }
    
    return current;
}

int main() {
    int nums[] = {5, 3, 6, 1, 12};
    int numsSize = 5;
    int original = 3;
    printf("%d\n", findFinalValue(nums, numsSize, original));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k)

O(n) to build hash set + O(k) for k doubling operations, where k is typically small

✓ Linear Growth

Space Complexity

O(n)

Hash set stores all unique elements from the array

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~8 min Avg. Time

892 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

Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler