Length of second longest sequence of consecutive 1s in a binary array
Last Updated :
07 Mar, 2022
Given a binary array arr[] of size N, the task is to find the length of the second longest sequence of consecutive 1s present in the array.
Examples:
Input: arr[] = {1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0}
Output: 4 3
Explanation:
Longest sequence of consecutive ones is 4 i.e {arr[7], ... arr[10]}.
Second longest sequence of consecutive ones is 3 i.e {arr[0], ... arr[2]}.
Input: arr[] = {1, 0, 1}
Output: 1 0
Approach: The idea is to traverse the given binary array and keep track of the largest and the second largest length of consecutive one's encountered so far. Below are the steps:
- Initialise variables maxi, count and second_max to store the length of the longest, current and second longest sequence of consecutive 1s respectively..
- Iterate over the given array twice.
- First, traverse the array from left to right. For every 1 encountered, then increment count and compare it with maximum so far. If 0 is encountered, reset count as 0.
- In the second traversal, find the required second longest count of consecutive 1's following the above procedure.
Below is the implementation of the above approach:
C++
// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to find maximum
// and second maximum length
void FindMax(int arr[], int N)
{
// Initialise maximum length
int maxi = -1;
// Initialise second maximum length
int maxi2 = -1;
// Initialise count
int count = 0;
// Iterate over the array
for (int i = 0; i < N; ++i) {
// If sequence ends
if (arr[i] == 0)
// Reset count
count = 0;
// Otherwise
else {
// Increase length
// of current sequence
count++;
// Update maximum
maxi = max(maxi, count);
}
}
// Traverse the given array
for (int i = 0; i < N; i++) {
// If sequence continues
if (arr[i] == 1) {
// Increase length
// of current sequence
count++;
// Update second max
if (count > maxi2 && count < maxi) {
maxi2 = count;
}
}
// Reset count when 0 is found
if (arr[i] == 0)
count = 0;
}
maxi = max(maxi, 0);
maxi2 = max(maxi2, 0);
// Print the result
cout << maxi2;
}
// Driver Code
int main()
{
// Given array
int arr[] = { 1, 1, 1, 0, 0, 1, 1 };
int N = sizeof(arr) / sizeof(arr[0]);
// Function Call
FindMax(arr, N);
return 0;
}
// Java implementation of the above approach
import java.io.*;
import java.util.*;
class GFG{
// Function to find maximum
// and second maximum length
static void FindMax(int arr[], int N)
{
// Initialise maximum length
int maxi = -1;
// Initialise second maximum length
int maxi2 = -1;
// Initialise count
int count = 0;
// Iterate over the array
for(int i = 0; i < N; ++i)
{
// If sequence ends
if (arr[i] == 0)
// Reset count
count = 0;
// Otherwise
else
{
// Increase length
// of current sequence
count++;
// Update maximum
maxi = Math.max(maxi, count);
}
}
// Traverse the given array
for(int i = 0; i < N; i++)
{
// If sequence continues
if (arr[i] == 1)
{
// Increase length
// of current sequence
count++;
// Update second max
if (count > maxi2 &&
count < maxi)
{
maxi2 = count;
}
}
// Reset count when 0 is found
if (arr[i] == 0)
count = 0;
}
maxi = Math.max(maxi, 0);
maxi2 = Math.max(maxi2, 0);
// Print the result
System.out.println( maxi2);
}
// Driver code
public static void main(String[] args)
{
int arr[] = { 1, 1, 1, 0, 0, 1, 1 };
int n = arr.length;
FindMax(arr, n);
}
}
// This code is contributed by Stream_Cipher
# Python3 implementation of the above approach
# Function to find maximum
# and second maximum length
def FindMax(arr, N):
# Initialise maximum length
maxi = -1
# Initialise second maximum length
maxi2 = -1
# Initialise count
count = 0
# Iterate over the array
for i in range(N):
# If sequence ends
if (arr[i] == 0):
# Reset count
count = 0
# Otherwise
else:
# Increase length
# of current sequence
count += 1
# Update maximum
maxi = max(maxi, count)
# Traverse the given array
for i in range(N):
# If sequence continues
if (arr[i] == 1):
# Increase length
# of current sequence
count += 1
# Update second max
if (count > maxi2 and
count < maxi):
maxi2 = count
# Reset count when 0 is found
if (arr[i] == 0):
count = 0
maxi = max(maxi, 0)
maxi2 = max(maxi2, 0)
# Print the result
print(maxi2)
# Driver Code
if __name__ == '__main__':
# Given array
arr = [1, 1, 1, 0, 0, 1, 1]
N = len(arr)
# Function Call
FindMax(arr, N)
# This code is contributed by Mohit Kumar29
// C# implementation of the above approach
using System.Collections.Generic;
using System;
class GFG{
// Function to find maximum
// and second maximum length
static void FindMax(int []arr, int N)
{
// Initialise maximum length
int maxi = -1;
// Initialise second maximum length
int maxi2 = -1;
// Initialise count
int count = 0;
// Iterate over the array
for(int i = 0; i < N; ++i)
{
// If sequence ends
if (arr[i] == 0)
// Reset count
count = 0;
// Otherwise
else
{
// Increase length
// of current sequence
count++;
// Update maximum
maxi = Math.Max(maxi, count);
}
}
// Traverse the given array
for(int i = 0; i < N; i++)
{
// If sequence continues
if (arr[i] == 1)
{
// Increase length
// of current sequence
count++;
// Update second max
if (count > maxi2 &&
count < maxi)
{
maxi2 = count;
}
}
// Reset count when 0 is found
if (arr[i] == 0)
count = 0;
}
maxi = Math.Max(maxi, 0);
maxi2 = Math.Max(maxi2, 0);
// Print the result
Console.WriteLine( maxi2);
}
// Driver code
public static void Main()
{
int []arr = { 1, 1, 1, 0, 0, 1, 1 };
int n = arr.Length;
FindMax(arr, n);
}
}
// This code is contributed by Stream_Cipher
<script>
// JavaScript program to implement
// the above approach
// Function to find maximum
// and second maximum length
function FindMax(arr, N)
{
// Initialise maximum length
let maxi = -1;
// Initialise second maximum length
let maxi2 = -1;
// Initialise count
let count = 0;
// Iterate over the array
for(let i = 0; i < N; ++i)
{
// If sequence ends
if (arr[i] == 0)
// Reset count
count = 0;
// Otherwise
else
{
// Increase length
// of current sequence
count++;
// Update maximum
maxi = Math.max(maxi, count);
}
}
// Traverse the given array
for(let i = 0; i < N; i++)
{
// If sequence continues
if (arr[i] == 1)
{
// Increase length
// of current sequence
count++;
// Update second max
if (count > maxi2 &&
count < maxi)
{
maxi2 = count;
}
}
// Reset count when 0 is found
if (arr[i] == 0)
count = 0;
}
maxi = Math.max(maxi, 0);
maxi2 = Math.max(maxi2, 0);
// Print the result
document.write( maxi2);
}
// Driver code
let arr = [ 1, 1, 1, 0, 0, 1, 1 ];
let n = arr.length;
FindMax(arr, n);
// This code is contributed by target_2.
</script>
Time Complexity: O(N)
Auxiliary Space: O(1)
Similar Reads
Length of the Longest Consecutive 1s in Binary Representation Given a number N, The task is to find the length of the longest consecutive 1s series in its binary representation.Examples : Input: N = 14Output: 3Explanation: The binary representation of 14 is 1110. Input: N = 222Output: 4Explanation: The binary representation of 222 is 11011110. Recommended Prac
9 min read
Length of longest consecutive ones by at most one swap in a Binary String Given a Binary String of length N . It is allowed to do at most one swap between any 0 and 1. The task is to find the length of the longest consecutive 1's that can be achieved. Examples: Input : str = "111011101" Output : 7 We can swap 0 at 4th with 1 at 10th position Input : str = "111000" Output
9 min read
Length of longest consecutive zeroes in the binary representation of a number. We have a number N. Determine the length of the longest consecutive 0's in its binary representation. Examples: Input : N = 14 Output : 1 Binary representation of 14 is 1110. There is only one 0 in the binary representation. Input : N = 9 Output : 2 A simple approach is to traverse through all bits
4 min read
Length of longest subsequence of Fibonacci Numbers in an Array Given an array arr containing non-negative integers, the task is to print the length of the longest subsequence of Fibonacci numbers in this array.Examples: Input: arr[] = { 3, 4, 11, 2, 9, 21 } Output: 3 Here, the subsequence is {3, 2, 21} and hence the answer is 3.Input: arr[] = { 6, 4, 10, 13, 9,
5 min read
Maximum consecutive one’s (or zeros) in a binary array Given a binary array arr[] consisting of only 0s and 1s, find the length of the longest contiguous sequence of either 1s or 0s in the array.Examples : Input: arr[] = [0, 1, 0, 1, 1, 1, 1]Output: 4Explanation: The maximum number of consecutive 1’s in the array is 4 from index 3-6.Input: arr[] = [0, 0
7 min read