Double the first element and move zero to end
For a given array of n integers and assume that ‘0’ is an invalid number and all others a valid number. Convert the array in such a way that if both current and next element is valid and both have same value then double current value and replace the next number with 0. After the modification, rearrange the array such that all 0’s shift to the end.
Examples:
Input : arr[] = {2, 2, 0, 4, 0, 8}
Output : 4 4 8 0 0 0
Input : arr[] = {0, 2, 2, 2, 0, 6, 6, 0, 0, 8}
Output : 4 2 12 8 0 0 0 0 0 0
Source: Microsoft IDC Interview Experience | Set 150.
Approach: First modify the array as mentioned, i.e., if the next valid number is the same as the current number, double its value and replace the next number with 0.
Algorithm for Modification:
1. if n == 1
2. return
3. for i = 0 to n-2
4. if (arr[i] != 0) && (arr[i] == arr[i+1])
5. arr[i] = 2 * arr[i]
6. arr[i+1] = 0
7. i++
After modifying the array, Move all zeroes to the end of the array.
C++
#include <bits/stdc++.h>
using namespace std;
void pushZerosToEnd( int arr[], int n)
{
int count = 0;
for ( int i = 0; i < n; i++)
if (arr[i] != 0)
arr[count++] = arr[i];
while (count < n)
arr[count++] = 0;
}
void modifyAndRearrangeArr( int arr[], int n)
{
if (n == 1)
return ;
for ( int i = 0; i < n - 1; i++) {
if ((arr[i] != 0) && (arr[i] == arr[i + 1])) {
arr[i] = 2 * arr[i];
arr[i + 1] = 0;
i++;
}
}
pushZerosToEnd(arr, n);
}
void printArray( int arr[], int n)
{
for ( int i = 0; i < n; i++)
cout << arr[i] << " " ;
}
int main()
{
int arr[] = { 0, 2, 2, 2, 0, 6, 6, 0, 0, 8 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << "Original array: " ;
printArray(arr, n);
modifyAndRearrangeArr(arr, n);
cout << "\nModified array: " ;
printArray(arr, n);
return 0;
}
|
C
#include <stdio.h>
void pushZerosToEnd( int arr[], int n)
{
int count = 0;
for ( int i = 0; i < n; i++)
if (arr[i] != 0)
arr[count++] = arr[i];
while (count < n)
arr[count++] = 0;
}
void modifyAndRearrangeArr( int arr[], int n)
{
if (n == 1)
return ;
for ( int i = 0; i < n - 1; i++) {
if ((arr[i] != 0) && (arr[i] == arr[i + 1])) {
arr[i] = 2 * arr[i];
arr[i + 1] = 0;
i++;
}
}
pushZerosToEnd(arr, n);
}
void printArray( int arr[], int n)
{
for ( int i = 0; i < n; i++)
printf ( "%d " , arr[i]);
}
int main()
{
int arr[] = { 0, 2, 2, 2, 0, 6, 6, 0, 0, 8 };
int n = sizeof (arr) / sizeof (arr[0]);
printf ( "Original array: " );
printArray(arr, n);
modifyAndRearrangeArr(arr, n);
printf ( "\nModified array: " );
printArray(arr, n);
return 0;
}
|
Java
import java.io.*;
class GFG {
static void pushZerosToEnd( int arr[], int n)
{
int count = 0 ;
for ( int i = 0 ; i < n; i++)
if (arr[i] != 0 )
arr[count++] = arr[i];
while (count < n)
arr[count++] = 0 ;
}
static void modifyAndRearrangeArr( int arr[], int n)
{
if (n == 1 )
return ;
for ( int i = 0 ; i < n - 1 ; i++) {
if ((arr[i] != 0 ) && (arr[i] == arr[i + 1 ]))
{
arr[i] = 2 * arr[i];
arr[i + 1 ] = 0 ;
i++;
}
}
pushZerosToEnd(arr, n);
}
static void printArray( int arr[], int n)
{
for ( int i = 0 ; i < n; i++)
System.out.print(arr[i] + " " );
System.out.println();
}
public static void main(String[] args)
{
int arr[] = { 0 , 2 , 2 , 2 , 0 , 6 , 6 , 0 , 0 , 8 };
int n = arr.length;
System.out.print( "Original array: " );
printArray(arr, n);
modifyAndRearrangeArr(arr, n);
System.out.print( "Modified array: " );
printArray(arr, n);
}
}
|
Python3
def pushZerosToEnd(arr, n):
count = 0
for i in range ( 0 , n):
if arr[i] ! = 0 :
arr[count] = arr[i]
count + = 1
while (count < n):
arr[count] = 0
count + = 1
def modifyAndRearrangeArr(ar, n):
if n = = 1 :
return
for i in range ( 0 , n - 1 ):
if (arr[i] ! = 0 ) and (arr[i] = = arr[i + 1 ]):
arr[i] = 2 * arr[i]
arr[i + 1 ] = 0
i + = 1
pushZerosToEnd(arr, n)
def printArray(arr, n):
for i in range ( 0 , n):
print (arr[i],end = " " )
arr = [ 0 , 2 , 2 , 2 , 0 , 6 , 6 , 0 , 0 , 8 ]
n = len (arr)
print ( "Original array:" ,end = " " )
printArray(arr, n)
modifyAndRearrangeArr(arr, n)
print ( "\nModified array:" ,end = " " )
printArray(arr, n)
|
C#
using System;
class GFG {
static void pushZerosToEnd( int [] arr, int n)
{
int count = 0;
for ( int i = 0; i < n; i++)
if (arr[i] != 0)
arr[count++] = arr[i];
while (count < n)
arr[count++] = 0;
}
static void modifyAndRearrangeArr( int [] arr, int n)
{
if (n == 1)
return ;
for ( int i = 0; i < n - 1; i++) {
if ((arr[i] != 0) && (arr[i] == arr[i + 1])) {
arr[i] = 2 * arr[i];
arr[i + 1] = 0;
i++;
}
}
pushZerosToEnd(arr, n);
}
static void printArray( int [] arr, int n)
{
for ( int i = 0; i < n; i++)
Console.Write(arr[i] + " " );
Console.WriteLine();
}
public static void Main()
{
int [] arr = { 0, 2, 2, 2, 0, 6, 6, 0, 0, 8 };
int n = arr.Length;
Console.Write( "Original array: " );
printArray(arr, n);
modifyAndRearrangeArr(arr, n);
Console.Write( "Modified array: " );
printArray(arr, n);
}
}
|
Javascript
<script>
function pushZerosToEnd(arr, n)
{
var count = 0;
for ( var i = 0; i < n; i++)
if (arr[i] != 0)
arr[count++] = arr[i];
while (count < n) arr[count++] = 0;
}
function modifyAndRearrangeArr(arr, n)
{
if (n == 1) return ;
for ( var i = 0; i < n - 1; i++)
{
if (arr[i] != 0 && arr[i] == arr[i + 1]) {
arr[i] = 2 * arr[i];
arr[i + 1] = 0;
i++;
}
}
pushZerosToEnd(arr, n);
}
function printArray(arr, n)
{
for ( var i = 0; i < n; i++) document.write(arr[i] + " " );
}
var arr = [0, 2, 2, 2, 0, 6, 6, 0, 0, 8];
var n = arr.length;
document.write( "Original array: " );
printArray(arr, n);
modifyAndRearrangeArr(arr, n);
document.write( "<br>" );
document.write( "Modified array: " );
printArray(arr, n);
</script>
|
Output
Original array: 0 2 2 2 0 6 6 0 0 8
Modified array: 4 2 12 8 0 0 0 0 0 0
Time Complexity: O(n).
Auxiliary Space: O(1)
Approach with efficient zero shiftings:
Although the above solution is efficient, we can further optimise it in shifting zero algorithms by reducing the number of operations.
In the above shifting algorithms, we scan some elements twice when we set the count index to last index element to zero.
Efficient Zero Shifting Algorithms:
int lastSeenPositiveIndex = 0;
for( index = 0; index < n; index++)
{
if(array[index] != 0)
{
swap(array[index], array[lastSeenPositiveIndex]);
lastSeenPositiveIndex++;
}
}
C++
void swap( int & a, int & b) { a = b + a - (b = a); }
void shiftAllZeroToLeft( int array[], int n)
{
int lastSeenNonZero = 0;
for (index = 0; index < n; index++)
{
if (array[index] != 0)
{
swap(array[index], array[lastSeenNonZero]);
lastSeenNonZero++;
}
}
}
|
Java
import java.io.*;
class GFG {
public static void swap( int [] A, int i, int j)
{
int temp = A[i];
A[i] = A[j];
A[j] = temp;
}
static void shiftAllZeroToLeft( int array[], int n)
{
int lastSeenNonZero = 0 ;
for ( int index = 0 ; index < n; index++) {
if (array[index] != 0 ) {
swap(array, array[index],
array[lastSeenNonZero]);
lastSeenNonZero++;
}
}
}
}
|
Python3
def shiftAllZeroToLeft(arr, n):
lastSeenNonZero = 0
for index in range ( 0 , n):
if (array[index] ! = 0 ):
array[index], array[lastSeenNonZero] = array[lastSeenNonZero], array[index]
lastSeenNonZero + +
|
C#
using System;
class GFG
{
public static void swap( int [] A, int i, int j)
{
int temp = A[i];
A[i] = A[j];
A[j] = temp;
}
static void shiftAllZeroToLeft( int [] array, int n)
{
int lastSeenNonZero = 0;
for ( int index = 0; index < n; index++)
{
if (array[index] != 0)
{
swap(array, array[index],
array[lastSeenNonZero]);
lastSeenNonZero++;
}
}
}
}
|
Javascript
<script>
function swap(A,i,j)
{
let temp = A[i];
A[i] = A[j];
A[j] = temp;
}
function shiftAllZeroToLeft(array,n)
{
let lastSeenNonZero = 0;
for (let index = 0; index < n; index++) {
if (array[index] != 0) {
swap(array, array[index],
array[lastSeenNonZero]);
lastSeenNonZero++;
}
}
}
}
</script>
|
Time Complexity: O(n)
Auxiliary Space: O(1)
Last Updated :
09 Dec, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...