Given a binary array X[] of length N (N >= 3). You are allowed to select any three consecutive integers of the array and replace them with 1, 0, and 0 respectively and you can apply the given operation at any number of times including zero, the task is to return the minimum possible sum of all elements of X[] such that X[] must be lexicographically smallest after applying the given operation.
Examples:
Input: N=3, X[] = {0, 1, 1}
Output: 2
Explanation: We can’t apply operations here, e.g. If we apply operation at first three consecutive indices (Which is only possible case here), then X[] = {1, 0, 0}.It can be seen that {1, 0, 0} is not lexographically smallest than initial X[] = {0, 1, 1}. Therefore, it will not be appropriate to apply any operation and remain X[] as it is. So the minimum sum will be 2.Input: N = 6, X[] = {0, 0, 1, 0, 1, 1}
Output: 1
Explanation: Operation 1(at three consecutive indices (3, 4, 5)): updated X[] = {0, 0, 1, 1, 0, 0}, Operation 2(at three consecutive indices (2, 3, 4)): updated X[] = {0, 0, 1, 0, 0, 0}
Now, at last X[] = {0, 0, 1, 0, 0, 0} smallest possible flexographically smallest X[], which gives the sum of X[] as 1. Therefore, output is equal to 1.
Approach: To solve the problem follow the below steps:
- Find the index of the first occurrence of element 1 in X[] and store it into a variable let’s say Ind.
- If there is no 1 present in X[], then output 0.
- Else convert all the ones before and after Ind into zero.
- Put 1 at index Ind.
- After that calculate the sum by iterating over X[] and output the minimum possible sum.
Implementation of the above approach:
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function to calculate the sum int sum( int X[], int N)
{ int sum = 0;
for ( int i = 0; i < N; i++) {
if (X[i] == 1)
sum++;
}
return sum;
} // Function to output the minimum possible sum // such that X[] is lexicographically smallest void min_sum( int X[], int N)
{ // Variable to store the first index
// of the first integer = 1
int index = -1;
// Loop to find the first index
// of integer 1
for ( int i = 0; i < N; i++) {
if (X[i] == 1) {
index = i;
break ;
}
}
// If operations can't be applied, the
// sum is equal to the number of
// integers equal to 1
if (index == -1 || index == (N - 1)
|| index == (N - 2)) {
cout << sum(X, N) << endl;
}
// If operations can be applied, then
// this block will execute
else {
// Making all zeroes before the index
for ( int i = 0; i < index; i++) {
X[i] = 0;
}
// Placing '1' at the index
X[index] = 1;
// Making all zeroes after the index
for ( int i = index + 1; i < N; i++) {
X[i] = 0;
}
// Function call to calculate the
// sum of the newly formed array
cout << sum(X, N) << endl;
}
} // Driver Function int main()
{ // Inputs
int N = 6;
int X[] = { 0, 0, 1, 0, 1, 1 };
// Function call
min_sum(X, N);
return 0;
} |
// Java code to implement the approach import java.io.*;
import java.lang.*;
import java.util.*;
class Main {
// Driver Function
public static void main(String[] args)
throws java.lang.Exception
{
// Inputs
int N = 6 ;
int [] X = { 0 , 0 , 1 , 0 , 1 , 1 };
// Function call
min_sum(X, N);
}
// Function to output the minimum possible sum
// Such that X[] is lexographically smallest
public static void min_sum( int [] X, int N)
{
// Variable to store first index of
// first integer = 1
int index = - 1 ;
// Loop which finds first index
// of integer 1
for ( int i = 0 ; i < N; i++) {
if (X[i] == 1 ) {
index = i;
break ;
}
}
// If operations can't be applied
// Then sum is equal to number of
// integers equal to 1
if (index == - 1 || index == (N - 1 )
|| index == (N - 2 )) {
System.out.println(sum(X, N));
}
// If operations can be applied then
// else loop will execute
else {
// Making all zeroes before index
for ( int i = 0 ; i < index; i++) {
X[i] = 0 ;
}
// Placing '1' at index
X[index] = 1 ;
// Making all zeroes after index
for ( int i = index + 1 ; i < N; i++) {
X[i] = 0 ;
}
// Function call to calculate sum
// of newly formed string
System.out.println(sum(X, N));
}
}
// Function call to calculate sum
public static int sum( int [] X, int N)
{
int sum = 0 ;
for ( int i = 0 ; i < N; i++) {
if (X[i] == 1 )
sum++;
}
return sum;
}
} |
# Python code to implement the approach # Function to calculate the sum def sum (X, N):
sum_val = 0
for i in range (N):
if X[i] = = 1 :
sum_val + = 1
return sum_val
# Function to output the minimum possible sum # such that X[] is lexicographically smallest def min_sum(X, N):
# Variable to store the first index
# of the first integer = 1
index = - 1
# Loop to find the first index
# of integer 1
for i in range (N):
if X[i] = = 1 :
index = i
break
# If operations can't be applied, the
# sum is equal to the number of
# integers equal to 1
if index = = - 1 or index = = (N - 1 ) or index = = (N - 2 ):
print ( sum (X, N))
# If operations can be applied, then
# this block will execute
else :
# Making all zeroes before the index
for i in range (index):
X[i] = 0
# Placing '1' at the index
X[index] = 1
# Making all zeroes after the index
for i in range (index + 1 , N):
X[i] = 0
# Function call to calculate the
# sum of the newly formed array
print ( sum (X, N))
# Driver Code if __name__ = = "__main__" :
# Inputs
N = 6
X = [ 0 , 0 , 1 , 0 , 1 , 1 ]
# Function call
min_sum(X, N)
# This code is contributed by Susobhan Akhuli |
// C# program for the above approach using System;
public class GFG {
// Function to calculate the sum
static int Sum( int [] X, int N)
{
int sum = 0;
for ( int i = 0; i < N; i++) {
if (X[i] == 1)
sum++;
}
return sum;
}
// Function to output the minimum possible sum
// such that X[] is lexicographically smallest
static void MinSum( int [] X, int N)
{
// Variable to store the first index
// of the first integer = 1
int index = -1;
// Loop to find the first index
// of integer 1
for ( int i = 0; i < N; i++) {
if (X[i] == 1) {
index = i;
break ;
}
}
// If operations can't be applied, the
// sum is equal to the number of
// integers equal to 1
if (index == -1 || index == (N - 1)
|| index == (N - 2)) {
Console.WriteLine(Sum(X, N));
}
// If operations can be applied, then
// this block will execute
else {
// Making all zeroes before the index
for ( int i = 0; i < index; i++) {
X[i] = 0;
}
// Placing '1' at the index
X[index] = 1;
// Making all zeroes after the index
for ( int i = index + 1; i < N; i++) {
X[i] = 0;
}
// Function call to calculate the
// sum of the newly formed array
Console.WriteLine(Sum(X, N));
}
}
// Driver Function
static void Main()
{
// Inputs
int N = 6;
int [] X = { 0, 0, 1, 0, 1, 1 };
// Function call
MinSum(X, N);
}
} // This code is contributed by Susobhan Akhuli |
// Javascript code to implement the approach // Function to calculate the sum function sum(X, N) {
let sum = 0;
for (let i = 0; i < N; i++) {
if (X[i] == 1)
sum++;
}
return sum;
} // Function to output the minimum possible sum // such that X[] is lexicographically smallest function min_sum(X, N) {
// Variable to store the first index
// of the first integer = 1
let index = -1;
// Loop to find the first index
// of integer 1
for (let i = 0; i < N; i++) {
if (X[i] == 1) {
index = i;
break ;
}
}
// If operations can't be applied, the
// sum is equal to the number of
// integers equal to 1
if (index == -1 || index == (N - 1) || index == (N - 2)) {
console.log(sum(X, N));
}
// If operations can be applied, then
// this block will execute
else {
// Making all zeroes before the index
for (let i = 0; i < index; i++) {
X[i] = 0;
}
// Placing '1' at the index
X[index] = 1;
// Making all zeroes after the index
for (let i = index + 1; i < N; i++) {
X[i] = 0;
}
// Function call to calculate the
// sum of the newly formed array
console.log(sum(X, N));
}
} // Driver Function // Inputs let N = 6; let X = [0, 0, 1, 0, 1, 1]; // Function call min_sum(X, N); |
1
Time Complexity: O(N)
Auxiliary Space: O(1)