Move Zeroes

                                            
class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int pos = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] != 0) {
                swap(nums[i], nums[pos]);
                pos++;
            }
        }
    }
};

                                            
class Solution {
    public void moveZeroes(int[] nums) {
        int nonZeroIdx = 0;
        
        for (int num : nums) {
            if (num != 0) {
                nums[nonZeroIdx++] = num;
            }
        }
        
        while (nonZeroIdx < nums.length) {
            nums[nonZeroIdx++] = 0;
        }
    }
}

                                            
class Solution(object):
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place 
        instead.
        """
        zero_count = 0
        n = len(nums)
        
        for i in range(n):
            if nums[i] == 0:
                zero_count += 1
            else:
                nums[i-zero_count] = nums[i]
        
        for i in range(n - zero_count, n):
            nums[i] = 0

                                            
void moveZeroes(int* nums, int numsSize) {
    int nonZeroIndex = 0;
    
    for(int i = 0; i < numsSize; i++) {
        if(nums[i] != 0) {
            nums[nonZeroIndex] = nums[i];
            if(i != nonZeroIndex) {
                nums[i] = 0;
            }
            nonZeroIndex++;
        }
    }
}

                                            
public class Solution {
    public void MoveZeroes(int[] nums) {
        int nonZeroIndex = 0;
        
        // Move all non-zero elements to the front of the array
        for (int i = 0; i < nums.Length; i++) {
            if (nums[i] != 0) {
                nums[nonZeroIndex] = nums[i];
                nonZeroIndex++;
            }
        }
        
        // Fill the rest of the array with zeros
        for (int i = nonZeroIndex; i < nums.Length; i++) {
            nums[i] = 0;
        }
    }
}

                                            
/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var moveZeroes = function(nums) {
    let nonZeroPointer = 0;
    
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] !== 0) {
            let temp = nums[nonZeroPointer];
            nums[nonZeroPointer] = nums[i];
            nums[i] = temp;
            nonZeroPointer++;
        }
    }
};

                                            
/**
 Do not return anything, modify nums in-place instead.
 */
function moveZeroes(nums: number[]): void {
    let nonZeroIdx = 0;
    
    for(let i = 0; i < nums.length; i++) {
        if(nums[i] !== 0) {
            [nums[nonZeroIdx], nums[i]] = [nums[i], nums[nonZeroIdx]];
            nonZeroIdx++;
        }
    }
};

                                            
class Solution {
    /**
     * @param Integer[] $nums
     * @return NULL
     */
    function moveZeroes(&$nums) {
        $nonZeroIndex = 0;
        for ($i = 0; $i < count($nums); $i++) {
            if ($nums[$i] != 0) {
                $temp = $nums[$nonZeroIndex];
                $nums[$nonZeroIndex] = $nums[$i];
                $nums[$i] = $temp;
                $nonZeroIndex++;
            }
        }
    }
}

                                            
class Solution {
    func moveZeroes(_ nums: inout [Int]) {
        var nonZeroIndex = 0
        
        for num in nums {
            if num != 0 {
                nums[nonZeroIndex] = num
                nonZeroIndex += 1
            }
        }
        
        while nonZeroIndex < nums.count {
            nums[nonZeroIndex] = 0
            nonZeroIndex += 1
        }
    }
}

                                            
class Solution {
  void moveZeroes(List<int> nums) {
    int nonZeroIndex = 0;
    
    for (int i = 0; i < nums.length; i++) {
      if (nums[i] != 0) {
        nums[nonZeroIndex] = nums[i];
        if (i != nonZeroIndex) {
          nums[i] = 0;
        }
        nonZeroIndex++;
      }
    }
  }
}

                                            
func moveZeroes(nums []int) {
    if len(nums) == 0 {
        return
    }
    
    insertPos := 0
    for _, num := range nums {
        if num != 0 {
            nums[insertPos] = num
            insertPos++
        }
    }
    
    for i := insertPos; i < len(nums); i++ {
        nums[i] = 0
    }
}

                                            
# @return {Void} Do not return anything, modify nums in-place instead.
def move_zeroes(nums)
    zero_count = nums.count(0)
    nums.delete(0)
    zero_count.times { nums << 0 }
end

                                            
object Solution {
    def moveZeroes(nums: Array[Int]): Unit = {
        var nonZeroIdx = 0
        for (i <- nums.indices) {
            if (nums(i) != 0) {
                val temp = nums(nonZeroIdx)
                nums(nonZeroIdx) = nums(i)
                nums(i) = temp
                nonZeroIdx += 1
            }
        }
    }
}

                                            
impl Solution {
    pub fn move_zeroes(nums: &mut Vec<i32>) {
        let mut count = 0;
        
        for i in 0..nums.len() {
            if nums[i] != 0 {
                nums.swap(i, count);
                count += 1;
            }
        }
    }
}

To solve this coding challenge, we need to move all zeroes in an integer array to the end while maintaining the relative order of the non-zero elements. This needs to be done in-place without creating a copy of the array.

Explanation

The task is to move all zeros in the given array to the end while maintaining the relative order of non-zero elements. To do this in-place, we need to take several steps:

Traverse the Array:

Traverse the given array and count how many zeros are there.
While counting zeros, we need to reposition non-zero elements to fill the positions previously occupied by zeros.

Shift Non-zero Elements:

Whenever we encounter a non-zero element, we move it to the position adjusted by the number of zeros encountered so far.
This keeps non-zero elements in their original order but places them at the earliest available position.

Fill Remaining with Zeros:

After repositioning non-zero elements, the positions towards the end of the array, left vacant by previous zeros, should be filled with zeros.

Here is the step-by-step pseudocode which explains the logic in great detail:

Detailed Steps in Pseudocode

Initialize Variables:

Initialize a variable
zero_count

to count the number of zeros encountered.
Determine the length of the array (
n

).

First Pass - Shift Non-zero Elements:

Iterate over the array using a loop.
For each element:

If it is zero, increment
zero_count

.
If it is non-zero, shift it to the left by the number of zeros encountered using the formula
nums[i-zero_count] = nums[i]

.

Second Pass - Fill Remaining with Zeros:

After the first pass, start another loop from
n - zero_count

to
n

.
For each position, set the element to zero.

Pseudocode

Pseudocode: Initializing Variables and First Pass

                                            
# Initialize variable to count zeros encountered
zero_count = 0

# Get the length of the array
n = length of nums

# First pass: Shift non-zero elements to the left
for i from 0 to n-1:
if nums[i] == 0:
# If the element is zero, increment zero_count
zero_count += 1
else:
# If the element is non-zero, move it to the correct position
nums[i - zero_count] = nums[i]

Pseudocode: Second Pass - Fill Remaining with Zeros

                                            
# Second pass: Fill the end of the array with zeros
for i from (n - zero_count) to n-1:
# Fill the position with zero
nums[i] = 0

Step-by-Step Explanation:

In the first step, we initialize
zero_count

to keep track of how many zeros we have encountered so far. We also determine the length of the input array (
n

).

                                            
zero_count = 0
n = length of nums

Next, we iterate over each element in the array from the beginning to the end. If we encounter a zero, we increment the
zero_count

. This helps us keep track of how many zeros we have seen so far.

                                            
for i from 0 to n-1:
if nums[i] == 0:
zero_count += 1
else:
nums[i - zero_count] = nums[i]

As we encounter non-zero elements, we move them to an earlier position in the array which is determined by subtracting
zero_count

from the current index
i

. This effectively skips over the positions that were initially occupied by zeros.
Finally, after repositioning all non-zero elements, the trailing elements in the array still remain at their original positions. We then loop from the position
n - zero_count

to the end of the array and fill these positions with zeros.

                                            
for i from (n - zero_count) to n-1:
nums[i] = 0

By following these steps, the challenge is solved efficiently in-place with minimal additional operations.