Given an array of 0s and 1s, find the position of 0 to be replaced with 1 to get longest continuous sequence of 1s. Expected time complexity is O(n) and auxiliary space is O(1).

**Example:**

Input: arr[] = {1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1} Output: Index 9 Assuming array index starts from 0, replacing 0 with 1 at index 9 causes the maximum continuous sequence of 1s. Input: arr[] = {1, 1, 1, 1, 0} Output: Index 4

**We strongly recommend to minimize the browser and try this yourself first.**

A **Simple Solution** is to traverse the array, for every 0, count the number of 1s on both sides of it. Keep track of maximum count for any 0. Finally return index of the 0 with maximum number of 1s around it. The time complexity of this solution is O(n^{2}).

Using an **Efficient Solution**, the problem can solved in O(n) time. The idea is to keep track of three indexes, current index (*curr*), previous zero index (*prev_zero*) and previous to previous zero index (*prev_prev_zero*). Traverse the array, if current element is 0, calculate the difference between *curr *and *prev_prev_zero* (This difference minus one is the number of 1s around the prev_zero). If the difference between *curr *and *prev_prev_zero* is more than maximum so far, then update the maximum. Finally return index of the prev_zero with maximum difference.

Following are the implementations of the above algorithm.

## C++

`// C++ program to find Index of 0 to be replaced with 1 to get` `// longest continuous sequence of 1s in a binary array` `#include<iostream>` `using` `namespace` `std;` `// Returns index of 0 to be replaced with 1 to get longest` `// continuous sequence of 1s. If there is no 0 in array, then` `// it returns -1.` `int` `maxOnesIndex(` `bool` `arr[], ` `int` `n)` `{` ` ` `int` `max_count = 0; ` `// for maximum number of 1 around a zero` ` ` `int` `max_index; ` `// for storing result` ` ` `int` `prev_zero = -1; ` `// index of previous zero` ` ` `int` `prev_prev_zero = -1; ` `// index of previous to previous zero` ` ` `// Traverse the input array` ` ` `for` `(` `int` `curr=0; curr<n; ++curr)` ` ` `{` ` ` `// If current element is 0, then calculate the difference` ` ` `// between curr and prev_prev_zero` ` ` `if` `(arr[curr] == 0)` ` ` `{` ` ` `// Update result if count of 1s around prev_zero is more` ` ` `if` `(curr - prev_prev_zero > max_count)` ` ` `{` ` ` `max_count = curr - prev_prev_zero;` ` ` `max_index = prev_zero;` ` ` `}` ` ` `// Update for next iteration` ` ` `prev_prev_zero = prev_zero;` ` ` `prev_zero = curr;` ` ` `}` ` ` `}` ` ` `// Check for the last encountered zero` ` ` `if` `(n-prev_prev_zero > max_count)` ` ` `max_index = prev_zero;` ` ` `return` `max_index;` `}` `// Driver program` `int` `main()` `{` ` ` `bool` `arr[] = {1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1};` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]);` ` ` `cout << ` `"Index of 0 to be replaced is "` ` ` `<< maxOnesIndex(arr, n);` ` ` `return` `0;` `}` |

## Java

`// Java program to find Index of 0 to be replaced with 1 to get` `// longest continuous sequence of 1s in a binary array` `import` `java.io.*;` `class` `Binary` `{ ` ` ` `// Returns index of 0 to be replaced with 1 to get longest` ` ` `// continuous sequence of 1s. If there is no 0 in array, then` ` ` `// it returns -1.` ` ` `static` `int` `maxOnesIndex(` `int` `arr[], ` `int` `n)` ` ` `{` ` ` `int` `max_count = ` `0` `; ` `// for maximum number of 1 around a zero` ` ` `int` `max_index=` `0` `; ` `// for storing result` ` ` `int` `prev_zero = -` `1` `; ` `// index of previous zero` ` ` `int` `prev_prev_zero = -` `1` `; ` `// index of previous to previous zero` ` ` ` ` `// Traverse the input array` ` ` `for` `(` `int` `curr=` `0` `; curr<n; ++curr)` ` ` `{` ` ` `// If current element is 0, then calculate the difference` ` ` `// between curr and prev_prev_zero` ` ` `if` `(arr[curr] == ` `0` `)` ` ` `{` ` ` `// Update result if count of 1s around prev_zero is more` ` ` `if` `(curr - prev_prev_zero > max_count)` ` ` `{` ` ` `max_count = curr - prev_prev_zero;` ` ` `max_index = prev_zero;` ` ` `}` ` ` ` ` `// Update for next iteration` ` ` `prev_prev_zero = prev_zero;` ` ` `prev_zero = curr;` ` ` `}` ` ` `}` ` ` ` ` `// Check for the last encountered zero` ` ` `if` `(n-prev_prev_zero > max_count)` ` ` `max_index = prev_zero;` ` ` ` ` `return` `max_index;` ` ` `}` ` ` ` ` ` ` `// Driver program to test above function` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `arr[] = {` `1` `, ` `1` `, ` `0` `, ` `0` `, ` `1` `, ` `0` `, ` `1` `, ` `1` `, ` `1` `, ` `0` `, ` `1` `, ` `1` `, ` `1` `};` ` ` `int` `n = arr.length;` ` ` `System.out.println(` `"Index of 0 to be replaced is "` `+` ` ` `maxOnesIndex(arr, n)); ` ` ` `}` `}` `/* This code is contributed by Devesh Agrawal */` |

