#2057

Easy

auto_awesomeArray-driven solution strategy

LeetCode Problem Workspace

Smallest Index With Equal Value

Find the smallest index where the index mod 10 equals the value at that index in the given array.

Problem Statement

Given a 0-indexed integer array nums, you need to return the smallest index i such that i mod 10 equals nums[i]. If no such index exists, return -1.

The operation i mod y returns the remainder when i is divided by y. You are tasked with finding the smallest index where this condition holds, or -1 if no such index is found.

Examples

Example 1

Input: nums = [0,1,2]

Output: 0

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

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

No index satisfies i mod 10 == nums[i].

Constraints

1 <= nums.length <= 100
0 <= nums[i] <= 9

Solution Approach

Iterate through the Array

To solve the problem, loop through each index of the array and check if the condition i mod 10 == nums[i] holds. The first index that satisfies this condition should be returned immediately.

Efficient Index Checking

Since the problem involves checking the modulo condition for each index, we ensure that we stop as soon as we find the first valid index. This avoids unnecessary checks after finding a valid index.

Handle Edge Cases

Consider the edge case where no index satisfies the condition. In such cases, return -1 to signal that no valid index was found.

Complexity Analysis

Metric	Value
Time	Depends on the final approach
Space	Depends on the final approach

The time complexity is O(n) because we check each index once, where n is the length of the array. The space complexity is O(1) since we only need a constant amount of extra space.

What Interviewers Usually Probe

Check the candidate's approach to early exits when a solution is found.
Assess how they handle edge cases like no valid index or a very small array.
Evaluate their understanding of the modulo operation and how it can be applied efficiently.

Common Pitfalls or Variants

Common pitfalls

Overlooking the possibility of no valid index and returning incorrect results.
Not returning the smallest valid index when multiple indices satisfy the condition.
Confusing the modulo operation and how it works with non-zero divisors.

Follow-up variants

Change the condition to i mod k == nums[i] where k is a parameter.
Allow negative numbers in the array and modify the solution accordingly.
Limit the size of the array to a specific value and optimize the approach.

FAQ

What is the primary pattern for solving Smallest Index With Equal Value?

The primary pattern is an array-driven solution strategy where we check each index for the condition i mod 10 == nums[i].

What if no index satisfies the condition in Smallest Index With Equal Value?

If no index satisfies the condition, the correct answer is -1, indicating that no valid index was found.

How does GhostInterview help with the Smallest Index With Equal Value problem?

GhostInterview guides you through iterating the array and ensures that you handle early exits and edge cases properly.

What is the time complexity of Smallest Index With Equal Value?

The time complexity is O(n) because each index is checked once, where n is the length of the array.

Can the Smallest Index With Equal Value problem be optimized further?

The solution is already optimized for the problem as it checks each index only once and stops early once a valid index is found.

terminal

Solution

Solution 1: Traversal

We directly traverse the array. For each index $i$, we check if it satisfies $i \bmod 10 = \textit{nums}[i]$. If it does, we return the current index $i$.

1

2

3

4

5

6

class Solution:
    def smallestEqual(self, nums: List[int]) -> int:
        for i, x in enumerate(nums):
            if i % 10 == x:
                return i
        return -1

Continue Practicing

#2056 number of valid move combinations on chessboard #2055 plates between candles #2059 minimum operations to convert number