1. 每日一言

最快乐的事情之一，就是或多或少不意识到自己的存在，因有趣的景色、事物和人而忘我。

---

2. 题目

题目链接：数组串联

给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，数组下标 从 0 开始计数 ，对于所有 0 <= i < n 的 i ，满足下述所有要求：

ans[i] == nums[i]
ans[i + n] == nums[i]
具体而言，ans 由两个 nums 数组 串联 形成。

返回数组 ans 。

• 示例 1：
  输入：nums = [1,2,1]
  输出：[1,2,1,1,2,1]
  解释：数组 ans 按下述方式形成：
  - ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]
  - ans = [1,2,1,1,2,1]

• 示例 2：
  输入：nums = [1,3,2,1]
  输出：[1,3,2,1,1,3,2,1]
  解释：数组 ans 按下述方式形成：
  - ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]
  - ans = [1,3,2,1,1,3,2,1]

提示：
n == nums.length
1 <= n <= 1000
1 <= nums[i] <= 1000

---

2.1 解题思路

1. 首先分配一个大小为 2 * numsSize 的整型数组 arr，用于存储拼接后的结果。
2. 然后，通过一个循环将 nums 数组中的元素复制到 arr 数组中两次，实现数组的拼接。
3. 拼接的方式是将原数组 nums 中的元素依次复制到 arr 数组中，然后再从原数组的第一个元素开始复制，直到复制完整个原数组。
4. 最后，将拼接后的数组的大小 2 * numsSize 通过 returnSize 返回，并返回拼接后的数组 arr。

2.2 代码

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* getConcatenation(int* nums, int numsSize, int* returnSize) {
	//开辟空间
    int* arr = (int*)malloc(2 * numsSize * sizeof(int));
    //复制数组
    for(int i = 0; i < numsSize; i++) {
        arr[i] = nums[i];
        arr[i+numsSize] = nums[i];
    }
    //设置返回的数组大小
    *returnSize = 2 * numsSize;
    //返回数组
    return arr;
}

3. 题目

题目链接：左右元素和的差值

给你一个下标从 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] 。

提示：
1 <= nums.length <= 1000
1 <= nums[i] <= 105

---

3.1 解题思路

1. 首先使用 malloc() 分配三个整型数组的内存空间，分别是 leftSum、rightSum 和 answer，用于存储左侧元素和、右侧元素和以及计算结果。
2. 计算左侧元素和 leftSum：从数组的第一个元素开始，累加当前元素与前一个元素的和，并存储在 leftSum 数组中。
3. 计算右侧元素和 rightSum：从数组的最后一个元素开始，逆序累加当前元素与后一个元素的和，并存储在 rightSum 数组中。
4. 计算左右两侧元素和的差值：遍历数组 nums，对于每个位置 i，计算 rightSum[i] - leftSum[i] 的绝对值，并存储在 answer 数组中。这一步得到了每个位置 i 左右两侧元素和的差值。
5. 释放内存：在计算完差值后，需要手动释放 leftSum 和 rightSum 数组的内存空间，以避免内存泄漏。
6. 最后，将计算得到的差值数组的大小 numsSize 通过 returnSize 返回，并返回差值数组 answer。

3.2 代码

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* leftRightDifference(int* nums, int numsSize, int* returnSize){
    
    int* leftSum = (int*)malloc(sizeof(int)*numsSize);
    leftSum[0] = 0;
    for(int i = 0; i < numsSize - 1; i++) {
        leftSum[i+1] = nums[i] + leftSum[i];
    }

    int* rightSum = (int*)malloc(sizeof(int)*numsSize);
    rightSum[numsSize-1] = 0;
    for(int i = numsSize - 1; i > 0; i--) {
        rightSum[i-1] = nums[i] + rightSum[i];
    }

    int* answer = (int*)malloc(sizeof(int)*numsSize);
    for(int i = 0; i < numsSize; i++) {
        answer[i] = abs(rightSum[i] - leftSum[i]);
    }
    free(rightSum);
    free(leftSum);
    *returnSize = numsSize;
    return answer;
}

---

---