Codestin Search App

Check if an Array Is Consecutive - Problem

Given an integer array nums, determine if the array contains consecutive integers that form a complete sequence.

An array is considered consecutive if it contains every number in the range [x, x + n - 1] (inclusive), where:

x is the minimum number in the array
n is the length of the array

Return true if the array is consecutive, false otherwise.

Example: The array [4, 2, 1, 3] is consecutive because it contains all numbers from 1 to 4. However, [1, 3, 4] is not consecutive because it's missing 2.

Input & Output

example_1.py — Basic Consecutive Array

$ Input: [1, 3, 2, 4]

› Output: true

💡 Note: The array contains all numbers from 1 to 4. After sorting: [1,2,3,4] - each adjacent pair differs by 1, forming a complete consecutive sequence.

example_2.py — Missing Number

$ Input: [1, 3, 4]

› Output: false

💡 Note: The minimum is 1 and length is 3, so we expect [1,2,3]. However, the number 2 is missing from the array, making it non-consecutive.

example_3.py — Single Element

$ Input: [5]

› Output: true

💡 Note: A single element is always consecutive. The expected range is [5,5] which contains only the number 5, and it exists in the array.

Constraints

0 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
All elements in nums are integers

Visualization

Tap to expand

Understanding the Visualization

Catalog Your Books

Create a quick-lookup catalog (hash set) of all books you have

Determine Expected Range

Find the lowest volume number and calculate expected range

Check Each Volume

For each expected volume, instantly check if it exists in your catalog

Key Takeaway

🎯 Key Insight: Instead of searching for each expected number repeatedly, create a hash set for instant O(1) lookups. This transforms an O(n²) search problem into an O(n) lookup problem.

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses a hash set for O(1) lookups. Build the hash set from input array, find the minimum value, then check if all numbers in range [min, min+n-1] exist in the set. This achieves O(n) time complexity compared to O(n²) brute force or O(n log n) sorting approaches.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each expected number, scan the entire array to check if it exists
Sorting + Verification	O(n log n)	O(1)	Sort the array and verify consecutive property by checking adjacent elements
Hash Set (Optimal)	O(n)	O(n)	Use hash set for O(1) lookups to check if all expected numbers exist

Brute Force (Nested Loops) — Algorithm Steps

Find the minimum number in the array
For each number from min to min + n - 1:
Search through the entire array to find this number
If any number is not found, return false
If all numbers are found, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Minimum

Scan array to find minimum value (starting point)

Check Each Expected

For each expected number, search through entire array

Linear Search

Scan all elements until we find the target or reach the end

Code -

solution.c — C

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

bool isConsecutive(int* nums, int n) {
    if (n == 0) return true;
    
    int minVal = nums[0];
    for (int i = 1; i < n; i++) {
        if (nums[i] < minVal) {
            minVal = nums[i];
        }
    }
    
    // Check if each expected number exists
    for (int expected = minVal; expected < minVal + n; expected++) {
        bool found = false;
        for (int i = 0; i < n; i++) {
            if (nums[i] == expected) {
                found = true;
                break;
            }
        }
        if (!found) return false;
    }
    
    return true;
}

int main() {
    int nums[1000];
    int n = 0;
    char ch;
    scanf("%c", &ch); // '['
    while (scanf("%d", &nums[n]) == 1) {
        n++;
        scanf("%c", &ch); // ',' or ']'
        if (ch == ']') break;
    }
    printf("%s\n", isConsecutive(nums, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n expected numbers, we search through the entire array of n elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track minimum and current search value

✓ Linear Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.9K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler