Apply Operations to an Array

class Solution {
public:
    vector<int> processVector(vector<int>& vec) {
        int length = vec.size();

        for (int i = 0; i < length - 1; i++) {
            if (vec[i] == vec[i + 1] && vec[i] != 0) {
                vec[i] *= 2;
                vec[i + 1] = 0;
            }
        }

        int moveIndex = 0;
        for (int j = 0; j < length; j++) {
            if (vec[j] != 0) {
                vec[moveIndex++] = vec[j];
            }
        }

        while (moveIndex < length) {
            vec[moveIndex++] = 0;
        }

        return vec;
    }
};

This summary describes the implementation details for a C++ function designed to process elements within a vector according to specific conditions. The function, processVector, performs operations on adjacent identical elements and rearranges the vector by moving non-zero elements to the beginning while zero-filled elements are pushed to the end.

• The function receives a reference to a vector of integers as its parameter.
• It obtains the size of the vector which is stored in a variable length.
• An initial loop through the vector checks for consecutive identical elements that are not zero. If such a pair is found, the first element of the pair is doubled, and the second is set to zero.
• Following the initial loop, another loop goes through the vector to advance the non-zero elements to the front. This operation makes use of a moveIndex variable that tracks the index position for modifications.
• Once all non-zero elements are moved, a final while loop fills the remainder of the vector with zeros until the end, ensuring all zero elements are placed after all non-zero elements.
• Finally, the modified vector is returned.

In essence, the function consolidates identical consecutive numbers by combining them into a single doubled value and shifts non-zero values to the forefront of the vector.

public class Solution {

    public int[] modifyArray(int[] array) {
        int size = array.length;

        // Apply operations on the elements
        for (int i = 0; i < size - 1; i++) {
            if (array[i] == array[i + 1] && array[i] != 0) {
                array[i] *= 2;
                array[i + 1] = 0;
            }
        }

        // Shift nonzero elements left
        int validPos = 0;
        for (int j = 0; j < size; j++) {
            if (array[j] != 0) {
                array[validPos++] = array[j];
            }
        }

        // Set remaining elements to zero
        while (validPos < size) {
            array[validPos++] = 0;
        }

        return array;
    }
}

The provided Java solution modifies an input array by applying two main operations: merging adjacent equal non-zero elements and repositioning non-zero elements to the beginning of the array. Review the operational breakdown:

• Merging Adjacent Elements: Traverse the array using a loop. If two adjacent elements have the same value and are not zero, double the value of the first element and set the second element to zero.

• Repositioning Non-zero Elements: In a subsequent loop, move all non-zero elements to the left side of the array. This is accomplished by maintaining a validPos counter that tracks the index for the next non-zero insertion.

• Zero-filling the Rest: After repositioning non-zero elements, fill the remainder of the array with zeros starting from the last position filled with a non-zero element until the end of the array.

This transformation ensures that any pair of adjacent duplicate numbers are combined into one, contributing to an efficient reorganization of the array for scenarios requiring non-zero values to be contiguous and upfront, followed by zeros. This method returns the transformed array.

class Solution:
    def transformList(self, elements):
        total_elements = len(elements)

        # Process elements for matching consecutive non-zeros
        for pos in range(total_elements - 1):
            if elements[pos] == elements[pos + 1] and elements[pos] != 0:
                elements[pos] *= 2
                elements[pos + 1] = 0

        # Rearrange the list by moving non-zeros to the front
        insert_pos = 0
        for check_pos in range(total_elements):
            if elements[check_pos] != 0:
                elements[insert_pos] = elements[check_pos]
                insert_pos += 1

        # Fill remaining slots in list with zero
        while insert_pos < total_elements:
            elements[insert_pos] = 0
            insert_pos += 1

        return elements

In the provided Python solution, the task is to modify a list based on specific rules. This involves processing and altering elements in an array such that:

1. Consecutive non-zero numbers that are identical are merged into one element that is the sum of the two (e.g., two adjacent 2s become 4), and the next element is set to zero.
2. All zero elements are moved to the end of the list while maintaining the order of non-zero elements.

The Python method transformList(self, elements) is defined within the class Solution. It consists of three major parts:

• First, iterate through the array checking for adjacent non-zero elements that are the same. Double the value of the first element and set the second to zero.
• Next, scan through the array again. This time, shift all non-zero numbers to the front of the array.
• Finally, fill the remaining positions in the array with zeros.

This method returns the modified list, with doubles combined and all zeros shifted to the end. This transformation is useful in game logic like that found in the game 2048, and for other applications that require compacting information while preserving order.