Given an array X[]. By using the given operation, you need to return the number of elements having the same initial value except 1 and 2 after applying the given operations after infinite time.
- If at any indices 1 or 2 is present, Then after each second the elements, which are adjacent to them are increased by 1 or 2 linearly in both directions.
- The value of an element will remain unchanged If it is an increment from both sides at the same time by 1 and 2.
- If 1 and 2 are adjacent, They can’t increment, Only the elements except 1 and 2 can be incremented.
- The increment process in that direction is stopped If both 1 and 2 try to increment the same element or no element is there for incrementing. For Example: In the below image in operation 2, 6 is being incremented by both 1 and 2. 6 will remain the same, and the linearly incrementing process by 1 on the right side and 2 on the left side stops.
For more clarification, the operations are defined with the help of a graphical representation.
Examples:
Input: N = 9, X[] = {1, 3, 2, 4, 5, 3, 7, 8, 1}
Output: 2
Explanation: The operations take place as:
- After 1 Second: X[ 2 ] = 3, which is adjacent to both 1 and 2. So, X[ 2 ] remains the same. X[ 4 ] = 4 is adjacent to 2, Hence incremented by 2. A[ 8 ] = 8, is adjacent to 1, hence incremented by 1. So updated X[] is = { 1, 3, 2, 6, 5, 3, 7, 9, 1}
- After 2 Second: Updated X[] after 1 second is = { 1, 3, 2, 6, 5, 3, 7, 9, 1}. Now X[ 5 ] = 5 and X[ 7 ] = 7 will be incremented by 2 and 1 at X[ 3 ] and X[9]. So the updated X[] becomes: { 1, 3, 2, 6, 7, 3, 8, 9, 1}
- After 3 Second: Updated X[] after 2 seconds is = { 1, 3, 2, 6, 7, 3, 8, 9, 1} Now X[ 6 ] = 3 will be incremented by 2 and 1 at the same time. So it will remain unchanged, then updated X[] becomes: { 1, 3, 2, 6, 7, 3, 8, 9, 1}.
- There are a total of 2 elements X[2] and X[ 6 ], Which remain the same as the initial value except 1 and 2. Therefore, the output is 2.
Input: N = 9, X[] = { 1, 2, 1, 4, 3, 4, 2, 2, 1}
Output: 1
Explanation: It can be verified that after infinite time, there will be only 1 unchanged element, which will be X[ 5 ] = 3. Therefore, the output is 1.
Approach: Implement the idea below to solve the problem
The problem is Greedy logic based and can be solved by using some mathematics. For more clarification see the Concept of approach section.
Concept of approach:
It is clear from the statement that, We have to output the number of elements. Which will remain the same as their initial value after performing the given operations an infinite number of times. Those elements will remain the same if they are being forced by incrementing their values by 1 and 2 from both sides at the same time.
So, the first observation comes that, They will lie in between somewhere elements 1 and 2.
Now it can be two cases:
- The number of elements between 1 and 2 is even: In this case, there will no element, which will remain the same after performing the given operation an infinite number of times.
- For example: X[] = {1, 3, 4, 5, 6, 2}
- After 1 second: 3 is incremented by 1 and 6 in incremented by 2. Then X[] = {1, 4, 4, 5, 8, 2}
- After 2 seconds: 4 is incremented by 1 and 5 in incremented by 2. Then X[] = {1, 4, 5, 7, 8, 2}
- Now, no element is there such that it has same value after performing the operation except 1 and 2. So from here observation comes that no element will remain same, If there are even number of elements are present between 1 and 2.
- The number of elements between 1 and 2 are odd: In this case there will certainly one element, which will remain same after performing the given operation for infinite number of times.
- For example: X[] = {1 3, 4, 3, 5, 6, 2}
- After 1 second: 3 is incremented by 1 and 6 in incremented by 2. Then X[] = {1 4, 4, 3, 5, 8, 2}
- After 2 seconds: 4 is incremented by 1 and 5 in incremented by 2. Then X[] = {1 4, 5, 3, 7, 8, 2}
- Now, 3 which is present in middle between 1 and 2 is being forced by increment its value by 1 and 2 from both sides. So, 3 remain same, because of second condition of the problem statement.
- Thus the observation comes that, if there are odd number of elements present in between 1 and 2, Then there will certainly one element, Which will remain same as its initial value.
Steps were taken to solve the problem:
- Create two ArrayList<Integer> let’s say Indices and Values.
- Create ans variable for holding the answer.
- Run a for loop from i = 0 to i < N and follow the below-mentioned steps under the scope of the loop:
- if ( X[ i ] == 1 || X[ i ] == 2 )
- Indices.add( i )
- Values.add( X[ i ] )
- if ( X[ i ] == 1 || X[ i ] == 2 )
- If the size of any ArrayList is zero, then ans will be equal to N.
- else:
- Run a loop for i =1 to i < values.size() and follow the below-mentioned steps under the scope of the loop:
- if (values.get( i ) != values.get(i – 1)
- Create a variable, X.
- X = indices.get( i ) – indices.get(i – 1)
- X = X – 1
- If (X is odd), Then ans++.
- if (values.get( i ) != values.get(i – 1)
- Run a loop for i =1 to i < values.size() and follow the below-mentioned steps under the scope of the loop:
- Output the value of ans.
Below is the code to implement the approach:
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Method for printing unchanged elements void UnchangedElements( int N, int X[])
{ // vector for storing indices
// of 1 and 2 So the we can
// calculate number of elements
// between them
vector< int > indices;
// ArrayList for storing 1 and 2,
// So that we can know different 1
// and 2 are adjacents like {1, 1},
// {2, 2} are not different
// adjacents but {1, 2}, {2, 1}
// are different adjacents
vector< int > values;
// Loop for traversing over X[] and
// initialize the both ArrayList
for ( int i = 0; i < N; i++) {
// Condition when 1 and 2
// found at any index
if (X[i] == 1 || X[i] == 2) {
// Adding indices and
// values to ArrayLists
values.push_back(X[i]);
indices.push_back(i);
}
}
// ans variable to hold number of
// unchanged elements
long long ans = 0;
// Boolean flag is initialized
// as false
bool flag = false ;
// Condition, When no 1 and 2 are
// present in X[] So that values
// vector will by empty, As it
// is only initialized to store 1
// and 2, If there are no 1 and 2
// are present in X[] values
// vector will have zero size
if (values.size() == 0) {
// This will execute if
// X[] doesn't contains 1 or 2
cout << N << endl;
flag = true ;
}
// Loop for traversing
// over values vector
for ( int i = 1; i < values.size(); i++) {
// If different adjacents are
// found like {2, 1} or {1, 2}
// in values vector
if (values[i] != values[i - 1]) {
// Variable to hold the
// length or formally
// number of elements
// between {1, 2} or {2, 1}
long long x = indices[i] - indices[i - 1];
x -= 1;
// if number of elements
// are odd, then incrementing
// ans variable by 1
if (x & 1) {
ans++;
}
}
}
// This Print line will execute
// If at least once 1 or 2
// is present in X[]
if (flag != true )
cout << ans << endl;
} int main()
{ // Inputs
int N = 9;
int X[] = { 1, 3, 2, 4, 5, 3, 7, 8, 1 };
// Function call
UnchangedElements(N, X);
} |
// Java code to implement the approach import java.util.*;
public class GFG {
// Driver Function
public static void main(String[] args)
{
// Inputs
int N = 9 ;
int X[] = { 1 , 3 , 2 , 4 , 5 , 3 , 7 , 8 , 1 };
// Function call
UnchangedElements(N, X);
}
// Method for printing unchanged elements
static void UnchangedElements( int N, int [] X)
{
// ArrayList for storing indices
// of 1 and 2 So the we can
// calculate number of elements
// between them
ArrayList<Integer> indices = new ArrayList<>();
// ArrayList for storing 1 and 2,
// So that we can know different 1
// and 2 are adjacents like {1, 1},
// {2, 2} are not different
// adjacents but {1, 2}, {2, 1}
// are different adjacents
ArrayList<Integer> values = new ArrayList<>();
// Loop for traversing over X[] and
// initialize the both ArrayList
for ( int i = 0 ; i < N; i++) {
// Condition when 1 and 2
// found at any index
if (X[i] == 1 || X[i] == 2 ) {
// Adding indices and
// values to ArrayLists
values.add(X[i]);
indices.add(i);
}
}
// ans variable to hold number of
// unchanged elements
long ans = 0 ;
// Boolean flag is initialized
// as false
boolean flag = false ;
// Condition, When no 1 and 2 are
// present in X[] So that values
// ArrayList will by empty, As it
// is only initialized to store 1
// and 2, If there are no 1 and 2
// are present in X[] values
// ArrayList will have zero size
if (values.size() == 0 ) {
// This will execute if
// X[] doesn't contains 1 or 2
System.out.println(N);
flag = true ;
}
// Loop for traversing
// over ArrayLists
for ( int i = 1 ; i < values.size(); i++) {
// If different adjacents are
// found like {2, 1} or {1, 2}
// in values ArrayList
if (values.get(i) != values.get(i - 1 )) {
// Variable to hold the
// length or formally
// number of elements
// between {1, 2} or {2, 1}
long x
= indices.get(i) - indices.get(i - 1 );
x -= 1 ;
// if number of elements
// are odd, then incrementing
// ans variable by 1
if ((x & 1 ) == 1 ) {
ans++;
}
}
}
// This Print line will execute
// If at least once 1 or 2
// is present in X[]
if (flag != true )
System.out.println(ans);
}
} |
# Python3 code to implement the approach # Method for printing unchanged elements def unchanged_elements(N, X):
# List for storing indices of 1 and 2
# So that we can calculate number of elements between them
indices = []
# List for storing 1 and 2,
# So that we can know different 1
# and 2 are adjacents like [1, 1],
# [2, 2] are not different
# adjacents but [1, 2], [2, 1]
# are different adjacents
values = []
# Loop for traversing over X[] and
# initialize both lists
for i in range (N):
# Condition when 1 and 2
# found at any index
if X[i] = = 1 or X[i] = = 2 :
# Adding indices and
# values to lists
values.append(X[i])
indices.append(i)
# Variable to hold number of
# unchanged elements
ans = 0
# Boolean flag is initialized
# as False
flag = False
# Condition, When no 1 and 2 are
# present in X[] So that values
# list will by empty, As it
# is only initialized to store 1
# and 2, If there are no 1 and 2
# are present in X[] values
# list will have zero length
if len (values) = = 0 :
# This will execute if
# X[] doesn't contain 1 or 2
print (N)
flag = True
# Loop for traversing over values list
for i in range ( 1 , len (values)):
# If different adjacents are
# found like [2, 1] or [1, 2]
# in values list
if values[i] ! = values[i - 1 ]:
# Variable to hold the
# length or formally
# number of elements
# between [1, 2] or [2, 1]
x = indices[i] - indices[i - 1 ] - 1
# If number of elements
# are odd, then incrementing
# ans variable by 1
if x % 2 = = 1 :
ans + = 1
# This print statement will execute
# If at least once 1 or 2
# is present in X[]
if flag ! = True :
print (ans)
# Driver Code if __name__ = = "__main__" :
# Inputs
N = 9
X = [ 1 , 3 , 2 , 4 , 5 , 3 , 7 , 8 , 1 ]
# Function call
unchanged_elements(N, X)
|
// C# code to implement the approach using System;
using System.Collections.Generic;
public class GFG {
// Method for printing unchanged elements
static void UnchangedElements( int N, int [] X)
{
// List for storing indices of 1 and 2 So the we can
// calculate number of elements between them
List< int > indices = new List< int >();
// List for storing 1 and 2, So that we can know
// different 1 and 2 are adjacents like {1, 1}, {2,
// 2} are not different adjacents but {1, 2}, {2, 1}
// are different adjacents
List< int > values = new List< int >();
// Loop for traversing over X[] and initialize the
// both Lists
for ( int i = 0; i < N; i++) {
// Condition when 1 and 2 found at any index
if (X[i] == 1 || X[i] == 2) {
// Adding indices and values to Lists
values.Add(X[i]);
indices.Add(i);
}
}
// ans variable to hold number of unchanged elements
long ans = 0;
// Boolean flag is initialized as false
bool flag = false ;
// Condition, When no 1 and 2 are present in X[] So
// that values List will by empty, As it is only
// initialized to store 1 and 2, If there are no 1
// and 2 are present in X[] values List will have
// zero size
if (values.Count == 0) {
// This will execute if X[] doesn't contains 1
// or 2
Console.WriteLine(N);
flag = true ;
}
// Loop for traversing over Lists
for ( int i = 1; i < values.Count; i++) {
// If different adjacents are found like {2, 1}
// or {1, 2} in values List
if (values[i] != values[i - 1]) {
// Variable to hold the length or formally
// number of elements between {1, 2} or {2,
// 1}
long x = indices[i] - indices[i - 1];
x -= 1;
// if number of elements are odd, then
// incrementing ans variable by 1
if ((x & 1) == 1) {
ans++;
}
}
}
// This Print line will execute If at least once 1
// or 2 is present in X[]
if (flag != true )
Console.WriteLine(ans);
}
static public void Main()
{
// Code
// Inputs
int N = 9;
int [] X = { 1, 3, 2, 4, 5, 3, 7, 8, 1 };
// Function call
UnchangedElements(N, X);
}
} // This code is contributed by sankar. |
// JavaScript code to implement the approach // Method for printing unchanged elements function UnchangedElements(N, X) { // Arrays for storing indices
// of 1 and 2 So that we can // calculate number of elements // between them let indices = []; // Array for storing 1 and 2, // So that we can know different 1 // and 2 are adjacents like [1, 1], // [2, 2] are not different // adjacents but [1, 2], [2, 1] // are different adjacents let values = []; // Loop for traversing over X[] and // initialize both the arrays for (let i = 0; i < N; i++) {
// Condition when 1 and 2
// found at any index
if (X[i] == 1 || X[i] == 2) {
// Adding indices and
// values to the arrays
values.push(X[i]);
indices.push(i);
}
} // Variable to hold number of // unchanged elements let ans = 0; // Boolean flag is initialized // as false let flag = false ;
// Condition, When no 1 and 2 are // present in X[] So that values // array will be empty, As it // is only initialized to store 1 // and 2, If there are no 1 and 2 // are present in X[] values // array will have zero size if (values.length == 0) {
// This will execute if
// X[] doesn't contains 1 or 2
console.log(N);
flag = true ;
} // Loop for traversing // over values array for (let i = 1; i < values.length; i++) {
// If different adjacents are
// found like [2, 1] or [1, 2]
// in values array
if (values[i] != values[i - 1]) {
// Variable to hold the
// length or formally
// number of elements
// between [1, 2] or [2, 1]
let x = indices[i] - indices[i - 1];
x -= 1;
// if number of elements
// are odd, then incrementing
// ans variable by 1
if (x & 1) {
ans++;
}
}
} // This print statement will execute // If at least once 1 or 2 // is present in X[] if (flag != true )
console.log(ans);
} // Inputs let N = 9; let X = [1, 3, 2, 4, 5, 3, 7, 8, 1]; // Function call UnchangedElements(N, X); |
2
Time Complexity: O(N)
Auxiliary Space: O(N)