给你一个 m x n 的整数网格 accounts ,其中 accounts[i][j] 是第 i 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。
客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。
int maximumWealth(int** accounts, int accountsSize, int* accountsColSize){ int i, j; int maxv = -1, maxIdx, sumv; for(i = 0; i < accountsSize; ++i) { sumv = 0; for(j = 0; j < *accountsColSize; ++j) { sumv += accounts[i][j]; } if(sumv > maxv) { maxv = sumv; maxIdx = i; } } return maxv; }
给你一个大小为 rows x cols 的矩阵 mat,其中 mat[i][j] 是 0 或 1,请返回 矩阵 mat 中特殊位置的数目 。
特殊位置 定义:如果 mat[i][j] == 1 并且第 i 行和第 j 列中的所有其他元素均为 0(行和列的下标均 从 0 开始 ),则位置 (i, j) 被称为特殊位置。
int numSpecial(int** mat, int matSize, int* matColSize){ int *row = (int*)malloc(sizeof(int)*matSize); int *col = (int*)malloc(sizeof(int)*(*matColSize)); memset( row , 0 , sizeof( int ) * matSize ); memset( col , 0 , sizeof( int ) * ( * matColSize ) ); int i,j; for(i=0;i<matSize;i++){ for(j=0;j<(*matColSize+0);j++){ row[i]+=mat[i][j]; col[j]+=mat[i][j]; } } int cnt=0; for( i = 0;i < matSize;i++) { for( j = 0;j <(*matColSize+0);j++) { if(mat[i][j] == 1 && row[i] == 1 && col[j] == 1) cnt++; } } return cnt; }
给定一个 n x n 的二进制矩阵 image ,先 水平 翻转图像,然后 反转 图像并返回 结果 。
水平翻转图片就是将图片的每一行都进行翻转,即逆序。
例如,水平翻转 [1,1,0] 的结果是 [0,1,1]。
反转图片的意思是图片中的 0 全部被 1 替换, 1 全部被 0 替换。
例如,反转 [0,1,1] 的结果是 [1,0,0]。
/** * Return an array of arrays of size *returnSize. * The sizes of the arrays are returned as *returnColumnSizes array. * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free(). */ int** flipAndInvertImage(int** image, int imageSize, int* imageColSize, int* returnSize, int** returnColumnSizes){ int i, j, col; int **ret = (int **)malloc( sizeof(int *) * imageSize ); *returnColumnSizes = (int *)malloc( sizeof(int) * imageSize ); for(i = 0; i < imageSize; ++i) { col = imageColSize[i]; ret[i] = (int *)malloc( sizeof(int) * col ); (*returnColumnSizes)[i] = col; for(j = 0; j < col; ++j) { ret[i][j] = 1 - image[i][ col-1-j ]; } } *returnSize = imageSize; return ret; }
给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
你必须在 原地 旋转图像,这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像
void rotate(int** matrix, int matrixSize, int* matrixColSize) { int matrix_new[matrixSize][matrixSize]; for (int i = 0; i < matrixSize; i++) { for (int j = 0; j < matrixSize; j++) { matrix_new[i][j] = matrix[i][j]; } } for (int i = 0; i < matrixSize; ++i) { for (int j = 0; j < matrixSize; ++j) { matrix[j][matrixSize - i - 1] = matrix_new[i][j]; } } }
给你一个二维整数数组
matrix
, 返回matrix
的 转置矩阵 。矩阵的 转置 是指将矩阵的主对角线翻转,交换矩阵的行索引与列索引。
/** * Return an array of arrays of size *returnSize. * The sizes of the arrays are returned as *returnColumnSizes array. * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free(). */ int** transpose(int** matrix, int matrixSize, int* matrixColSize, int* returnSize, int** returnColumnSizes) { int m = matrixSize, n = matrixColSize[0]; int** transposed = malloc(sizeof(int*) * n); *returnSize = n; *returnColumnSizes = malloc(sizeof(int) * n); for (int i = 0; i < n; i++) { transposed[i] = malloc(sizeof(int) * m); (*returnColumnSizes)[i] = m; } for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { transposed[j][i] = matrix[i][j]; } } return transposed; }
给你一个下标从 0 开始的一维整数数组 original 和两个整数 m 和 n 。你需要使用 original 中 所有 元素创建一个 m 行 n 列的二维数组。
original 中下标从 0 到 n - 1 (都 包含 )的元素构成二维数组的第一行,下标从 n 到 2 * n - 1 (都 包含 )的元素构成二维数组的第二行,依此类推。
请你根据上述过程返回一个 m x n 的二维数组。如果无法构成这样的二维数组,请你返回一个空的二维数组。
/** * Return an array of arrays of size *returnSize. * The sizes of the arrays are returned as *returnColumnSizes array. * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free(). */ int **myMalloc(int r, int c, int* returnSize, int** returnColumnSizes) { int i; int **ret = (int **)malloc( sizeof(int *) * r ); *returnColumnSizes = (int *)malloc( sizeof(int) * r ); *returnSize = r; for(i = 0; i < r; ++i){ ret[i] = (int *)malloc( sizeof(int) * c ); (*returnColumnSizes)[i] = c; } return ret; } int** construct2DArray(int* original, int originalSize, int m, int n, int* returnSize, int** returnColumnSizes){ int **ret, i, j; if (originalSize != n*m) { *returnSize = 0; return ret; } ret = myMalloc(m, n, returnSize, returnColumnSizes); for(i = 0; i < m; ++i) { for(j = 0; j < n; ++j) { ret[i][j] = original[ i * n + j ]; } } return ret; }