1
int removeDuplicates(int *nums, int numsSize) {
2
    if (numsSize == 0) return 0;
3

4
    int slow = 0;                        /* [0, slow] 是已去重的前缀 */
5
    for (int fast = 1; fast < numsSize; fast++) {
6
        if (nums[fast] != nums[slow]) {  /* 发现新值 */
7
            slow++;
8
            nums[slow] = nums[fast];
9
        }
10
    }
11
    return slow + 1;                     /* 长度 = 最后下标 + 1 */
12
}

1
function removeDuplicates(nums) {
2
  if (nums.length === 0) return 0;
3

4
  let slow = 0;                        // [0, slow] 是已去重的前缀
5
  for (let fast = 1; fast < nums.length; fast++) {
6
    if (nums[fast] !== nums[slow]) {   // 发现新值
7
      slow++;
8
      nums[slow] = nums[fast];
9
    }
10
  }
11
  return slow + 1;
12
}

1
#include <ctype.h>
2
#include <string.h>
3

4
int isPalindrome(char *s) {
5
    int i = 0;
6
    int j = (int)strlen(s) - 1;
7

8
    while (i < j) {
9
        /* 跳过非字母数字字符，注意内层循环也要检查 i < j */
10
        while (i < j && !isalnum((unsigned char)s[i])) i++;
11
        while (i < j && !isalnum((unsigned char)s[j])) j--;
12

13
        if (tolower((unsigned char)s[i]) != tolower((unsigned char)s[j])) return 0; /* false */
14
        i++;
15
        j--;
16
    }
17
    return 1; /* true */
18
}

1
function isPalindrome(s) {
2
  const isAlnum = (ch) => /[0-9a-zA-Z]/.test(ch);
3

4
  let i = 0;
5
  let j = s.length - 1;
6

7
  while (i < j) {
8
    // 跳过非字母数字字符，注意内层循环也要检查 i < j
9
    while (i < j && !isAlnum(s[i])) i++;
10
    while (i < j && !isAlnum(s[j])) j--;
11

12
    if (s[i].toLowerCase() !== s[j].toLowerCase()) return false;
13
    i++;
14
    j--;
15
  }
16
  return true;
17
}

1
static void swapInt(int *a, int *b) {
2
    int t = *a;
3
    *a = *b;
4
    *b = t;
5
}
6

7
void sortColors(int *nums, int numsSize) {
8
    int p0 = 0;                   /* 下一个 0 要放的位置 */
9
    int i = 0;                    /* 当前扫描位置 */
10
    int p2 = numsSize - 1;        /* 下一个 2 要放的位置 */
11

12
    while (i <= p2) {
13
        if (nums[i] == 0) {
14
            swapInt(&nums[i], &nums[p0]);
15
            p0++;
16
            i++;                  /* 换过来的一定是 0 或 1，可以跳过 */
17
        } else if (nums[i] == 2) {
18
            swapInt(&nums[i], &nums[p2]);
19
            p2--;                 /* 换过来的是未处理元素，i 不能前进 */
20
        } else {
21
            i++;                  /* 1 留在原地 */
22
        }
23
    }
24
}

1
function sortColors(nums) {
2
  let p0 = 0;                  // 下一个 0 要放的位置
3
  let i = 0;                   // 当前扫描位置
4
  let p2 = nums.length - 1;    // 下一个 2 要放的位置
5

6
  while (i <= p2) {
7
    if (nums[i] === 0) {
8
      [nums[i], nums[p0]] = [nums[p0], nums[i]];
9
      p0++;
10
      i++;                     // 换过来的一定是 0 或 1，可以跳过
11
    } else if (nums[i] === 2) {
12
      [nums[i], nums[p2]] = [nums[p2], nums[i]];
13
      p2--;                    // 换过来的是未处理元素，i 不能前进
14
    } else {
15
      i++;                     // 1 留在原地
16
    }
17
  }
18
}

1
void merge(int *nums1, int m, int *nums2, int n) {
2
    int p1 = m - 1;               /* nums1 中待合并的最后一个元素 */
3
    int p2 = n - 1;               /* nums2 中待合并的最后一个元素 */
4
    int tail = m + n - 1;         /* 写入位置，从后往前 */
5

6
    while (p2 >= 0) {
7
        /* p1 可能已经是 -1，必须先判断 p1 >= 0（利用 && 短路） */
8
        if (p1 >= 0 && nums1[p1] > nums2[p2]) {
9
            nums1[tail--] = nums1[p1--];
10
        } else {
11
            nums1[tail--] = nums2[p2--];
12
        }
13
    }
14
}

1
function merge(nums1, m, nums2, n) {
2
  let p1 = m - 1;              // nums1 中待合并的最后一个元素
3
  let p2 = n - 1;              // nums2 中待合并的最后一个元素
4
  let tail = m + n - 1;        // 写入位置，从后往前
5

6
  while (p2 >= 0) {
7
    // p1 可能已经是 -1，必须先判断 p1 >= 0（利用 && 短路）
8
    if (p1 >= 0 && nums1[p1] > nums2[p2]) {
9
      nums1[tail--] = nums1[p1--];
10
    } else {
11
      nums1[tail--] = nums2[p2--];
12
    }
13
  }
14
}

1
#include <stdlib.h>
2

3
int *sortedSquares(int *nums, int numsSize, int *returnSize) {
4
    int *res = (int *)malloc(sizeof(int) * numsSize);
5
    int i = 0;
6
    int j = numsSize - 1;
7
    int k = numsSize - 1;         /* 从结果数组末尾往前填 */
8

9
    while (i <= j) {
10
        int left = nums[i] * nums[i];
11
        int right = nums[j] * nums[j];
12
        if (left > right) {
13
            res[k--] = left;
14
            i++;
15
        } else {
16
            res[k--] = right;
17
            j--;
18
        }
19
    }
20

21
    *returnSize = numsSize;
22
    return res;
23
}

1
function sortedSquares(nums) {
2
  const n = nums.length;
3
  const res = new Array(n);
4
  let i = 0;
5
  let j = n - 1;
6

7
  for (let k = n - 1; k >= 0; k--) {
8
    // 对整数而言 |x| > |y| 等价于 x² > y²
9
    if (Math.abs(nums[i]) > Math.abs(nums[j])) {
10
      res[k] = nums[i] * nums[i];
11
      i++;
12
    } else {
13
      res[k] = nums[j] * nums[j];
14
      j--;
15
    }
16
  }
17
  return res;
18
}