Smallest Index With Equal Value solution and explanation
Google
9 more videos on this problem
Leetcode | 2057. Smallest Index With Equal Value | Easy | Java SolutionDeveloper Docs · 3:53 · 1K views
2057. Smallest Index With Equal Value (Leetcode Easy)Programming Live with Larry · 2:00 · 308 views
2057. Smallest Index With Equal Value | LEETCODE EASYcode Explainer · 1:45 · 255 views
Leetcode 2057. Smallest Index With Equal ValueStill Compiling · 4:38 · 213 views
Smallest Index With Equal Value Leetcode - 2057 | Coder InfinityCoder Infinity · 1:26 · 89 views
Leetcode 2057 Smallest Index With Equal ValueMath Geeks · 0:48 · 40 views
LeetCode: 2057. Smallest Index With Equal Value | Day 20CodeWithMaaz · 6:39 · 40 views
2057. Smallest Index With Equal Value - Javascript - Time: O(n) Space: O(1) - LeetcodeAaron Sadino Coding · 11:31 · 30 views
LeetCode 2057 - Smallest Index With Equal Value 🔥Jal Patel · 4:02 · 24 views
LeetCode 2057 | Smallest Index With Equal Value | Linear Scan | C++Hanuman Singh Rajpurohit · 5:26 · 18 views
The problem
Given a 0-indexed integer array nums, return the smallest index i of nums such that i mod 10 == nums[i], or -1 if such index does not exist.
x mod y denotes the remainder when x is divided by y.
Example 1:
Input: nums = [0,1,2] Output: 0 Explanation: i=0: 0 mod 10 = 0 == nums[0]. i=1: 1 mod 10 = 1 == nums[1]. i=2: 2 mod 10 = 2 == nums[2]. All indices have i mod 10 == nums[i], so we return the smallest index 0.
Example 2:
Input: nums = [4,3,2,1] Output: 2 Explanation: i=0: 0 mod 10 = 0 != nums[0]. i=1: 1 mod 10 = 1 != nums[1]. i=2: 2 mod 10 = 2 == nums[2]. i=3: 3 mod 10 = 3 != nums[3]. 2 is the only index which has i mod 10 == nums[i].
Example 3:
Input: nums = [1,2,3,4,5,6,7,8,9,0] Output: -1 Explanation: No index satisfies i mod 10 == nums[i].
Constraints:
1 <= nums.length <= 1000 <= nums[i] <= 9
Approach overview
Problem Overview: Given an integer array nums, return the smallest index i such that i % 10 == nums[i]. If no index satisfies the condition, return -1. The task is mainly about scanning the array and checking a simple modulo condition.
Approach 1: Iterative Method (O(n) time, O(1) space)
The most direct solution is a single pass through the array. For each index i, compute i % 10 and compare it with nums[i]. The first index where the values match is the answer because the traversal proceeds from left to right. As soon as the condition holds, return that index immediately.
This approach relies only on sequential iteration and constant-time arithmetic operations. No additional data structures are needed. The algorithm performs exactly one comparison per element, making the time complexity O(n) and space complexity O(1). Because the problem asks for the smallest index, scanning from the beginning naturally guarantees correctness.
This is the approach most developers use in practice. The logic is minimal, easy to implement, and efficient even for large arrays. Problems involving element checks tied to index properties often reduce to a straightforward traversal over an array.
Approach 2: Divide and Conquer (O(n) time, O(log n) space)
A divide and conquer variant splits the array into two halves and recursively checks each segment for a valid index. The algorithm first searches the left half. If a valid index exists there, return it immediately because it will always be smaller than any index in the right half. If the left half contains no valid index, search the right half.
Each recursive call processes a smaller portion of the array while maintaining the original index positions for the modulo comparison. The overall number of examined elements remains n, so the time complexity stays O(n). However, recursive calls introduce a stack depth of O(log n).
This method demonstrates the mechanics of divide and conquer, but it does not provide a performance advantage over a simple loop. The modulo comparison still needs to happen for each element, and recursion only adds overhead. Still, it can be useful when practicing recursive decomposition patterns alongside simple array traversal.
Recommended for interviews: The iterative scan is the expected answer. Interviewers typically look for the observation that you only need to check each index once and can return immediately on the first match. Mentioning the O(n) time and O(1) space complexity demonstrates solid understanding. The divide and conquer version is mostly educational rather than practical.
Approach 1: Approach 1: Iterative Method
This approach involves using a simple iterative method to solve the problem. The idea is to loop through the data structure, process elements, and maintain a result based on conditions.
def solve(arr):
result = sum(arr)
print(f"Result: {result}")public class Solution {
public static void solve(int[] arr) {
int result = 0;
for (int num : arr) {
result += num;
}
System.out.println("Result: " + result);
}
}#include <iostream>
#include <vector>
void solve(const std::vector<int>& arr) {
int result = 0;
for (int num : arr) {
result += num;
}
std::cout << "Result: " << result << std::endl;
}function solve(arr) {
const result = arr.reduce((a, b) => a + b, 0);
console.log(`Result: ${result}`);
}#include <stdio.h>
void solve(int arr[], int size) {
int result = 0;
for (int i = 0; i < size; i++) {
result += arr[i];
}
printf("Result: %d\n", result);
}using System;
class Solution {
public static void Solve(int[] arr) {
int result = 0;
foreach (int num in arr) {
result += num;
}
Console.WriteLine("Result: " + result);
}
}Python provides a built-in function sum() that efficiently computes the sum of iterable elements.
Time Complexity: O(n)
Space Complexity: O(1)
Approach 2: Approach 2: Divide and Conquer
This approach uses the divide and conquer strategy, which involves dividing the problem into sub-problems, solving each sub-problem independently, and combining the results.
def sum(arr, low, high):
if low > high:
return 0
if low == high:
return arr[low]
mid = (low + high) // 2
return sum(arr, low, mid) + sum(arr, mid + 1, high)
def solve(arr):
result = sum(arr, 0, len(arr) - 1)
print(f"Result: {result}")public class Solution {
public static int sum(int[] arr, int low, int high) {
if (low > high) return 0;
if (low == high) return arr[low];
int mid = (low + high) / 2;
return sum(arr, low, mid) + sum(arr, mid + 1, high);
}
public static void solve(int[] arr) {
int result = sum(arr, 0, arr.length - 1);
System.out.println("Result: " + result);
}
}#include <iostream>
#include <vector>
int sum(const std::vector<int>& arr, int low, int high) {
if (low > high) return 0;
if (low == high) return arr[low];
int mid = (low + high) / 2;
return sum(arr, low, mid) + sum(arr, mid+1, high);
}
void solve(const std::vector<int>& arr) {
int result = sum(arr, 0, arr.size() - 1);
std::cout << "Result: " << result << std::endl;
}function sum(arr, low, high) {
if (low > high) return 0;
if (low === high) return arr[low];
const mid = Math.floor((low + high) / 2);
return sum(arr, low, mid) + sum(arr, mid + 1, high);
}
function solve(arr) {
const result = sum(arr, 0, arr.length - 1);
console.log(`Result: ${result}`);
}#include <stdio.h>
int sum(int arr[], int low, int high) {
if (low > high) return 0;
if (low == high) return arr[low];
int mid = (low + high) / 2;
return sum(arr, low, mid) + sum(arr, mid+1, high);
}
void solve(int arr[], int size) {
int result = sum(arr, 0, size - 1);
printf("Result: %d\n", result);
}using System;
class Solution {
public static int Sum(int[] arr, int low, int high) {
if (low > high) return 0;
if (low == high) return arr[low];
int mid = (low + high) / 2;
return Sum(arr, low, mid) + Sum(arr, mid + 1, high);
}
public static void Solve(int[] arr) {
int result = Sum(arr, 0, arr.Length - 1);
Console.WriteLine("Result: " + result);
}
}The Python code defines a recursive function to break down the array summing process using divide and conquer principles.
Time Complexity: O(n log n)
Space Complexity: O(log n)
Approach 3: Traversal
We directly traverse the array. For each index i, we check if it satisfies i bmod 10 = nums[i]. If it does, we return the current index i.
If we traverse the entire array and do not find a satisfying index, we return -1.
The time complexity is O(n), where n is the length of the array. The space complexity is O(1).
function smallestEqual(nums: number[]): number {
for (let i = 0; i < nums.length; ++i) {
if (i % 10 === nums[i]) {
return i;
}
}
return -1;
}func smallestEqual(nums []int) int {
for i, x := range nums {
if i%10 == x {
return i
}
}
return -1
}impl Solution {
pub fn smallest_equal(nums: Vec<i32>) -> i32 {
for (i, &x) in nums.iter().enumerate() {
if i % 10 == x as usize {
return i as i32;
}
}
-1
}
}class Solution {
func smallestEqual(nums: Array<Int64>): Int64 {
for (i in 0..nums.size) {
if (i % 10 == nums[i]) {
return i
}
}
-1
}
}Complexity comparison
| Approach | Complexity |
|---|---|
| Approach 1: Iterative Method | Time Complexity: O(n) |
| Approach 2: Divide and Conquer | Time Complexity: O(n log n) |
| Traversal | – |
Complexity analysis
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Iterative Method | O(n) | O(1) | Best for this problem. Simple linear scan and early return when the first valid index appears. |
| Divide and Conquer | O(n) | O(log n) | Useful for practicing recursive decomposition, though it adds overhead compared to iteration. |
Frequently asked questions
Is Smallest Index With Equal Value easy or hard?
Smallest Index With Equal Value is classified as an Easy problem on LeetCode. The challenge mainly tests understanding of array iteration and modulo arithmetic rather than complex algorithms or data structures.
Smallest Index With Equal Value Python/Java solution
In Python or Java, implement a loop that checks each index i and compares i % 10 with nums[i]. If they match, return i. Otherwise continue scanning until the end and return -1 if no valid index exists. The implementation stays O(n) time and O(1) space in both languages.
How to solve Smallest Index With Equal Value in O(n)?
Traverse the array from left to right. For each index i, compute i % 10 and compare it with nums[i]. If they match, return i immediately because it is the smallest valid index. If the loop finishes without a match, return -1.
What is the best approach for Smallest Index With Equal Value?
The best approach is a simple linear scan of the array. Iterate through indices from 0 to n-1 and check whether i % 10 equals nums[i]. The first index satisfying this condition is returned immediately. This method runs in O(n) time and O(1) space.
Is Smallest Index With Equal Value asked at Google/Amazon/Meta?
Problems based on simple array traversal and modular arithmetic appear frequently in coding interviews at companies like Amazon and Google. While this exact question may vary, the pattern of scanning arrays and validating index-based conditions is common in entry-level interview rounds.
What data structure is used in Smallest Index With Equal Value?
The problem uses a basic array. The solution only requires sequential traversal and a modulo operation on the index. No additional data structures such as hash maps or stacks are needed.
What is the time complexity of Smallest Index With Equal Value?
The optimal solution runs in O(n) time because each element of the array is checked once. The space complexity is O(1) since only a few variables are used and no additional data structures are required.