Check if an Array Is Consecutive - Practice Coding Problems

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.

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.

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to create hash set + O(n) to check all expected numbers = O(n)

✓ Linear Growth

Space Complexity

O(n)

Hash set stores all n numbers from the input array

⚡ Linearithmic Space

Constraints

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

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

Hash Set (Optimal) — Algorithm Steps

Create a hash set from all numbers in the array
Find the minimum number in the array
For each number from min to min + n - 1:
Check if the number exists in the hash set (O(1) lookup)
If any number is missing, return false
If all numbers exist, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Set

Convert array to hash set for O(1) lookups

Find Range

Determine the expected consecutive range

Fast Lookup

Check each expected number with O(1) hash lookup

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    int key;
    struct HashNode* next;
} HashNode;

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

void insert(HashNode* table[], int key) {
    int index = hash(key);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    node->key = key;
    node->next = table[index];
    table[index] = node;
}

bool contains(HashNode* table[], int key) {
    int index = hash(key);
    HashNode* node = table[index];
    while (node) {
        if (node->key == key) return true;
        node = node->next;
    }
    return false;
}

bool isConsecutive(int* nums, int n) {
    if (n == 0) return true;
    
    // Create hash table
    HashNode* table[HASH_SIZE] = {NULL};
    
    // Insert all numbers and find min
    int minVal = nums[0];
    for (int i = 0; i < n; i++) {
        insert(table, nums[i]);
        if (nums[i] < minVal) {
            minVal = nums[i];
        }
    }
    
    // Check if all expected numbers exist
    for (int expected = minVal; expected < minVal + n; expected++) {
        if (!contains(table, expected)) {
            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)

O(n) to create hash set + O(n) to check all expected numbers = O(n)

✓ Linear Growth

Space Complexity

O(n)

Hash set stores all n numbers from the input array

⚡ Linearithmic Space

Constraints

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler