#include <iostream>
#include <vector>

using namespace std;

/**
 * Sorts the array in-place such that all even integers appear before odd integers.
 * Uses two-pointer technique for O(n) time complexity and O(1) space complexity.
 * 
 * @param nums Reference to the vector of integers to be rearranged.
 * @return The modified vector after rearrangement.
 */
vector<int> sortArrayByParity(vector<int>& nums) {
    int left = 0;
    int right = nums.size() - 1;
    
    while (left < right) {
        // Move left pointer forward while current element is even
        while (left < right && nums[left] % 2 == 0) {
            left++;
        }
        // Move right pointer backward while current element is odd
        while (left < right && nums[right] % 2 != 0) {
            right--;
        }
        // Swap if left points to odd and right points to even
        if (left < right) {
            swap(nums[left], nums[right]);
            left++;
            right--;
        }
    }
    
    return nums;
}

int main() {
    // Example usage
    vector<int> nums = {3, 1, 2, 4, 5};
    vector<int> result = sortArrayByParity(nums);
    
    for (int num : result) {
        cout << num << " ";
    }
    cout << endl;
    
    return 0;
}

import java.util.Arrays;

public class Solution {
    /**
     * Sorts the array in-place such that all even integers appear before odd integers.
     * Uses two-pointer technique for O(n) time complexity and O(1) space complexity.
     * 
     * @param nums The array of integers to be rearranged.
     * @return The modified array after rearrangement.
     */
    public int[] sortArrayByParity(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        
        while (left < right) {
            // Move left pointer forward while current element is even
            while (left < right && nums[left] % 2 == 0) {
                left++;
            }
            // Move right pointer backward while current element is odd
            while (left < right && nums[right] % 2 != 0) {
                right--;
            }
            // Swap if left points to odd and right points to even
            if (left < right) {
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left++;
                right--;
            }
        }
        
        return nums;
    }
    
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] nums = {3, 1, 2, 4, 5};
        int[] result = solution.sortArrayByParity(nums);
        System.out.println(Arrays.toString(result));
    }
}

from typing import List

def sort_array_by_parity(nums: List[int]) -> List[int]:
    """
    Sorts the array in-place such that all even integers appear before odd integers.
    Uses two-pointer technique for O(n) time complexity and O(1) space complexity.
    
    Args:
        nums: A list of integers to be rearranged.
        
    Returns:
        The modified list after rearrangement.
    """
    left = 0
    right = len(nums) - 1
    
    while left < right:
        # Move left pointer forward while current element is even
        while left < right and nums[left] % 2 == 0:
            left += 1
        # Move right pointer backward while current element is odd
        while left < right and nums[right] % 2 != 0:
            right -= 1
        # Swap if left points to odd and right points to even
        if left < right:
            nums[left], nums[right] = nums[right], nums[left]
            left += 1
            right -= 1
    
    return nums

# Example usage
if __name__ == "__main__":
    nums = [3, 1, 2, 4, 5]
    result = sort_array_by_parity(nums)
    print(result)

/**
 * Sorts the array in-place such that all even integers appear before odd integers.
 * Uses two-pointer technique for O(n) time complexity and O(1) space complexity.
 * 
 * @param {number[]} nums - The array of integers to be rearranged.
 * @return {number[]} - The modified array after rearrangement.
 */
function sortArrayByParity(nums) {
    let left = 0;
    let right = nums.length - 1;
    
    while (left < right) {
        // Move left pointer forward while current element is even
        while (left < right && nums[left] % 2 === 0) {
            left++;
        }
        // Move right pointer backward while current element is odd
        while (left < right && nums[right] % 2 !== 0) {
            right--;
        }
        // Swap if left points to odd and right points to even
        if (left < right) {
            [nums[left], nums[right]] = [nums[right], nums[left]];
            left++;
            right--;
        }
    }
    
    return nums;
}

// Example usage
const nums = [3, 1, 2, 4, 5];
const result = sortArrayByParity(nums);
console.log(result);