Three Consecutive Odds - Practice Coding Problems

Three Consecutive Odds - Problem

Array Easy

You're given an integer array arr and need to determine if there are three consecutive odd numbers anywhere in the array.

Goal: Return true if you can find three odd numbers that appear one after another in the array, otherwise return false.

What makes a number odd? A number is odd if it's not divisible by 2 (i.e., num % 2 == 1).

Example: In the array [2, 6, 4, 1, 3, 5, 8], we have three consecutive odd numbers: 1, 3, 5 at positions 3, 4, and 5, so we return true.

Input & Output

example_1.py — Basic case with consecutive odds

$ Input: [2, 6, 4, 1, 3, 5, 8]

› Output: true

💡 Note: The array contains three consecutive odd numbers: 1, 3, 5 at indices 3, 4, and 5.

example_2.py — No three consecutive odds

$ Input: [1, 2, 34, 3, 6, 7, 23, 12]

› Output: false

💡 Note: While there are odd numbers (1, 3, 7, 23), no three of them appear consecutively.

example_3.py — All odd numbers

$ Input: [1, 3, 5]

› Output: true

💡 Note: The entire array consists of three consecutive odd numbers.

Visualization

Tap to expand

Understanding the Visualization

Start monitoring

Begin walking down the street, counting consecutive green lights

Count greens

For each green light, increment counter; for red lights, reset to 0

Found pattern

When we see 3 consecutive greens, we've found our answer!

Key Takeaway

🎯 Key Insight: We only need to track consecutive odd numbers with a simple counter, resetting when we hit even numbers and returning true immediately when the counter reaches 3!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, visiting each element exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using one integer variable to count consecutive odds

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 1000
1 ≤ arr[i] ≤ 1000
Array elements can be any positive integers

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a single-pass counter approach with O(n) time and O(1) space. We maintain a counter of consecutive odd numbers, incrementing it for odd numbers and resetting it for even numbers. As soon as the counter reaches 3, we return true immediately.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Triplet)	O(n)	O(1)	Check every possible group of 3 consecutive elements
Single Pass Counter (Optimal)	O(n)	O(1)	Count consecutive odd numbers in one pass through the array

Brute Force (Check Every Triplet) — Algorithm Steps

Loop through array from index 0 to n-3
For each position i, check if arr[i], arr[i+1], and arr[i+2] are all odd
If found, return true immediately
If no triplet found after checking all positions, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Check elements at indices 0, 1, 2

Move to position 1

Check elements at indices 1, 2, 3

Continue sliding

Keep checking triplets until we find three consecutive odds or reach the end

Code -

solution.c — C

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

bool solution(int* arr, int size) {
    // Check every possible triplet of consecutive elements
    for (int i = 0; i < size - 2; i++) {
        // Check if current element and next two are all odd
        if (arr[i] % 2 == 1 && arr[i + 1] % 2 == 1 && arr[i + 2] % 2 == 1) {
            return true;
        }
    }
    return false;
}

int main() {
    int arr[1000];
    int size = 0;
    char c;
    int num = 0;
    bool reading_num = false;
    
    // Simple array parser
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading_num = true;
        } else if (reading_num) {
            arr[size++] = num;
            num = 0;
            reading_num = false;
        }
    }
    if (reading_num) arr[size++] = num;
    
    printf("%s\n", solution(arr, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through n-2 positions, and for each position we do constant work (3 checks)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures needed

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 1000
1 ≤ arr[i] ≤ 1000
Array elements can be any positive integers

42.0K Views

Medium Frequency

~12 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

Brute Force (Check Every Triplet) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler