# 905. Sort Array By Parity

## 題目敘述

Given an integer array `nums`, move all the even integers at the beginning of the array followed by all the odd integers.

Return any array that satisfies this condition.

Example 1:

``````Input: nums = [3,1,2,4]
Output: [2,4,3,1]
Explanation: The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.
``````

Example 2:

``````Input: nums = [0]
Output: [0]
``````

Constraints:

• `1 <= nums.length <= 5000`
• `0 <= nums[i] <= 5000`

## 解法解析

### 解法範例

#### Go

##### Sort
``````func sortArrayByParity(nums []int) []int {
sort.Slice(nums, func(i, j int) bool {
return nums[i]%2 < nums[j]%2
})
return nums
}
``````
##### Two Pointers
``````func sortArrayByParity(nums []int) []int {
even := []int{}
odd := []int{}

for _, v := range nums {
if v%2 == 0 {
even = append(even, v)
} else {
odd = append(odd, v)
}
}

return append(even, odd...)
}
``````
##### In Place
``````func sortArrayByParity(nums []int) []int {
for i, j := 0, len(nums)-1; i < j; {
if nums[i]%2 > nums[j]%2 {
nums[i], nums[j] = nums[j], nums[i]
}
if nums[i]%2 == 0 {
i++
}
if nums[j]%2 == 1 {
j--
}
}
return nums
}
``````

#### JavaScript

##### Sort
``````/**
* @param {number[]} nums
* @return {number[]}
*/
var sortArrayByParity = function (nums) {
nums.sort((a, b) => (a % 2) - (b % 2));
return nums;
};
``````
##### Two Pointers
``````/**
* @param {number[]} nums
* @return {number[]}
*/
var sortArrayByParity = function (nums) {
const result = new Array();
nums.forEach((e) => {
if (e % 2 == 1) {
result.push(e);
} else {
result.unshift(e);
}
});

return result;
};
``````
##### In Place
``````/**
* @param {number[]} nums
* @return {number[]}
*/
var sortArrayByParity = function (nums) {
let i = 0,
j = nums.length - 1;
while (i < j) {
if (nums[i] % 2 > nums[j] % 2) {
[nums[i], nums[j]] = [nums[j], nums[i]];
}
if (nums[i] % 2 == 0) {
i++;
}
if (nums[j] % 2 == 1) {
j--;
}
}
return nums;
};
``````

#### Kotlin

##### Sort
``````class Solution {
fun sortArrayByParity(nums: IntArray): IntArray {
return nums.sortedBy { it % 2 }.toIntArray()
}
}
``````
##### Two Pointers
``````class Solution {
fun sortArrayByParity(nums: IntArray): IntArray {
return nums.filter { it % 2 == 0 }.toIntArray().plus(nums.filter { it % 2 == 1 })
}
}
``````
##### In Place
``````class Solution {
fun sortArrayByParity(nums: IntArray): IntArray {
var i = 0
var j = nums.size - 1
while (i < j) {
if (nums[i] % 2 > nums[j] % 2) {
nums[i] = nums[j].also { nums[j] = nums[i] }
}
if (nums[i] % 2 == 0) {
i++
}
if (nums[j] % 2 == 1) {
j--
}
}
return nums
}
}
``````

#### PHP

##### Sort
``````class Solution
{

/**
* @param Integer[] \$nums
* @return Integer[]
*/
function sortArrayByParity(\$nums)
{
usort(\$nums, function (\$a, \$b) {
return (\$a % 2) - (\$b % 2);
});
return \$nums;
}
}
``````
##### Two Pointers
``````class Solution
{

/**
* @param Integer[] \$nums
* @return Integer[]
*/
function sortArrayByParity(\$nums)
{
\$even = [];
foreach (\$nums as \$num) {
if (\$num % 2 === 0) {
\$even[] = \$num;
}
}
return array_merge(\$even, array_diff(\$nums, \$even));
}
}
``````
##### In Place
``````class Solution
{

/**
* @param Integer[] \$nums
* @return Integer[]
*/
function sortArrayByParity(\$nums)
{
\$i = 0;
\$j = count(\$nums) - 1;
while (\$i < \$j) {
if (\$nums[\$i] % 2 > \$nums[\$j] % 2) {
\$tmp = \$nums[\$i];
\$nums[\$i] = \$nums[\$j];
\$nums[\$j] = \$tmp;
}

if (\$nums[\$i] % 2 === 0) {
\$i++;
}
if (\$nums[\$j] % 2 === 1) {
\$j--;
}
}

return \$nums;
}
}
``````

#### Python

##### Sort
``````class Solution:
def sortArrayByParity(self, nums: List[int]) -> List[int]:
nums.sort(key=lambda x: x % 2)
return nums
``````
##### Two Pointers
``````class Solution:
def sortArrayByParity(self, nums: List[int]) -> List[int]:
return [x for x in nums if x % 2 == 0] + [x for x in nums if x % 2 == 1]
``````
##### In Place
``````class Solution:
def sortArrayByParity(self, nums: List[int]) -> List[int]:
i, j = 0, len(nums) - 1
while i < j:
if nums[i] % 2 > nums[j] % 2:
nums[i], nums[j] = nums[j], nums[i]

if nums[i] % 2 == 0:
i += 1
if nums[j] % 2 == 1:
j -= 1

return nums
``````

#### Rust

``````
``````

#### Swift

##### Sort
``````class Solution {
func sortArrayByParity(_ nums: [Int]) -> [Int] {
return nums.sorted {
\$0 % 2 < \$1 % 2
}
}
}
``````
##### Two Pointers
``````class Solution {
func sortArrayByParity(_ nums: [Int]) -> [Int] {
return nums.filter { \$0 % 2 == 0 } + nums.filter { \$0 % 2 == 1 }
}
}
``````
##### In Place
``````class Solution {
func sortArrayByParity(_ nums: [Int]) -> [Int] {
var i: Int = 0
var j: Int = nums.count - 1
var nums: [Int] = nums
while i < j {
if nums[i] % 2 == 0 {
i += 1
} else {
nums.swapAt(i, j)
j -= 1
}
}
return nums
}
}
``````