int[] nums = [...]; // 输入数组
int val = ...; // 要移除的值
int[] expectedNums = [...]; // 长度正确的预期答案。
                            // 它以不等于 val 的值排序。

int k = removeElement(nums, val); // 调用你的实现

assert k == expectedNums.length;
sort(nums, 0, k); // 排序 nums 的前 k 个元素
for (int i = 0; i < actualLength; i++) {
    assert nums[i] == expectedNums[i];
}

/**
 * @param {number[]} nums
 * @param {number} val
 * @return {number}
 */
var removeElement = function(nums, val) {
  let slow = 0, fast = 0
  for (; fast < nums.length; fast++) {
    if(nums[fast] !== val) nums[slow++] = nums[fast]
  }
  return slow
};

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function (nums) {
  let l = 0, r = 0
  for (; r < nums.length; r++) {
    if (nums[r] !== nums[l]) nums[++l] = nums[r]
  }
  // 唯一元素个数
  return l+1
};

/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function (nums) {
  if(nums.length === 1) return 1
  let slow = 1, fast = 1
  for (; fast < nums.length; fast++) {
    // 如果当前的值和上一个相同，这一个需要被跳过
    if (nums[fast] !== nums[fast - 1]) nums[slow++] = nums[fast]
  }
  return slow
};

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

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

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var backspaceCompare = function (s, t) {
  const filterBackSpace = (str) => {
    let l = 0, r = 0
    for (; r < str.length; r++) {
      // 如果快指针遇到#，慢指针需要退1格，但不会超过0
      if (str[r] === '#') {
        l = Math.max(0, l-1)
      } else {
        str[l++] = str[r]
      }
    }
    return str.slice(0, l).join('')
  }
  const s_new = filterBackSpace(s.split(""))
  const t_new = filterBackSpace(t.split(""))
  if (s_new !== t_new) return false
  return true
};

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var sortedSquares = function (nums) {
  const firstPositive = () => {
    for (let i = 0; i < nums.length; i++) {
      if (nums[i] >= 0) return i
    }
    return nums.length
  }
  const ans = []
  // 先找到第一个正数
  let positive = firstPositive()
  let navigator = positive - 1
  // 当前正数小于负数绝对值，把正数平方放进数组，正数移动
  // 当前正数大于负数绝对值，把负数平方放进数组，负数移动
  while (positive < nums.length && navigator >= 0) {
    if (nums[positive] < Math.abs(nums[navigator])) {
      ans.push(nums[positive] * nums[positive++])
    } else {
      ans.push(nums[navigator] * nums[navigator--])
    }
  }

  // 把剩余的正数/负数放进数组
  if (navigator < 0) {
    while (positive < nums.length) {
      ans.push(nums[positive] * nums[positive++])
    }
  } else if (positive >= nums.length) {
    while (navigator >= 0) {
      ans.push(nums[navigator] * nums[navigator--])
    }
  }

  return ans
};

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var sortedSquares = function (nums) {
  let l = 0, r = nums.length - 1
  let arr = []
  while (l <= r) {
    const l_2 = nums[l] * nums[l]
    const r_2 = nums[r] * nums[r]
    if (l_2 > r_2) {
      arr.unshift(l_2)
      l++
    } else {
      arr.unshift(r_2)
      r--
    }
  }
  return arr
};