剑指offer(31-35)编程题

• 整数中1出现的次数（从1到n整数中1出现的次数）
• 把数组排成最小的数
• 丑数
• 第一个只出现一次的字符位置
• 数组中的逆序

31.求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数。

class Solution {
public:
    int NumberOf1Between1AndN_Solution(int n) {
        string str = std::to_string(n);
        int len = str.length();
        int first = str[] - '';
        if (len ==  && first == ) return ;
        if (len ==  && first > ) return ;;

        //最高为1
        int num1 = ;
        if (first > ) {
            num1 = pow(, len - );
        } else if(first == ){
            num1 = stoi(str.substr()) + ;
        }
        int num2 = first * (len - ) * pow(, len - );
        return num1 + num2 + NumberOf1Between1AndN_Solution(stoi(str.substr()));
    }
};

32.输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

class Solution {
public:
    static bool comp(const string& a, const string& b) {
        string ab = a + b;
        string ba = b + a;
        if(ab > ba) return false;
        return true;
    }
public:
    string PrintMinNumber(vector<int>& numbers) {
        vector<string> numStrs;
        for(size_t i=;i<numbers.size();i++){
            numStrs.push_back(to_string(numbers[i]));
        }
        sort(numStrs.begin(),numStrs.end(),comp);

        string res;
        for(int i=;i<numStrs.size();i++){
            res += numStrs[i];
        }
        return res;
    }
};

33把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

 class Solution {
 public:
     int GetUglyNumber_Solution(int index) {
         vector<int> uglyArray = { , , , ,  };
         if (index <= )
             return uglyArray[index - ];

         int m2, m3, m5;
         int n1 = ,n3 = ,n5 = ;
         int k = ;
         while (k <= index) {
             for (int i = n1; i < uglyArray.size(); i++) {
                 if ( * uglyArray[i] > uglyArray.back()) {
                     m2 =  * uglyArray[i];
                     n1 = i;
                     break;
                 }
             }
             for (int i = n3; i < uglyArray.size(); i++) {
                 if ( * uglyArray[i] > uglyArray.back()) {
                     m3 =  * uglyArray[i];
                     n3 = i;
                     break;
                 }
             }
             for (int i = n5; i < uglyArray.size(); i++) {
                 if ( * uglyArray[i] > uglyArray.back()) {
                     m5 =  * uglyArray[i];
                     n3 = i;
                     break;
                 }
             }
             uglyArray.push_back(min(min(m2,m3),m5));
             k++;
         }
         return uglyArray.back();
     }
 };

34.在一个字符串(1<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置。如果字符串为空,返回-1

 class Solution {
 public:
     int FirstNotRepeatingChar(string str) {
         int tableSize = ;
         int *hashTable = new int[tableSize];
         for (int i = ; i < ; i++) {
             hashTable[i] = ;
         }
         for (size_t i = ; i < str.size(); i++) {
             hashTable[static_cast<unsigned int>(str[i])]++;
         }

         for (size_t i = ; i < str.size(); i++) {
             if (hashTable[static_cast<unsigned int>(str[i])] == )
                 return i;
         }

         delete[] hashTable;
         return -;
     }
 };

35.在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007

 class Solution {
 private:
     int InversePairs(vector<int>&data, int left, int right) {
         if (left == right) return ;
         int mid = left + (right - left) / ;
         int leftCount = InversePairs(data, left, mid);
         int rightCount = InversePairs(data, mid + , right);
         int mergeCount = merge(data, left, mid, right);
         return (leftCount + rightCount + mergeCount)%;
     }

     int merge(vector<int>& data, int left, int mid, int right) {
         int* temp = new int[right - left + ];
         int p = mid;
         int q = right;
         int count = ;
         int k = right - left;
         while (p >= left && q > mid) {
             if (data[p] > data[q]) {
                 count = (count + q - mid)%;
                 temp[k--] = data[p--];
             } else {
                 temp[k--] = data[q--];
             }
         }
         while (p >= left) {
             temp[k--] = data[p--];
         }
         while (q > mid) {
             temp[k--] = data[q--];
         }
         for (int i = ; i <= right - left; i++) {
             data[left + i] = temp[i];
         }
         delete[] temp;
         return count;
     }
 public:
     int InversePairs(vector<int> data) {
         int n = data.size();
         if (n < )
             return -;
         return InversePairs(data, , n - );
     }
 };