Leetcode -724.寻找数组的中心下标

题目：给你一个整数数组 nums ，请计算数组的 中心下标 。
数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。
如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 - 1 。

示例 1：
输入：nums = [1, 7, 3, 6, 5, 6]
输出：3
解释：
中心下标是 3 。
左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，
右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。

示例 2：
输入：nums = [1, 2, 3]
输出： - 1
解释：
数组中不存在满足此条件的中心下标。

示例 3：
输入：nums = [2, 1, -1]
输出：0
解释：
中心下标是 0 。
左侧数之和 sum = 0 ，（下标 0 左侧不存在元素），
右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。

提示：
1 <= nums.length <= 10^4

• 1000 <= nums[i] <= 1000

思路是前缀和，遍历数组，先计算数组的元素总和 total，sum 计算前缀和，前缀和是当前元素之前的和，判断前缀和和当前元素的后面元素之和，就返回当前元素的下标；否则返回 -1；

		int pivotIndex(int* nums, int numsSize)
		{
		    //total计算数组中元素的总和，sum计算前缀和
		    int total = 0, sum = 0;
		    for (int i = 0; i < numsSize; i++)
		    {
		        total += nums[i];
		    }
		
		    //sum计算当前元素之前的元素的和
		    //total - sum - nums[i]，是当前元素之后的元素的和
		    //当它们俩相等，当前元素即为返回的下标
		    for (int i = 0; i < numsSize; i++)
		    {
		        if (total - sum - nums[i] == sum)
		        {
		            return i;
		        }
		        sum += nums[i];
		    }
		
		    //否则返回-1
		    return -1;
		}

Leetcode -728.自除数

题目：自除数 是指可以被它包含的每一位数整除的数。

例如，128 是一个 自除数 ，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。
自除数 不允许包含 0 。
给定两个整数 left 和 right ，返回一个列表，列表的元素是范围 [left, right] 内所有的 自除数 。

示例 1：
输入：left = 1, right = 22
输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]

示例 2:
输入：left = 47, right = 85
输出：[48, 55, 66, 77]

提示：
1 <= left <= right <= 10^4

思路是先生成 left 到 right 的数，定义一个函数判断是否是自除数，每生成一个数判断这个数是否是自除数，是则返回true，否则返回false；

		bool func(int num)
		{
		    int digit = num;
		    while (digit > 0)
		    {
		        //取这个数的最后一位的数
		        int temp = digit % 10;
		
		        //如果这个数的最后一位是0（不能除以0），或者这个数不能整除 temp ，就不是自除数，返回false
		        if (temp == 0 || num % temp)
		        {
		            return false;
		        }
		
		        //每次判断完除以10，去掉低位
		        digit /= 10;
		    }
		    return true;
		}
		
		int* selfDividingNumbers(int left, int right, int* returnSize)
		{
		    //开辟返回的空间，len计算需要返回的长度
		    int* ret = (int*)malloc(sizeof(int) * right);
		    int len = 0;
		
		    //生成从 left 到 right 的数
		    //func函数判断是否是自除数，若返回true，则是自除数，就把它放入返回数组中
		    for (int i = left; i <= right; i++)
		    {
		        if (func(i))
		        {
		            ret[len++] = i;
		        }
		    }
		
		    *returnSize = len;
		    return ret;
		}