Question

977. Squares of a Sorted Array

中文文档

Description

Given an integer array nums sorted in non-decreasing order, return _an array of the squares of each number sorted in non-decreasing order_.

 

Example 1:

Input: nums = [-4,-1,0,3,10]
Output: [0,1,9,16,100]
Explanation: After squaring, the array becomes [16,1,0,9,100].
After sorting, it becomes [0,1,9,16,100].

Example 2:

Input: nums = [-7,-3,2,3,11]
Output: [4,9,9,49,121]

 

Constraints:

• 1 <= nums.length <= 104
• -104 <= nums[i] <= 104
• nums is sorted in non-decreasing order.

 

Follow up: Squaring each element and sorting the new array is very trivial, could you find an O(n) solution using a different approach?

Solutions

Solution 1

class Solution:
  def sortedSquares(self, nums: List[int]) -> List[int]:
    n = len(nums)
    res = [0] * n
    i, j, k = 0, n - 1, n - 1
    while i <= j:
      if nums[i] * nums[i] > nums[j] * nums[j]:
        res[k] = nums[i] * nums[i]
        i += 1
      else:
        res[k] = nums[j] * nums[j]
        j -= 1
      k -= 1
    return res

class Solution {
  public int[] sortedSquares(int[] nums) {
    int n = nums.length;
    int[] res = new int[n];
    for (int i = 0, j = n - 1, k = n - 1; i <= j;) {
      if (nums[i] * nums[i] > nums[j] * nums[j]) {
        res[k--] = nums[i] * nums[i];
        ++i;
      } else {
        res[k--] = nums[j] * nums[j];
        --j;
      }
    }
    return res;
  }
}

class Solution {
public:
  vector<int> sortedSquares(vector<int>& nums) {
    int n = nums.size();
    vector<int> res(n);
    for (int i = 0, j = n - 1, k = n - 1; i <= j;) {
      if (nums[i] * nums[i] > nums[j] * nums[j]) {
        res[k--] = nums[i] * nums[i];
        ++i;
      } else {
        res[k--] = nums[j] * nums[j];
        --j;
      }
    }
    return res;
  }
};

func sortedSquares(nums []int) []int {
  n := len(nums)
  res := make([]int, n)
  for i, j, k := 0, n-1, n-1; i <= j; {
    if nums[i]*nums[i] > nums[j]*nums[j] {
      res[k] = nums[i] * nums[i]
      i++
    } else {
      res[k] = nums[j] * nums[j]
      j--
    }
    k--
  }
  return res
}

impl Solution {
  pub fn sorted_squares(nums: Vec<i32>) -> Vec<i32> {
    let n = nums.len();
    let mut l = 0;
    let mut r = n - 1;
    let mut res = vec![0; n];
    for i in (0..n).rev() {
      let a = nums[l] * nums[l];
      let b = nums[r] * nums[r];
      if a < b {
        res[i] = b;
        r -= 1;
      } else {
        res[i] = a;
        l += 1;
      }
    }
    res
  }
}

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var sortedSquares = function (nums) {
  const n = nums.length;
  const res = new Array(n);
  for (let i = 0, j = n - 1, k = n - 1; i <= j; ) {
    if (nums[i] * nums[i] > nums[j] * nums[j]) {
      res[k--] = nums[i] * nums[i];
      ++i;
    } else {
      res[k--] = nums[j] * nums[j];
      --j;
    }
  }
  return res;
};

class Solution {
  /**
   * @param Integer[] $nums
   * @return Integer[]
   */
  function sortedSquares($nums) {
    $i = 0;
    $j = $k = count($nums) - 1;
    $rs = array_fill(0, count($nums), -1);
    while ($i <= $j) {
      $max1 = $nums[$i] * $nums[$i];
      $max2 = $nums[$j] * $nums[$j];
      if ($max1 > $max2) {
        $rs[$k] = $max1;
        $i++;
      } else {
        $rs[$k] = $max2;
        $j--;
      }
      $k--;
    }
    return $rs;
  }
}