万人千题计划-33

今日题解

七进制数

思路：除 k 取余法

class Solution {
public:
    string convertToBase7(int num) {
        string res = "";
        int flag = 0;//判断数字的正负
        if(num==0) return "0";
        if(num < 0)
        {
            flag = 1;
            num = -num;
        }
        while(num > 0)
        {
            res += to_string(num%7);
            num /= 7;
        }
        if(flag) res += "-";
        reverse(res.begin(), res.end());
        return res;
    }
};

k进制表示下的各位数字总和

思路：也是除 k 取余法，但比第一题简单

class Solution {
public:
    int sumBase(int n, int k) {
        int res = 0;
        while(n){
            res += n%k;
            n /= k;
        }
        return res;
    }
};

数字转换成十六进制数

思路：用字符串模拟出一个哈希表：数字0 ~ 9对应字符 ‘0’ ~ ‘9’, 而10 ~ 15对应的字符是 ‘a’ ~ ‘f’

class Solution {
public:
    string toHex(int num) {
        string res;
        long N = num; 
        if (N == 0) return "0";
        string dict = "0123456789abcdef";
        if (N < 0) N = N + 0x100000000; //负数的补码
        while (N > 0)
        {
            long lastDigit = N % 16;
            N /= 16;
            res = dict[lastDigit] + res;
        }
        return res;
    }
};

统计最大组的数目

思路：用map保存 1 ~ n 数位和相同的数的个数,遍历map找出其中拥有最大个数的组的数量

class Solution {
public:
    int countLargestGroup(int n) {
        unordered_map<int, int> map;
        int maxValue = 0;
        for (int i = 1; i <= n; ++i) {
            int key = 0, i0 = i;
            while (i0) {
                key += i0 % 10;
                i0 /= 10;
            }
            ++map[key];
            maxValue = max(maxValue, map[key]);
        }
        int count = 0;
        for (auto& m: map) {
            if (m.second == maxValue) {
                ++count;
            }
        }
        return count;
    }
};

颜色分类

思路：第一种是使用库函数，我就不说了，我们说说单指针＋两次遍历的方法
第一次遍历：把数组中所有的 0 都交换到数组的前面，同时指针也向后移一位；
第二次遍历：再上一层遍历后的基础上，把所有的 1 交换到头部的 0 的后面

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int cur = 0;
        for(int i=0; i<nums.size(); ++i) {
            if(nums[i] == 0) {
                swap(nums[i], nums[cur]);
                ++cur;
            }
        }

        for(int i=cur; i<nums.size(); ++i) {
            if(nums[i] == 1) {
                swap(nums[i], nums[cur]);
                ++cur;
            }
        }
    }
};

第二种方法：一次遍历＋双指针
思路：遍历到当前指针所指的值是 0 时，交换当前指针和左指针的位置，当前指针和左指针都往右移一位；
当遍历到当前指针所指的值为 1 时，当前指针右移一位即可；
遍历到当前指针所指的值为 2 时，交换当前指针和右指针的位置，同时右指针左移一位

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int left = 0, right = nums.size()-1, cur = 0;
        while(cur <= right) {
            if(nums[cur] == 0) {
                swap(nums[cur++], nums[left++]);
            }else if(nums[cur] == 1) {
                cur++;
            }else swap(nums[cur], nums[right--]);
        }
    }
};

至少是其他数字两倍的最大数

思路：找到第二大的数和第一大的数，让最大数和第二大的数进行比较

class Solution {
public:
    int dominantIndex(vector<int>& nums) {
        int size = nums.size();
        int max = 0, index = 0, lower = 1;
        for(int i=0; i<nums.size(); ++i) {
            if(nums[i] > max) {
                lower = max;
                max = nums[i];
                index = i;
            }else if(nums[i] > lower) {
                lower = nums[i];
            }
        }
        return max >= (lower*2) ? index : -1;
    }
};