## Python3

`# Python program to find Index` `# of 0 to be replaced with 1 to get` `# longest continuous sequence` `# of 1s in a binary array` `# Returns index of 0 to be` `# replaced with 1 to get longest` `# continuous sequence of 1s.` `# If there is no 0 in array, then` `# it returns -1.` `def` `maxOnesIndex(arr,n):` ` ` ` ` `# for maximum number of 1 around a zero` ` ` `max_count ` `=` `0` ` ` `# for storing result ` ` ` `max_index ` `=` `0` ` ` `# index of previous zero` ` ` `prev_zero ` `=` `-` `1` ` ` `# index of previous to previous zero` ` ` `prev_prev_zero ` `=` `-` `1` ` ` ` ` `# Traverse the input array` ` ` `for` `curr ` `in` `range` `(n):` ` ` ` ` `# If current element is 0,` ` ` `# then calculate the difference` ` ` `# between curr and prev_prev_zero` ` ` `if` `(arr[curr] ` `=` `=` `0` `):` ` ` ` ` `# Update result if count of` ` ` `# 1s around prev_zero is more` ` ` `if` `(curr ` `-` `prev_prev_zero > max_count):` ` ` ` ` `max_count ` `=` `curr ` `-` `prev_prev_zero` ` ` `max_index ` `=` `prev_zero` ` ` ` ` ` ` `# Update for next iteration` ` ` `prev_prev_zero ` `=` `prev_zero` ` ` `prev_zero ` `=` `curr` ` ` ` ` `# Check for the last encountered zero` ` ` `if` `(n` `-` `prev_prev_zero > max_count):` ` ` `max_index ` `=` `prev_zero` ` ` ` ` `return` `max_index` ` ` `# Driver program` `arr ` `=` `[` `1` `, ` `1` `, ` `0` `, ` `0` `, ` `1` `, ` `0` `, ` `1` `, ` `1` `, ` `1` `, ` `0` `, ` `1` `, ` `1` `, ` `1` `]` `n ` `=` `len` `(arr)` `print` `(` `"Index of 0 to be replaced is "` `,` ` ` `maxOnesIndex(arr, n))` `# This code is contributed` `# by Anant Agarwal.` |

## C#

`// C# program to find Index of 0 to be replaced` `// with 1 to get longest continuous sequence of` `// 1s in a binary array` `using` `System;` `class` `GFG {` ` ` ` ` `// Returns index of 0 to be replaced with` ` ` `// 1 to get longest continuous sequence of` ` ` `// 1s. If there is no 0 in array, then it` ` ` `// returns -1.` ` ` `static` `int` `maxOnesIndex(` `int` `[]arr, ` `int` `n)` ` ` `{` ` ` ` ` `// for maximum number of 1 around a zero` ` ` `int` `max_count = 0;` ` ` ` ` `// for storing result` ` ` `int` `max_index = 0;` ` ` ` ` `// index of previous zero` ` ` `int` `prev_zero = -1;` ` ` ` ` `// index of previous to previous zero` ` ` `int` `prev_prev_zero = -1;` ` ` `// Traverse the input array` ` ` `for` `(` `int` `curr = 0; curr < n; ++curr)` ` ` `{` ` ` ` ` `// If current element is 0, then` ` ` `// calculate the difference` ` ` `// between curr and prev_prev_zero` ` ` `if` `(arr[curr] == 0)` ` ` `{` ` ` ` ` `// Update result if count of 1s` ` ` `// around prev_zero is more` ` ` `if` `(curr - prev_prev_zero > max_count)` ` ` `{` ` ` `max_count = curr - prev_prev_zero;` ` ` `max_index = prev_zero;` ` ` `}` ` ` `// Update for next iteration` ` ` `prev_prev_zero = prev_zero;` ` ` `prev_zero = curr;` ` ` `}` ` ` `}` ` ` `// Check for the last encountered zero` ` ` `if` `(n-prev_prev_zero > max_count)` ` ` `max_index = prev_zero;` ` ` `return` `max_index;` ` ` `}` ` ` ` ` `// Driver program to test above function` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `[]arr = {1, 1, 0, 0, 1, 0, 1, 1, 1,` ` ` `0, 1, 1, 1};` ` ` `int` `n = arr.Length;` ` ` `Console.Write(` `"Index of 0 to be replaced is "` ` ` `+ maxOnesIndex(arr, n)); ` ` ` `}` `}` `// This code is contributed by nitin mittal.` |

## PHP

`<?php` `// PHP program to find Index of 0 to be` `// replaced with 1 to get longest continuous` `// sequence of 1s in a binary array` `// Returns index of 0 to be replaced with` `// 1 to get longest continuous sequence of 1s.` `// If there is no 0 in array, then it returns -1.` `function` `maxOnesIndex( ` `$arr` `, ` `$n` `)` `{` ` ` `$max_count` `= 0; ` `// for maximum number of` ` ` `// 1 around a zero` ` ` `$max_index` `; ` `// for storing result` ` ` `$prev_zero` `= -1; ` `// index of previous zero` ` ` `$prev_prev_zero` `= -1; ` `// index of previous to` ` ` `// previous zero` ` ` `// Traverse the input array` ` ` `for` `(` `$curr` `= 0; ` `$curr` `< ` `$n` `; ++` `$curr` `)` ` ` `{` ` ` `// If current element is 0, then` ` ` `// calculate the difference` ` ` `// between curr and prev_prev_zero` ` ` `if` `(` `$arr` `[` `$curr` `] == 0)` ` ` `{` ` ` `// Update result if count of 1s` ` ` `// around prev_zero is more` ` ` `if` `(` `$curr` `- ` `$prev_prev_zero` `> ` `$max_count` `)` ` ` `{` ` ` `$max_count` `= ` `$curr` `- ` `$prev_prev_zero` `;` ` ` `$max_index` `= ` `$prev_zero` `;` ` ` `}` ` ` `// Update for next iteration` ` ` `$prev_prev_zero` `= ` `$prev_zero` `;` ` ` `$prev_zero` `= ` `$curr` `;` ` ` `}` ` ` `}` ` ` `// Check for the last encountered zero` ` ` `if` `(` `$n` `- ` `$prev_prev_zero` `> ` `$max_count` `)` ` ` `$max_index` `= ` `$prev_zero` `;` ` ` `return` `$max_index` `;` `}` `// Driver Code` `$arr` `= ` `array` `(1, 1, 0, 0, 1, 0, 1,` ` ` `1, 1, 0, 1, 1, 1);` `$n` `= sizeof(` `$arr` `);` `echo` `"Index of 0 to be replaced is "` `,` ` ` `maxOnesIndex(` `$arr` `, ` `$n` `);` `// This code is contributed by ajit` `?>` |

## Javascript

`<script>` `// Javascript program to find Index of 0 to` `// be replaced with 1 to get longest continuous` `// sequence of 1s in a binary array` `// Returns index of 0 to be replaced with` `// 1 to get longest continuous sequence of` `// 1s. If there is no 0 in array, then it` `// returns -1.` `function` `maxOnesIndex(arr, n)` `{` ` ` ` ` `// for maximum number of 1 around a zero` ` ` `let max_count = 0;` ` ` ` ` `// for storing result` ` ` `let max_index = 0;` ` ` ` ` `// index of previous zero` ` ` `let prev_zero = -1;` ` ` ` ` `// index of previous to previous zero` ` ` `let prev_prev_zero = -1;` ` ` `// Traverse the input array` ` ` `for` `(let curr = 0; curr < n; ++curr)` ` ` `{` ` ` ` ` `// If current element is 0, then` ` ` `// calculate the difference` ` ` `// between curr and prev_prev_zero` ` ` `if` `(arr[curr] == 0)` ` ` `{` ` ` ` ` `// Update result if count of 1s` ` ` `// around prev_zero is more` ` ` `if` `(curr - prev_prev_zero > max_count)` ` ` `{` ` ` `max_count = curr - prev_prev_zero;` ` ` `max_index = prev_zero;` ` ` `}` ` ` `// Update for next iteration` ` ` `prev_prev_zero = prev_zero;` ` ` `prev_zero = curr;` ` ` `}` ` ` `}` ` ` `// Check for the last encountered zero` ` ` `if` `(n - prev_prev_zero > max_count)` ` ` `max_index = prev_zero;` ` ` `return` `max_index;` `}` `// Driver code` `let arr = [ 1, 1, 0, 0, 1, 0, 1,` ` ` `1, 1, 0, 1, 1, 1 ];` `let n = arr.length;` `document.write(` `"Index of 0 to be replaced is "` `+` ` ` `maxOnesIndex(arr, n)); ` ` ` `// This code is contributed by divyesh072019` `</script>` |

**Output:**

Index of 0 to be replaced is 9

**Time Complexity: **O(n) **Auxiliary Space:** O(1)

This article is contributed by **Ankur Singh**. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.