Home » Data Structure » Array Data Structure

Double the first element and move zero to end

C++ implementation to double the first element and move zero to end.
Submitted by Vikneshwar GK, on March 11, 2022

Consider an integer array, of size n. 0 is considered as an invalid integer whereas other numbers are valid integers. The task at hand is to iterate the array and check whether the current element is valid and its value is the same as the next element. If true, double the current element and replace the next element with 0. Finally, rearrange the array in such a way that all the zeros are placed at the end of the array.

Example:

Input:
array[]= {2, 4, 0, 3, 3, 5, 8, 8, 0, 6}

Output:
array[] = {2, 4, 6, 5, 16, 6, 0, 0, 0, 0} 

Input:
array[]= {1, 2, 2, 4, 4}

Output:
array[] = {1, 4, 8, 0, 0}

Solution

This is a simple yet efficient method that involves iterating through the array and finding the elements that have the same value as its next element and that is not zero. If true, then double the current element and replace its next element with zero. Finally, iterate the array again and place the zero at the end of the array.

Algorithm for moving zeros to the end of the array:

• Iterate the array
• Use an index called count to assign non-zero elements in the array
• If the element is not zero, then assign it to the array and increment the count
• Again, iterate the through from count to the length of the array and assign zero

C++ Implementation:

#include <bits/stdc++.h>

using namespace std;

// Function to push the zeros
// to the end of the array
void moveZerosToEnd(int array[], int length)
{
    // index to store non-zero elements
    int count = 0;

    // iterate the array
    for (int i = 0; i < length; i++)

        // if the element is not zero
        if (array[i] != 0)
            array[count++] = array[i];

    // assign zero to the remaining positions
    while (count < length)
        array[count++] = 0;
}

// function to double the element
// based on the conditions
void rearrangeArray(int array[], int length)
{
    // if the array has only one element
    if (length == 1)
        return;

    // traverse the array
    for (int i = 0; i < length - 1; i++) {

        // element not equal to zero
        // element is same as its next element
        if ((array[i] != 0) && (array[i] == array[i + 1])) {

            // double current index value
            array[i] = 2 * array[i];

            // assign zero to next element
            array[i + 1] = 0;

            // increment the array to one position
            // because the next element is zero
            i++;
        }
    }

    // call function to push the zeros
    moveZerosToEnd(array, length);
}

// Function to print the array
void printArray(int array[], int length)
{
    for (int i = 0; i < length; i++) {
        cout << array[i] << " ";
    }
}

// Main function
int main()
{
    int array[100], N, k;
    
    cout << "Enter Number of elements: ";
    cin >> N;

    for (int i = 0; i < N; i++) {
        cout << "Enter element " << i + 1 << ": ";
        cin >> array[i];
    }
    
    rearrangeArray(array, N);
    printArray(array, N);
    
    return 0;
}

Output:

Enter Number of elements: 10
Enter element 1: 2
Enter element 2: 4
Enter element 3: 0
Enter element 4: 3
Enter element 5: 3
Enter element 6: 5
Enter element 7: 8
Enter element 8: 8
Enter element 9: 0
Enter element 10: 6
2 4 6 5 16 6 0 0 0 0

Time Complexity: O(n), where n is the length of the array.