Balanced Triplets Subarray

Like11

Balanced Triplets Subarray asks for the longest contiguous subarray that satisfies a triplet-balance rule across every length-3 window inside that subarray. In this dataset, windows containing only one parity (all-even or all-odd) break validity, while mixed-parity triplets are considered balanced enough to keep the streak alive.

A practical approach is to scan with a rolling check on each 3-element window. Extend the current candidate segment while the newest triplet is valid; when a violating triplet appears, restart from a safe position and continue. Track the best start/end span seen so far and return the actual subarray values for that best span. If no valid span exists, return an empty array.

Judge behavior confirms whole-array acceptance for certain mixed patterns, rejection for uniform-parity arrays, and empty output when no qualifying stretch is found. Return the selected subarray structure exactly as expected. The core difficulty is defining violation boundaries correctly so resets neither skip valid recovery points nor include invalid windows in the final returned segment.

Examples

Example 1

Input

nums = [1,2,3,5,4,7,9]

Output

[1,2,3,5,4,7]

Explanation

Sliding windows like [1,2,3], [2,3,5], [3,5,4], [5,4,7] each contain exactly one even and two odd numbers.

Example 2

Input

nums = [2,4,6,8]

Output

[]

Explanation

No window of three values has the required mix.

Example 3

Input

nums = [1,3,2,5,7,4,9,11,6]

Output

[1,3,2,5,7,4,9]

Explanation

The first seven readings sustain the one-even two-odd pattern across every triple.

Algorithm Flow

Recommendation Algorithm Flow for Balanced Triplets Subarray - Budibadu

Best Answers

java

import java.util.*;
class Solution {
    public int[] balanced_triplets_subarray(int[] nums) {
        int n = nums.length;
        if (n < 3) return new int[0];
        
        boolean[] valid_starts = new boolean[n - 2];
        for (int i = 0; i < n - 2; i++) {
            int odd_cnt = 0;
            for (int j = 0; j < 3; j++) {
                if (nums[i+j] % 2 != 0) odd_cnt++;
            }
            if (odd_cnt == 2) valid_starts[i] = true;
        }
        
        int longest_len = 0;
        int best_start = -1;
        int current_start = -1;
        int current_len = 0;
        
        for (int i = 0; i < n - 2; i++) {
            if (valid_starts[i]) {
                if (current_len == 0) current_start = i;
                current_len++;
            } else {
                if (current_len > 0) {
                    int real_len = current_len + 2;
                    if (real_len > longest_len) {
                        longest_len = real_len;
                        best_start = current_start;
                    }
                }
                current_len = 0;
            }
        }
        
        if (current_len > 0) {
            int real_len = current_len + 2;
            if (real_len > longest_len) {
                longest_len = real_len;
                best_start = current_start;
            }
        }
        
        if (best_start == -1) return new int[0];
        return Arrays.copyOfRange(nums, best_start, best_start + longest_len);
    }
}

javascript

function balanced_triplets_subarray(nums) {
    const n = nums.length;
    if (n < 3) return [];

    const valid_starts = new Array(n - 2).fill(false);
    for (let i = 0; i < n - 2; i++) {
        let odd_cnt = 0;
        for (let j = 0; j < 3; j++) {
            if (nums[i+j] % 2 !== 0) odd_cnt++;
        }
        if (odd_cnt === 2) valid_starts[i] = true;
    }

    let longest_len = 0;
    let best_start = -1;
    let current_start = -1;
    let current_len = 0;

    for (let i = 0; i < n - 2; i++) {
        if (valid_starts[i]) {
            if (current_len === 0) current_start = i;
            current_len++;
        } else {
            if (current_len > 0) {
                const real_len = current_len + 2;
                if (real_len > longest_len) {
                    longest_len = real_len;
                    best_start = current_start;
                }
            }
            current_len = 0;
        }
    }

    if (current_len > 0) {
        const real_len = current_len + 2;
        if (real_len > longest_len) {
            longest_len = real_len;
            best_start = current_start;
        }
    }

    if (best_start === -1) return [];
    return nums.slice(best_start, best_start + longest_len);
}

php

