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

Sum of Values at Indices With K Set Bits - Problem

You are given a 0-indexed integer array nums and an integer k.

Return an integer that denotes the sum of elements in nums whose corresponding indices have exactly k set bits in their binary representation.

The set bits in an integer are the 1's present when it is written in binary.

For example: The binary representation of 21 is 10101, which has 3 set bits.

Input & Output

Example 1 — Basic Case

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

› Output: 13

💡 Note: Check indices: i=0 has 0 set bits, i=1 has 1 set bit (nums[1]=10), i=2 has 1 set bit (nums[2]=1), i=3 has 2 set bits, i=4 has 1 set bit (nums[4]=2). Sum = 10+1+2 = 13.

Example 2 — All Zero Bits

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

› Output: 4

💡 Note: Only index 0 has 0 set bits (binary: 0), so we sum only nums[0] = 4.

Example 3 — No Matches

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

› Output: 0

💡 Note: No index from 0-2 has 3 set bits (max is 2 bits for index 3), so sum is 0.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input

Array nums=[5,10,1,5,2] and k=1

Process

Check each index binary representation for k set bits

Output

Sum values at matching indices: 13

Key Takeaway

🎯 Key Insight: Focus on index bit patterns, not array values - efficient bit counting is the optimization key

Asked in

a Amazon 15 M Microsoft 8

The key insight is to focus on indices rather than array values - count set bits in position numbers. Best approach uses built-in bit counting functions. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Bit Counting	O(n log n)	O(1)	Manually count set bits for each index by repeatedly dividing by 2
Built-in Bit Count	O(n)	O(1)	Use built-in functions to count set bits efficiently

Brute Force Bit Counting — Algorithm Steps

Iterate through each array index
For each index, count set bits by dividing by 2
If bit count equals k, add nums[index] to sum
Return total sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Index

For each array index, convert to binary

Count Bits

Manually count 1's by dividing by 2

Sum Values

Add array value if bit count equals k

Code -

solution.c — C

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

int countSetBits(int n) {
    int count = 0;
    while (n > 0) {
        count += n & 1;
        n >>= 1;
    }
    return count;
}

int solution(int* nums, int numsSize, int k) {
    int totalSum = 0;
    for (int i = 0; i < numsSize; i++) {
        if (countSetBits(i) == k) {
            totalSum += nums[i];
        }
    }
    return totalSum;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[100];
    int numsSize = 0;
    char* ptr = line + 1; // Skip '['
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

For n indices, each bit counting takes O(log i) time, sum is O(n log n)

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for counting, no extra data structures

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

345 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

Brute Force Bit Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler