Find Index of 0 to be replaced with 1 to get longest continuous sequence of 1s in a binary array | Set-2

// C# program to find index of zero 
// to be replaced by one to get longest 
// continuous sequence of ones. 


using System;

public 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(bool []arr, int n) { 
        int i = 0; 

        // To store count of ones on left 
        // side of current element zero 
        int leftCnt = 0; 

        // To store count of ones on right 
        // side of current element zero 
        int rightCnt = 0; 

        // Index of zero with maximum number 
        // of ones around it. 
        int maxIndex = -1; 

        // Index of last zero element seen 
        int lastInd = -1; 

        // Count of ones if zero at index 
        // maxInd is replaced by one. 
        int maxCnt = 0; 

        while (i < n) { 

            // Keep incrementing count until 
            // current element is 1. 
            if (arr[i]) { 
                rightCnt++; 
            } else { 

                // If current zero element 
                // is not first zero element, 
                // then count number of ones 
                // obtained by replacing zero at 
                // index lastInd. Update maxCnt 
                // and maxIndex if required. 
                if (lastInd != -1) { 
                    if (rightCnt + leftCnt + 1 > maxCnt) { 
                        maxCnt = leftCnt + rightCnt + 1; 
                        maxIndex = lastInd; 
                    } 
                } 
                lastInd = i; 
                leftCnt = rightCnt; 
                rightCnt = 0; 
            } 

            i++; 
        } 

        // Find number of ones in continuous 
        // sequence when last zero element is 
        // replaced by one. 
        if (lastInd != -1) { 
            if (leftCnt + rightCnt + 1 > maxCnt) { 
                maxCnt = leftCnt + rightCnt + 1; 
                maxIndex = lastInd; 
            } 
        } 

        return maxIndex; 
    } 

    // Driver function 
    static public void Main (){
        bool []arr = {true, true, false, false, true, 
            false, true, true, true, false, true, true, true,}; 

        int n = arr.Length; 
        Console.WriteLine("Index of 0 to be replaced is "
                + maxOnesIndex(arr, n)); 
    } 
} 
//This code contribute by ajit 

using System;

// c# program to find index of zero  
// to be replaced by one to get longest  
// continuous sequence of ones. 

public 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.  
    public static int maxOnesIndex(bool[] arr, int n)
    {

        // To store starting point of  
        // sliding window.  
        int start = 0;

        // To store ending point of  
        // sliding window.  
        int end = 0;

        // Index of zero with maximum number  
        // of ones around it.  
        int maxIndex = -1;

        // Index of last zero element seen  
        int lastInd = -1;

        // Count of ones if zero at index  
        // maxInd is replaced by one.  
        int maxCnt = 0;

        while (end < n)
        {

            // Keep increasing ending point  
            // of sliding window until one is  
            // present in input array.  
            while (end < n && arr[end])
            {
                end++;
            }

            // If this is not first zero element  
            // then number of ones obtained by  
            // replacing zero at lastInd is  
            // equal to length of window.  
            // Compare this with maximum number  
            // of ones in a previous window so far.  
            if (maxCnt < end - start && lastInd != -1)
            {
                maxCnt = end - start;
                maxIndex = lastInd;
            }

            // The new starting point of next window  
            // is from index position next to last  
            // zero which is stored in lastInd.  
            start = lastInd + 1;
            lastInd = end;
            end++;
        }

        // For the case when only one zero is  
        // present in input array and is at  
        // last position.  
        if (maxCnt < end - start && lastInd != -1)
        {
            maxCnt = end - start;
            maxIndex = lastInd;
        }

        return maxIndex;
    }

        // Driver function  
    public static void Main(string[] args)
    {
        bool[] arr = new bool[] {true, true, false, false, true, false, true, true, true, false, true, true, true};

        // bool arr[] = {1, 1, 1, 1, 0};  
        int n = arr.Length;
        Console.WriteLine("Index of 0 to be replaced is " + maxOnesIndex(arr, n));
    }
}

// This code is contributed by Shrikant13