1
#include <stdlib.h>
2

3
static int cmpInt(const void *a, const void *b) {
4
    int x = *(const int *)a;
5
    int y = *(const int *)b;
6
    return (x > y) - (x < y);          /* 用减法可能溢出，这样写更稳 */
7
}
8

9
/* 排序从 (r, c) 出发、朝右下延伸的那条对角线 */
10
static void sortDiagonal(int **mat, int m, int n, int r, int c) {
11
    int len = 0;
12
    while (r + len < m && c + len < n) len++;      /* 这条对角线的长度 */
13

14
    int *buf = (int *)malloc(sizeof(int) * len);
15
    for (int k = 0; k < len; k++) buf[k] = mat[r + k][c + k];
16

17
    qsort(buf, len, sizeof(int), cmpInt);
18

19
    for (int k = 0; k < len; k++) mat[r + k][c + k] = buf[k];
20

21
    free(buf);
22
}
23

24
void diagonalSort(int **mat, int m, int n) {
25
    for (int i = 0; i < m; i++) sortDiagonal(mat, m, n, i, 0);  /* 第一列出发 */
26
    for (int j = 1; j < n; j++) sortDiagonal(mat, m, n, 0, j);  /* 第一行出发 */
27
}

1
function diagonalSort(mat) {
2
  const m = mat.length;
3
  const n = mat[0].length;
4

5
  // 读出 (r, c) 这条对角线 -> 排序 -> 写回
6
  const sortDiagonal = (r, c) => {
7
    const diag = [];
8
    for (let i = r, j = c; i < m && j < n; i++, j++) diag.push(mat[i][j]);
9
    diag.sort((a, b) => a - b);
10
    let k = 0;
11
    for (let i = r, j = c; i < m && j < n; i++, j++) mat[i][j] = diag[k++];
12
  };
13

14
  for (let i = 0; i < m; i++) sortDiagonal(i, 0);   // 第一列出发
15
  for (let j = 1; j < n; j++) sortDiagonal(0, j);   // 第一行出发（跳过 (0,0)）
16

17
  return mat;
18
}

1
#include <stdlib.h>
2

3
int **shiftGrid(int **grid, int m, int n, int k) {
4
    int total = m * n;
5
    k %= total;                                    /* 迁移 total 次等于没动 */
6

7
    int **res = (int **)malloc(sizeof(int *) * m);
8
    for (int i = 0; i < m; i++) res[i] = (int *)malloc(sizeof(int) * n);
9

10
    for (int i = 0; i < m; i++) {
11
        for (int j = 0; j < n; j++) {
12
            int p = i * n + j;                     /* 展平后的下标 */
13
            int q = (p + k) % total;               /* 迁移 k 次后的下标 */
14
            res[q / n][q % n] = grid[i][j];
15
        }
16
    }
17
    return res;
18
}

1
function shiftGrid(grid, k) {
2
  const m = grid.length;
3
  const n = grid[0].length;
4
  const total = m * n;
5
  k %= total;                                  // 迁移 total 次等于没动
6

7
  const res = Array.from({ length: m }, () => new Array(n));
8

9
  for (let i = 0; i < m; i++) {
10
    for (let j = 0; j < n; j++) {
11
      const q = (i * n + j + k) % total;       // 展平后向后移动 k 位
12
      res[Math.floor(q / n)][q % n] = grid[i][j];
13
    }
14
  }
15
  return res;
16
}

1
#include <stdlib.h>
2

3
/* 非方阵：结果是一个新的 n×m 矩阵 */
4
int **transpose(int **mat, int m, int n) {
5
    int **res = (int **)malloc(sizeof(int *) * n);
6
    for (int j = 0; j < n; j++) res[j] = (int *)malloc(sizeof(int) * m);
7

8
    for (int i = 0; i < m; i++)
9
        for (int j = 0; j < n; j++)
10
            res[j][i] = mat[i][j];
11

12
    return res;
13
}
14

15
/* 方阵可以原地转置：只处理上三角 (i < j)，对角线不动 */
16
void transposeInPlace(int **mat, int m) {
17
    for (int i = 0; i < m; i++)
18
        for (int j = i + 1; j < m; j++) {
19
            int t = mat[i][j];
20
            mat[i][j] = mat[j][i];
21
            mat[j][i] = t;
22
        }
23
}

1
function transpose(matrix) {
2
  const m = matrix.length;
3
  const n = matrix[0].length;
4
  const res = Array.from({ length: n }, () => new Array(m));
5

6
  for (let i = 0; i < m; i++)
7
    for (let j = 0; j < n; j++) res[j][i] = matrix[i][j];
8

9
  return res;
10
}
11

12
// 方阵可以原地转置：只处理上三角
13
function transposeInPlace(matrix) {
14
  const m = matrix.length;
15
  for (let i = 0; i < m; i++)
16
    for (let j = i + 1; j < m; j++) {
17
      [matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];
18
    }
19
}

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

4
char *longestCommonPrefix(char **strs, int strsSize) {
5
    int len = (int)strlen(strs[0]);        /* 公共前缀不可能比基准串更长 */
6

7
    for (int j = 0; j < len; j++) {        /* j：沿基准串前进的列指针 */
8
        char c = strs[0][j];
9
        for (int i = 1; i < strsSize; i++) {   /* i：横向比较其余字符串 */
10
            /* 该字符串在此处已经结束（读到 '\0'），或字符不相等 */
11
            if (strs[i][j] == '\0' || strs[i][j] != c) {
12
                char *cut = (char *)malloc(j + 1);
13
                memcpy(cut, strs[0], j);
14
                cut[j] = '\0';
15
                return cut;
16
            }
17
        }
18
    }
19

20
    char *whole = (char *)malloc(len + 1);
21
    memcpy(whole, strs[0], len + 1);
22
    return whole;
23
}

1
function longestCommonPrefix(strs) {
2
  const base = strs[0];                    // 基准串
3

4
  for (let j = 0; j < base.length; j++) {         // j：列指针
5
    const c = base[j];
6
    for (let i = 1; i < strs.length; i++) {       // i：行指针
7
      // 该字符串已经结束，或第 j 个字符不相等
8
      if (j >= strs[i].length || strs[i][j] !== c) {
9
        return base.slice(0, j);
10
      }
11
    }
12
  }
13
  return base;
14
}