力扣(LeetCode)刷题，简单题(第23期)

目录

第1题：整数转换

第2题：重复的子字符串

第3题：范围求和2

第4题：反转数位

第5题：数字转换为十六进制

第6题：比较含退格的字符

第7题：三个数的最大乘积

第8题：珠玑妙算

第9题：旋转字符串

第10题：较大分组的位置

---

力扣(LeetCode)定期刷题，每期10道题，业务繁重的同志可以看看我分享的思路，不是最高效解决方案，只求互相提升。

第1题：整数转换

试题要求如下：

解答思路：

异或操作。

回答（C语言）：

int convertInteger(int A, int B){
    int res=0;

    unsigned int tmp = A^B;

    while(tmp){
        if(tmp&1==1){
            res=res+1;
        }
        
        tmp>>=1;
    }

    return res;
}

运行效率如下所示：

---

第2题：重复的子字符串

试题要求如下：

解答思路：

回答（C语言）：

bool repeatedSubstringPattern(char* s) {
    int n = strlen(s);

    for (int i = 1; i * 2 <= n; ++i) {
        if (n % i == 0) {
            bool match = true;

            for (int j = i; j < n; ++j) {
                if (s[j] != s[j - i]) {
                    match = false;
                    break;
                }
            }
            
            if (match) {
                return true;
            }
        }
    }

    return false;
}

运行效率如下所示：

---

第3题：范围求和2

试题要求如下：

解答思路：

这题最简单的做法就是去找所给二维矩阵的第一列了和第二列最小的数，因为数组每行的两个数都可以划分一个矩形，最后和最大的数，必定是共同的重叠部分，所以只需找数组每列的最小值，乘积为所求。

回答（C语言）：

int maxCount(int m, int n, int** ops, int opsSize, int* opsColSize){
    int min_c = m, min_r = n;

    for(int i = 0;i < opsSize;i++){
        if(ops[i][0] < min_c){
            min_c = ops[i][0];
        }
        if(ops[i][1] < min_r){
            min_r = ops[i][1];
        }
    }

    return min_c * min_r;
}

运行效率如下所示：

---

第4题：反转数位

试题要求如下：

回答（C语言）：

void toBit(int num, int *val) {
    int i = 0;
    while(num) {
        val[i] = num & 1;
        num >>= 1;
        i++;
    }
}

int reverseBits(int num){
    int val[32] = {0};
    toBit(num, val);
    
    int count = 0;
    int countPre = 0;
    int max = 0;
    for (int i = 0; i < 32; i++) {
        if (val[i] == 1) {
            count++;
        } 
        else {
            if (countPre + count + 1 > max) {
                max = countPre + count + 1;
            }
            countPre = count;
            count = 0;
        }
    }

    return max;
}

运行效率如下所示：

---

第5题：数字转换为十六进制

试题要求如下：

解答思路：

取余、除以16（0X0F），装入数组，再反转。

回答（C语言）：

char g_stack[16 + 1] = {0};
void swap(char *a, char *b) {char t = *a; *a = *b; *b = t; }

char * toHex(int num) {
    int top = -1;
    unsigned int n = num;
    char index[] = "0123456789abcdef";

    // 这里用do...while()而不是while()，能直接覆盖num为0的情况
    do {
        g_stack[++top] = index[n % 16];
        n /= 16;
    } while (n != 0);
    g_stack[top + 1] = '\0';

    int lo = 0, hi = top;

    while (lo < hi) {
        swap(&g_stack[lo++], &g_stack[hi--]);
    }
    
    return g_stack;
}

运行效率如下所示：

---

第6题：比较含退格的字符

试题要求如下：

解答思路：

采用双指针，遇到‘#’，下标减一，删除前一个字符；其他字符依次增加下标计数；得到新的字符串，然后就是字符串是否相同对比。

回答（C语言）：

