Sum of Values at Indices With K Set Bits - Practice Coding Problems

Sum of Values at Indices With K Set Bits - Problem

Given a 0-indexed integer array nums and an integer k, you need to find the sum of all elements in the array whose array indices have exactly k set bits in their binary representation.

A set bit is a bit with value 1 in the binary representation of a number. For example:

Index 5 has binary representation 101 → 2 set bits
Index 7 has binary representation 111 → 3 set bits
Index 8 has binary representation 1000 → 1 set bit

Goal: Return the sum of nums[i] for all indices i where the binary representation of i contains exactly k ones.

Input & Output

example_1.py — Basic Case

$ Input: nums = [5,10,1,5,2], k = 1

› Output: 13

💡 Note: Indices with exactly 1 set bit: 1 (binary: 1), 2 (binary: 10), 4 (binary: 100). Sum: nums[1] + nums[2] + nums[4] = 10 + 1 + 2 = 13

example_2.py — Multiple Set Bits

$ Input: nums = [4,3,2,1], k = 2

› Output: 1

💡 Note: Only index 3 has exactly 2 set bits (binary: 11). Sum: nums[3] = 1

example_3.py — Edge Case k=0

$ Input: nums = [1,2,3], k = 0

› Output: 1

💡 Note: Only index 0 has exactly 0 set bits (binary: 0). Sum: nums[0] = 1

Visualization

Tap to expand

Understanding the Visualization

Index to Binary

Convert array index to binary representation

Count Set Bits

Use efficient bit manipulation to count 1's

Compare and Sum

If count equals k, add array value to result

Key Takeaway

🎯 Key Insight: Use efficient bit manipulation functions to count set bits instead of string conversion for optimal O(n) performance.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, bit counting is O(1) with built-in functions

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
0 ≤ k ≤ 10

Asked in

G Google 15 ⊞ Microsoft 12 a Amazon 8 f Meta 6

The optimal solution uses bit manipulation to efficiently count set bits in each array index. By leveraging built-in functions like popcount or implementing Brian Kernighan's algorithm, we achieve O(n) time complexity with O(1) space, avoiding the overhead of string conversion used in naive approaches.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (String Conversion)	O(n * log n)	O(log n)	Convert each index to binary string and count '1' characters
Bit Manipulation (Optimal)	O(n)	O(1)	Use built-in bit counting or Brian Kernighan's algorithm for efficient set bit counting

Brute Force (String Conversion) — Algorithm Steps

Iterate through all indices from 0 to length-1
Convert each index to binary string representation
Count the number of '1' characters in the binary string
If count equals k, add nums[index] to the result sum
Return the final sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert Index

Convert current index to binary string

Count Set Bits

Count '1' characters in the string

Check Condition

If count equals k, add nums[i] to sum

Code -

solution.c — C

int sumIndicesWithKSetBits(int* nums, int numsSize, int k) {
    int result = 0;
    for (int i = 0; i < numsSize; i++) {
        // Count set bits by converting to binary
        int temp = i, setBits = 0;
        if (temp == 0 && k == 0) {
            result += nums[i];
            continue;
        }
        while (temp > 0) {
            if (temp % 2 == 1) setBits++;
            temp /= 2;
        }
        if (setBits == k) {
            result += nums[i];
        }
    }
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * log n)

For each of n elements, we convert index to binary string which takes O(log n) time

⚡ Linearithmic

Space Complexity

O(log n)

Space for binary string representation of largest index

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
0 ≤ k ≤ 10

28.5K Views

Medium Frequency

~8 min Avg. Time

890 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (String Conversion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler