Three Consecutive Odds

• Check if the array has fewer than 3 elements. If so, return false as it's impossible to have three consecutive numbers.
• Loop through the array from index i = 0 to arr.length - 3.
• Inside the loop, check if arr[i], arr[i+1], and arr[i+2] are all odd using the modulo operator (%).
• If all three are odd, we have found our sequence, so we return true.
• If the loop finishes without finding such a sequence, we return false.

We can solve this by iterating through the array with a loop. The loop should start at index 0 and end at arr.length - 3 to ensure there are at least three elements left to check (the current one, and the next two).

In each iteration, for the current index i, we check if the number arr[i], the next number arr[i+1], and the number after that arr[i+2] are all odd.

An integer x is odd if the remainder of its division by 2 is not 0 (i.e., x % 2 != 0).

If we find a triplet (arr[i], arr[i+1], arr[i+2]) where all three are odd, we can immediately stop and return true.

If the loop finishes without finding any such triplet, it means no three consecutive odd numbers exist in the array, so we return false.

1class Solution {2    public boolean threeConsecutiveOdds(int[] arr) {3        // We need at least 3 elements to have 3 consecutive odds.4        if (arr.length < 3) {5            return false;6        }7 8        // Iterate up to the third-to-last element.9        for (int i = 0; i <= arr.length - 3; i++) {10            // Check if the current, next, and next-next elements are all odd.11            if (arr[i] % 2 != 0 && arr[i+1] % 2 != 0 && arr[i+2] % 2 != 0) {12                return true;13            }14        }15 16        // If the loop completes, no such sequence was found.17        return false;18    }19}

• Initialize a counter oddCount to 0.
• Loop through each number num in the array arr.
• If num is odd, increment oddCount.
• If num is even, reset oddCount to 0.
• In each iteration, after updating the counter, check if oddCount is equal to 3. If it is, return true.
• If the loop completes, return false.

This approach uses a single pass and a counter to track the number of consecutive odd numbers. This is more efficient as it avoids re-inspecting elements.

We initialize a counter, say oddCount, to 0. We then iterate through each number in the array arr.

For each number:

• If the number is odd, we increment oddCount.
• If the number is even, it breaks any existing sequence of odds, so we must reset oddCount to 0.

After processing each number, we check if oddCount has reached 3. If it has, we've found our target sequence and can return true immediately.

If we finish iterating through the entire array and the counter never reached 3, it means no such sequence exists, and we return false.

1class Solution {2    public boolean threeConsecutiveOdds(int[] arr) {3        int oddCount = 0;4        for (int num : arr) {5            if (num % 2 != 0) {6                oddCount++;7            } else {8                // Reset the counter if we find an even number.9                oddCount = 0;10            }11            // Check if we have found three consecutive odds.12            if (oddCount == 3) {13                return true;14            }15        }16        // If we finish the loop, it means we didn't find 3 consecutive odds.17        return false;18    }19}