C语言-力扣100155.双模幂运算（malloc函数）

给你一个下标从 0 开始的二维数组 variables ，其中 variables[i] = [ai, bi, ci, mi]，以及一个整数 target 。

如果满足以下公式，则下标 i 是 好下标：

• 0 <= i < variables.length
• ((aibi % 10)ci) % mi == target

返回一个由 好下标 组成的数组，顺序不限 。

示例 1：

输入：variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
输出：[0,2]
解释：对于 variables 数组中的每个下标 i ：
1) 对于下标 0 ，variables[0] = [2,3,3,10] ，(23 % 10)3 % 10 = 2 。
2) 对于下标 1 ，variables[1] = [3,3,3,1] ，(33 % 10)3 % 1 = 0 。
3) 对于下标 2 ，variables[2] = [6,1,1,4] ，(61 % 10)1 % 4 = 2 。
因此，返回 [0,2] 作为答案。

示例 2：

输入：variables = [[39,3,1000,1000]], target = 17
输出：[]
解释：对于 variables 数组中的每个下标 i ：
1) 对于下标 0 ，variables[0] = [39,3,1000,1000] ，(393 % 10)1000 % 1000 = 1 。
因此，返回 [] 作为答案。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* getGoodIndices(int** variables, int variablesSize, int* variablesColSize, int target, int* returnSize) {
    // 用于存储好下标的动态数组
    int* ans = (int*)malloc(variablesSize * sizeof(int));
    *returnSize = 0;

    for (int i = 0; i < variablesSize; ++i) {
        int a = variables[i][0];
        int b = variables[i][1];
        int c = variables[i][2];
        int m = variables[i][3];

        // 计算公式 ((a * b % 10) ^ c) % m
        long long abMod10 = 1;
        for (int j = 0; j < b; ++j) {
            abMod10 = (abMod10 * a) % 10;
        }

        long long result = 1;
        for (int j = 0; j < c; ++j) {
            result = (result * abMod10) % m;
        }

        // 检查是否等于 target
        if (result == target) {
            ans[*returnSize] = i;
            (*returnSize)++;
        }
    }

    return ans;
}

• int** variables :一个指向二位整数数组的指针，用于存储每个变量的值。
• int variablesSize :这个二维数组的行数。
• int* variablesColSize :一个指向整数数组的指针，其中每个元素表示 variables 中相应行的列数（在此特定问题中不使用）。
• int target :我们需要匹配的目标值。
• int* returnSize :一个指向整数的指针，用来存储函数返回数组的大小。

int* ans=(int*)malloc(variablesSize * sizeof(int))

malloc 函数

malloc函数是C语言中用于动态内存分配的标准库函数。malloc的全程为memory allocation（分配）

1.语法：void* malloc(size_t size)

2.返回值：

• 成功：返回一个指向分配内存的指针。
• 失败：返回NULL。

3.初始化：

分配的内存不会被自动初始化，其内容是未定义的。可用 calloc 函数，或者手动初始化内存。

4.内存释放：

用 malloc分配的内存会一直保留，直到使用 free 函数显示释放，或者程序结束。

5.类型转换：

malloc 返回的是 void* 类型的指针，可以被转换为任何其它类型的指针。

6.示例

int* ptr = (int*)malloc(10 * sizeof(int));
if(ptr == NULL){
    //分配失败的处理
}
//使用ptr
free(ptr);//释放内存

num = (num * a)%10

for(int j=0;j<b;++j){
    num = (num * a)%10;
    }

这个循环计算（a * b）%10。由于直接计算可能导致溢出，所以用循环乘法代替。

！！！重点注意最后一段代码，可代替python中的.append()方法

 if (result == target) {
            ans[*returnSize] = i;
            (*returnSize)++;
        }