C语言源代码有一个长为 n (1 ≤ n ≤ 1000) 的序列，序列上的元素两两不同。你需要用最少的操作步数翻转这个 序列。 每次操作你需要给出三个数 i, j, k(1 ≤ i ≤ j < k ≤ n)，交换序列中下标属于 [i, j] 的元素与下标属于 [j + 1, k] 的元素。例如：对于长为 7 的序列 1, 2, 3, 4, 5, 6, 7，进行操作 i = 2, j = 4, k = 6 后序列会变为 1, 5, 6, 2, 3, 4, 7。 给定 n，你需要输出最少的操作步数，并输出每一步的具体操作。保证对于所有输入的 n，均存在至 少一个有限步内的合法操作。 Input 一行，一个整数 n。 Output 第一行一个非负整数 m，表示最少的操作步数。 接下来 m 行，每行三个整数 i, j, k，表示进行题目中描述的操作。 要求 1 ≤ i, j, k ≤ n, i ≤ j < k。 你的输出必须保证从上到下执行这 m 次操作后，整个序列被翻转。

这个问题可以使用递归的思路来解决。我们从序列的两端开始，依次将两个元素交换。然后，我们可以将序列分成两个子序列，对每个子序列重复这个过程，直到序列长度为 1 或 2。每次交换后，我们记录交换的位置和长度，最后输出所有操作的位置和长度即可。

以下是实现思路的 C 代码：

#include <stdio.h>

#define MAXN 1005

int n;
int a[MAXN];        // 存储序列
int op[MAXN][3];    // 存储操作

void swap(int i, int j, int k) {
    int x, y, z;
    for (x = i, y = j + 1, z = 0; z <= k - i; z++) {
        int temp = a[x];
        a[x] = a[y];
        a[y] = temp;
        x++;
        y++;
    }
    op[z][0] = i;
    op[z][1] = j;
    op[z][2] = k;
}

void reverse(int l, int r) {
    if (l >= r) return;
    if (r - l == 1) {
        swap(l, l, r);
        return;
    }
    int mid = (l + r) / 2;
    reverse(l, mid);
    reverse(mid + 1, r);
    swap(l, mid, r);
}

int main() {
    scanf("%d", &n);
    int i;
    for (i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    reverse(1, n);
    printf("%d\n", n - 1);
    for (i = 0; i < n - 1; i++) {
        printf("%d %d %d\n", op[i][0], op[i][1], op[i][2]);
    }
    return 0;
}

在这个程序中，我们定义了 `swap()` 函数来实现交换操作。它接受三个参数：操作的起始位置 i、结束位置 j 和交换的长度 k。我们使用一个循环来依次交换两个子序列中的元素，最后记录操作的位置和长度。

我们还定义了 `reverse()` 函数来递归地将序列翻转。当序列长度为 1 或 2 时，我们直接交换元素。否则，我们将序列分成两个子序列，对每个子序列重复这个过程。最后，我们再次调用 `swap()` 函数来交换整个序列的两个子序列。

在主函数中，我们读取输入序列，调用 `reverse()` 函数来翻转序列，并输出每个操作的位置和长度。注意，最后一个操作不需要输出，因为它不改变序列。