int deletebackspace(char *str,int size){
    if(str==NULL||size==0){
        return 0;
    }

    int index = 0;

    for(int i=0;i<size;i++){
        if(str[i] != '#'){
            str[index++] = str[i];
        }
        else{
            if(index>0){
                index--;
            }
        }
    }

    return index;
}

bool backspaceCompare(char * S, char * T){
    int slen = deletebackspace(S,strlen(S));
    int tlen = deletebackspace(T,strlen(T));

    if(slen != tlen){
        return false;
    }
    else{
        for(int i=0;i<slen;i++){
            if(S[i] != T[i]){
                return false;
            }
        }
        
        return true;
    }
}

运行效率如下所示：

---

第7题：三个数的最大乘积

试题要求如下：

解答思路：

我们将数组进行升序排序，如果数组中所有的元素都是非负数，那么答案即为最后三个元素的乘积。

如果数组中出现了负数，那么我们还需要考虑乘积中包含负数的情况，显然选择最小的两个负数和最大的一个正数是最优的，即为前两个元素与最后一个元素的乘积。

回答（C语言）：

int Compare(const void* a, const void* b)
{
    return *(int*)a - *(int*)b;
}

int Max(int a, int b)
{
    return a > b ? a : b;
}

int maximumProduct(int* nums, int numsSize){
    qsort(nums, numsSize, sizeof(int), Compare);
    
    return Max(nums[numsSize - 1] * nums[numsSize -2] * nums[numsSize - 3], nums[numsSize - 1] * nums[0] * nums[1]);
}

运行效率如下所示：

---

第8题：珠玑妙算

试题要求如下：

回答（C语言）：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* masterMind(char* solution, char* guess, int* returnSize){
    returnSize[0] = 2;
    int dict[26] = {0}, *res = (int *)malloc (sizeof (int) * 2);
    res[0] = res[1] = 0;

    for (int i = 0; solution[i] != '\0'; ++i) {
        dict[solution[i] -'A']++;
        if (guess[i] == solution[i]) res[0]++;
    }

    for (int i = 0; solution[i] != '\0'; ++i) {
        if (dict[guess[i] - 'A']) {
            dict[guess[i] - 'A']--;
            res[1]++;
        }
    }
    
    res[1] -= res[0];
    return res;
}

运行效率如下所示：

---

第9题：旋转字符串

试题要求如下：

回答（C语言）：

bool rotateString(char * A, char * B){
    int len = strlen(A);

    if(strlen(B) != len) return false;
    if(strcmp(A, B) == 0) return true;

    for(int i = 0; i < len; i++) {
        if(A[0] == B[i]) {
            int j;
            
            for(j=0; j < len; j++) {
                if(j<i && A[j+len-i] != B[j]) {
                    break;
                }
                if(j >= i && A[j-i] != B[j]) {
                    break;
                }
            }

            if(j == len) {
                return true;
            }
        }
    }

    return false;
}

运行效率如下所示：

---

第10题：较大分组的位置

试题要求如下：

回答（C语言）：

/**
 * 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** largeGroupPositions(char * S, int* returnSize, int** returnColumnSizes){
    int size = 0;
    int len =strlen(S);

    if(len < 3){
        *returnSize = 0;
        ** returnColumnSizes = 0;
        return 0;
    }

    int ** res = (int **)malloc(len * sizeof(int *));
    for(int i=0;i<len;i++){
        res[i] = (int *)calloc(2,sizeof(int));
    }

    for(int i=0; i<len-2 ; i++){
        if( S[i] == S[i+1] && S[i] == S[i+2]){
            (*returnColumnSizes)[size] = 2;
            char temp = S[i];
            res[size][0]=i;
            i+=3;
            while(temp == S[i] && i<len) i++;
            res[size][1]=--i;                   //由于循环体内有i++,此处的S[i]已经是新值的起始点，为了一致，应退回1
            size++;   
        }
    }
    
    *returnSize = size;
    return res;
}

运行效率如下所示：