01数组._给你一个 从 0 开始的排列 nums(下标也从 0 开始)。请你构建一个 同样长度 的数组

1、1920-从排列构建数组

给你一个 从 0 开始的排列 （下标也从 0 开始）。请你构建一个 同样长度 的数组 ，其中，对于每个 （），都满足 。返回构建好的数组 。numsansi0 <= i < nums.lengthans[i] = nums[nums[i]]ans

从 0 开始的排列 是一个由 到 （ 和 也包含在内）的不同整数组成的数组。nums0nums.length - 10nums.length - 1

示例 1：

输入：nums = [0,2,1,5,3,4]
输出：[0,1,2,4,5,3]
解释：数组 ans 构建如下：
ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
    = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
    = [0,1,2,4,5,3]

示例 2：

输入：nums = [5,0,1,2,3,4]
输出：[4,5,0,1,2,3]
解释：数组 ans 构建如下：
ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
    = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]
    = [4,5,0,1,2,3]

int* buildArray(int* nums, int numsSize, int* returnSize){
    int *ans=(int*) malloc(sizeof(int)*numsSize);
    //动态分配内存空间，数组长度为numsSize，首地址为ans
    int i=0;
    for(i=0;i<numsSize;i++)
    {
        ans[i]=nums[nums[i]];
    }
    *returnSize=numsSize;   //用参数实现将数组长度告诉调用者。
    return ans;
}

2、1732-找到最高海拔

有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。

给你一个长度为 n 的整数数组 gain ，其中 gain[i] 是点 i 和点 i + 1 的 净海拔高度差（0 <= i < n）。请你返回 最高点的海拔 。

示例 1：

输入：gain = [-5,1,5,0,-7]
输出：1
解释：海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。
示例 2：

输入：gain = [-4,-3,-2,-1,4,3,2]
输出：0
解释：海拔高度依次为 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔为 0 。
 

int largestAltitude(int* gain, int gainSize){
    int sum=0;
    int max=0;
    for(int i=0;i<gainSize;i++)
    {
        sum+=gain[i];
        max=fmax(sum,max);
    }
    return max;
}

3、2367-算术三元组的数量

给你一个下标从 0 开始、严格递增 的整数数组 nums 和一个正整数 diff 。如果满足下述全部条件，则三元组 (i, j, k) 就是一个 算术三元组 ：

i < j < k ，
nums[j] - nums[i] == diff 且
nums[k] - nums[j] == diff
返回不同 算术三元组 的数目。

示例 1：

输入：nums = [0,1,4,6,7,10], diff = 3
输出：2
解释：
(1, 2, 4) 是算术三元组：7 - 4 == 3 且 4 - 1 == 3 。
(2, 4, 5) 是算术三元组：10 - 7 == 3 且 7 - 4 == 3 。
示例 2：

输入：nums = [4,5,6,7,8,9], diff = 2
输出：2
解释：
(0, 2, 4) 是算术三元组：8 - 6 == 2 且 6 - 4 == 2 。
(1, 3, 5) 是算术三元组：9 - 7 == 2 且 7 - 5 == 2 。
 

int arithmeticTriplets(int* nums, int numsSize, int diff){
     int ans = 0;
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[j] - nums[i] != diff) {
                continue;
            }
            for (int k = j + 1; k < numsSize; k++) {
                if (nums[k] - nums[j] == diff) {
                    ans++;
                }
            }
        }
    }
    return ans;
}

4、2574-左右和差

给你一个下标从 0 开始的整数数组 nums ，请你找出一个下标从 0 开始的整数数组 answer ，其中：

answer.length == nums.length
answer[i] = |leftSum[i] - rightSum[i]|
其中：

leftSum[i] 是数组 nums 中下标 i 左侧元素之和。如果不存在对应的元素，leftSum[i] = 0 。
rightSum[i] 是数组 nums 中下标 i 右侧元素之和。如果不存在对应的元素，rightSum[i] = 0 。
返回数组 answer 。

示例 1：

输入：nums = [10,4,8,3]
输出：[15,1,11,22]
解释：数组 leftSum 为 [0,10,14,22] 且数组 rightSum 为 [15,11,3,0] 。
数组 answer 为 [|0 - 15|,|10 - 11|,|14 - 3|,|22 - 0|] = [15,1,11,22] 。
示例 2：

输入：nums = [1]
输出：[0]
解释：数组 leftSum 为 [0] 且数组 rightSum 为 [0] 。
数组 answer 为 [|0 - 0|] = [0] 。

int* leftRightDifference(int* nums, int numsSize, int* returnSize){
  int right_sum = 0,left_sum = 0;
    int *res = malloc(sizeof(int) * numsSize);
    *returnSize = numsSize;
    for (int i = 1; i < numsSize; i++) {
        right_sum += nums[i];
    }
    for (int i = 0; i < numsSize - 1; i++) {
        res[i] = abs(right_sum - left_sum);
        left_sum += nums[i];
        right_sum -= nums[i + 1];
    }
    res[numsSize - 1] = left_sum;
    return res;
}