Smallest Index With Digit Sum Equal to Index

Smallest Index With Digit Sum Equal to Index - Problem

Array Math Easy

You are given an integer array nums. Return the smallest index i such that the sum of the digits of nums[i] is equal to i. If no such index exists, return -1.

The sum of digits of a number is calculated by adding all its individual digits together. For example, the sum of digits of 123 is 1 + 2 + 3 = 6.

Input & Output

Example 1 — Basic Case

$ Input: nums = [18, 43, 29, 5, 37]

› Output: -1

💡 Note: Check each index: digit_sum(18)=9 ≠ 0, digit_sum(43)=7 ≠ 1, digit_sum(29)=11 ≠ 2, digit_sum(5)=5 ≠ 3, digit_sum(37)=10 ≠ 4. No match found.

Example 2 — Found Match

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

› Output: 0

💡 Note: At index 0: digit_sum(0) = 0, which equals the index 0. Return 0 as it's the smallest matching index.

Example 3 — Later Match

$ Input: nums = [10, 20, 11, 3]

› Output: 2

💡 Note: Check indices: digit_sum(10)=1 ≠ 0, digit_sum(20)=2 ≠ 1, digit_sum(11)=2 = 2. Return index 2 as it's the first match.

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8

The key insight is that we need to find the smallest index where the sum of digits equals the index value. Since we want the smallest index, we must scan from left to right. Best approach is linear scan with digit sum calculation. Time: O(n × d), Space: O(1).

Common Approaches

✓ Linear Scan with Digit Sum

⏱️ Time: O(n × d) Space: O(1)

For each index, calculate the sum of digits of nums[i] and check if it equals i. Return the first matching index, or -1 if none found.

Optimized Digit Sum Calculation

⏱️ Time: O(n × d) Space: O(1)

Use the same approach but optimize the digit sum calculation by avoiding repeated modulo operations where possible. The overall complexity remains the same.

Linear Scan with Digit Sum — Algorithm Steps

Step 1: Iterate through each index i from 0 to n-1
Step 2: Calculate sum of digits of nums[i]
Step 3: If digit sum equals i, return i
Step 4: If no match found, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Check if digit sum of nums[0] equals 0

Continue to next indices

Calculate digit sum and compare with index

Return first match

Return the smallest index where condition is met

Code -

solution.c — C

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

int digitSum(int n) {
    n = abs(n);
    int total = 0;
    while (n > 0) {
        total += n % 10;
        n /= 10;
    }
    return total;
}

int solution(int* nums, int numsSize) {
    for (int i = 0; i < numsSize; i++) {
        if (digitSum(nums[i]) == i) {
            return i;
        }
    }
    return -1;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × d)

We iterate through n elements, and for each element we calculate digit sum which takes O(d) time where d is number of digits

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

12.4K Views

Medium Frequency

~15 min Avg. Time

234 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

Linear Scan with Digit Sum — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler