五月集训：DAY01数组

1.增量元素之间的最大差值

给你一个下标从 0 开始的整数数组 nums ，该数组的大小为 n ，请你计算 nums[j] - nums[i] 能求得的 最大差值 ，其中 0 <= i < j < n 且 nums[i] < nums[j] 。
返回 最大差值 。如果不存在满足要求的 i 和 j ，返回 -1 。

输入：nums = [7,1,5,4]
输出：4
解释：
最大差值出现在 i = 1 且 j = 2 时，nums[j] - nums[i] = 5 - 1 = 4 。
注意，尽管 i = 1 且 j = 0 时 ，nums[j] - nums[i] = 7 - 1 = 6 > 4 ，但 i > j 不满足题面要求，所以 6 不是有效的答案。

输入：nums = [9,4,3,2]
输出：-1
解释：
不存在同时满足 i < j 和 nums[i] < nums[j] 这两个条件的 i, j 组合。

输入：nums = [1,5,2,10]
输出：9
解释：
最大差值出现在 i = 0 且 j = 3 时，nums[j] - nums[i] = 10 - 1 = 9 。

• n == nums.length
• 2 <= n <= 1000
• 1 <= nums[i] <= 109

int maximumDifference(int* nums, int numsSize){
    int i = 0; 
    int j = 0;
    int max = 0;
    for(i = 0; i < numsSize; i++){
        for(j = i + 1; j < numsSize; j++){
            int ret = nums[j] - nums[i];
            if(ret > 0){
                max = max > ret ? max : ret;
            }
        }
    }
    if(0 == max){  //(1)
        return -1; 
    }else{
        return max;
    }
}

解题思路:(1)如果 后 - 前 都是负值，不满足题意，则max的值不会改变。

2.找到最接近0的数字

给你一个长度为 n 的整数数组 nums ，请你返回 nums 中最 接近 0 的数字。如果有多个答案，请你返回它们中的 最大值 。

输入：nums = [-4,-2,1,4,8]
输出：1
解释：
-4 到 0 的距离为 |-4| = 4 。
-2 到 0 的距离为 |-2| = 2 。
1 到 0 的距离为 |1| = 1 。
4 到 0 的距离为 |4| = 4 。
8 到 0 的距离为 |8| = 8 。
所以，数组中距离 0 最近的数字为 1 。

输入：nums = [2,-1,1]
输出：1
解释：1 和 -1 都是距离 0 最近的数字，所以返回较大值 1 。

• 1 <= n <= 1000
• -100000 <= nums[i] <= 100000

int findClosestNumber(int* nums, int numsSize){
    int i = 0; int j = 0;
    int min = 100001;
    int max = -100001;
    int* ret = (int*)malloc(sizeof(int) * numsSize);
    for(i = 0; i < numsSize; i++){
        ret[i] = nums[i] > 0 ? nums[i] : -nums[i];  //(1)
    }
    for(i = 0; i < numsSize; i++){
        if(ret[i] < min){
            min = ret[i];                           //(2)
        }
    }
    for(i = 0; i < numsSize; i++){
        if(min == ret[i]){
            max = max > nums[i] ? max : nums[i];   //(3)
        }
    }
    return max;
}

解题思路:
(1)ret数组表示到0的距离
(2)找到最小的距离min
(3)找出这些答案中的最大值

商品折扣后的最终价格

给你一个数组 prices ，其中 prices[i] 是商店里第 i 件商品的价格。
商店里正在进行促销活动，如果你要买第 i 件商品，那么你可以得到与 prices[j] 相等的折扣，其中 j 是满足 j > i 且 prices[j] <= prices[i] 的 最小下标 ，如果没有满足条件的 j ，你将没有任何折扣。
请你返回一个数组，数组中第 i 个元素是折扣后你购买商品 i 最终需要支付的价格。

输入：prices = [8,4,6,2,3]
输出：[4,2,4,2,3]
解释：
商品 0 的价格为 price[0]=8 ，你将得到 prices[1]=4 的折扣，所以最终价格为 8 - 4 = 4 。
商品 1 的价格为 price[1]=4 ，你将得到 prices[3]=2 的折扣，所以最终价格为 4 - 2 = 2 。
商品 2 的价格为 price[2]=6 ，你将得到 prices[3]=2 的折扣，所以最终价格为 6 - 2 = 4 。
商品 3 和 4 都没有折扣。

输入：prices = [1,2,3,4,5]
输出：[1,2,3,4,5]
解释：在这个例子中，所有商品都没有折扣。

输入：prices = [10,1,1,6]
输出：[9,0,1,6]

• 1 <= prices.length <= 500
• 1 <= prices[i] <= 10^3

int* finalPrices(int* prices, int pricesSize, int* returnSize){
    int i = 0; int j = 0;
    int* ret = (int*)malloc(sizeof(int) * pricesSize);
    for(i = 0; i < pricesSize; i++){
        for(j = i + 1; j < pricesSize; j++){
            if(prices[j] <= prices[i]){
                prices[i] = prices[i] - prices[j];
                break;
            }
        }
        ret[i] = prices[i];
    }
    *returnSize = pricesSize;
    return ret;
}

多个数组交集

给你一个二维整数数组 nums ，其中 nums[i] 是由 不同 正整数组成的一个非空数组，按 升序排列 返回一个数组，数组中的每个元素在 nums 所有数组 中都出现过。

输入：nums = [[3,1,2,4,5],[1,2,3,4],[3,4,5,6]]
输出：[3,4]
解释：
nums[0] = [3,1,2,4,5]，nums[1] = [1,2,3,4]，nums[2] = [3,4,5,6]，在 nums 中每个数组中都出现的数字是 3 和 4 ，所以返回 [3,4] 。

输入：nums = [[1,2,3],[4,5,6]]
输出：[]
解释：
不存在同时出现在 nums[0] 和 nums[1] 的整数，所以返回一个空列表 [] 。

• 1 <= nums.length <= 1000
• 1 <= sum(nums[i].length) <= 1000
• 1 <= nums[i][j] <= 1000
• nums[i] 中的所有值 互不相同

int cmp(const void* a, const void* b){
    return *(int*)a - *(int*)b;
}
int* intersection(int** nums, int numsSize, int* numsColSize, int* returnSize){
    int i= 0; int j = 0; int k = 0;
    int* ret = (int*)malloc(sizeof(int) * numsColSize[0]);
    int len = 0;
    for(k = 0; k < numsColSize[0]; k++){               //(1)
        int count = 0;
        for(i = 1; i < numsSize; i++){                 //(2)
            for(j = 0; j < numsColSize[i]; j++){
                if(nums[0][k] == nums[i][j]){             
                    count++;
                    break;
                }
            }
        }
        if(count == numsSize-1){
            ret[len++] = nums[0][k];                  //(3)
        }
    }
    *returnSize = len;
    qsort(ret, len, sizeof(int), cmp);                //(4)
    return ret;
}

解题思路:
(1)第一排的元素是nums[0][k]。
(2)把第一排的每一个元素与其他对比，相同就count++。
(3)如果相同的元素有 行数-1 说明每一行都有这个元素。
(4)把得到的数组从小到大排序。