<?php
function balanced_triplets_subarray($nums) {
    $n = count($nums);
    if ($n < 3) return [];

    $valid_starts = array_fill(0, $n - 2, false);
    for ($i = 0; $i < $n - 2; $i++) {
        $odd_cnt = 0;
        for ($j = 0; $j < 3; $j++) {
            if ($nums[$i+$j] % 2 != 0) $odd_cnt++;
        }
        if ($odd_cnt == 2) $valid_starts[$i] = true;
    }

    $longest_len = 0;
    $best_start = -1;
    
    $current_start = -1;
    $current_len = 0;

    for ($i = 0; $i < $n - 2; $i++) {
        if ($valid_starts[$i]) {
            if ($current_len == 0) $current_start = $i;
            $current_len++;
        } else {
            if ($current_len > 0) {
                $real_len = $current_len + 2;
                if ($real_len > $longest_len) {
                    $longest_len = $real_len;
                    $best_start = $current_start;
                }
            }
            $current_len = 0;
        }
    }

    if ($current_len > 0) {
        $real_len = $current_len + 2;
        if ($real_len > $longest_len) {
            $longest_len = $real_len;
            $best_start = $current_start;
        }
    }

    if ($best_start == -1) return [];
    
    return array_slice($nums, $best_start, $longest_len);
}
?>

python

from typing import List

def balanced_triplets_subarray(nums: List[int]) -> List[int]:
    n = len(nums)
    if n < 3: return []
    
    valid_starts = [False] * (n - 2)
    for i in range(n - 2):
        odd_cnt = 0
        for j in range(3):
            if nums[i+j] % 2 != 0: odd_cnt += 1
        if odd_cnt == 2:
            valid_starts[i] = True
            
    longest_len = 0
    best_start = -1
    
    current_start = -1
    current_len = 0
    
    for i in range(n - 2):
        if valid_starts[i]:
            if current_len == 0:
                current_start = i
            current_len += 1
        else:
            if current_len > 0:
                # Length of subarray is triplets count + 2
                real_len = current_len + 2
                if real_len > longest_len:
                    longest_len = real_len
                    best_start = current_start
            current_len = 0
            
    if current_len > 0:
        real_len = current_len + 2
        if real_len > longest_len:
            longest_len = real_len
            best_start = current_start
            
    if best_start == -1:
        return []
        
    return nums[best_start : best_start + longest_len]

rust

pub fn balanced_triplets_subarray(nums: Vec<i32>) -> Vec<i32> {
    let n = nums.len();
    if n < 3 {
        return Vec::new();
    }

    let mut valid_starts = vec![false; n - 2];
    for i in 0..n-2 {
        let mut odd_cnt = 0;
        for j in 0..3 {
            if nums[i+j] % 2 != 0 {
                odd_cnt += 1;
            }
        }
        if odd_cnt == 2 {
            valid_starts[i] = true;
        }
    }

    let mut longest_len = 0;
    let mut best_start = 0;
    let mut found = false;

    let mut current_start = 0;
    let mut current_len = 0;

    for i in 0..n-2 {
        if valid_starts[i] {
            if current_len == 0 {
                current_start = i;
            }
            current_len += 1;
        } else {
            if current_len > 0 {
                let real_len = current_len + 2;
                if real_len > longest_len {
                    longest_len = real_len;
                    best_start = current_start;
                    found = true;
                }
            }
            current_len = 0;
        }
    }

    if current_len > 0 {
        let real_len = current_len + 2;
        if real_len > longest_len {
            longest_len = real_len;
            best_start = current_start;
            found = true;
        }
    }

    if !found {
        return Vec::new();
    }

    nums[best_start..best_start + longest_len].to_vec()
}

typescript

function balanced_triplets_subarray(nums: number[]): number[] {
    const n = nums.length;
    if (n < 3) return [];

    const valid_starts: boolean[] = new Array(n - 2).fill(false);
    for (let i = 0; i < n - 2; i++) {
        let odd_cnt = 0;
        for (let j = 0; j < 3; j++) {
            if (nums[i+j] % 2 !== 0) odd_cnt++;
        }
        if (odd_cnt === 2) valid_starts[i] = true;
    }

    let longest_len = 0;
    let best_start = -1;
    let current_start = -1;
    let current_len = 0;

    for (let i = 0; i < n - 2; i++) {
        if (valid_starts[i]) {
            if (current_len === 0) current_start = i;
            current_len++;
        } else {
            if (current_len > 0) {
                const real_len = current_len + 2;
                if (real_len > longest_len) {
                    longest_len = real_len;
                    best_start = current_start;
                }
            }
            current_len = 0;
        }
    }

    if (current_len > 0) {
        const real_len = current_len + 2;
        if (real_len > longest_len) {
            longest_len = real_len;
            best_start = current_start;
        }
    }

    if (best_start === -1) return [];
    return nums.slice(best_start, best_start + longest_len);
}

Comments (0)

Join the Discussion

Share your thoughts, ask questions, or help others with this problem.

Balanced Triplets Subarray

Examples

Algorithm Flow

Best Answers

Solutions Coming Soon

Related Sliding Window Problems

Maximum Sum Subarray Size K

First Negative In Every Window

Maximum Vowels In Substring Length K

Contains Nearby Duplicate Window

Minimum Recolors To Get K Consecutive Black Blocks

Comments (0)

Join the Discussion