字符串

 

1.请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

思路：类似数组的双索引。

class Solution {
public:
	void replaceSpace(char *str,int length) {
        int oldstringLen = 0;
        int blacknumber = 0;
        for(; str[oldstringLen] != '\0'; oldstringLen++){
            if(str[oldstringLen] == ' ') blacknumber++;
        }
        int newstringLen = oldstringLen + blacknumber * 2;
        if(newstringLen > length) return;
        str[newstringLen] = '\0';
        int point1 = oldstringLen - 1;
        int point2 = newstringLen - 1;
        while(point1 >= 0 && point1 != point2){
            if(str[point1] == ' '){
                str[point2--] = '0';
                str[point2--] = '2';
                str[point2--] = '%';
            }else{
                str[point2--] = str[point1];
            }
            point1--;
        }
        return;
	}
};

2.请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配

思路：使用递归的思想

1）*pattern == '*' 时，

匹配0个字符：matchCore(str, pattern+2);

匹配1个字符：matchCore(str+1, pattern+2)；

匹配多个字符：matchCore(str，pattern+2);

2) *pattern == *str || *pattern = '.' && *str!='\0': matchCore(str+1, pattern+1)

class Solution {
public:
    bool match(char* str, char* pattern)
    {
        if(str == NULL || pattern == NULL) return false;
        return matchCore(str, pattern);
    }
    
    bool matchCore(char* str, char* pattern)
    {
        if(*str == '\0' && *pattern == '\0') return true;
        if(*str != '\0' && *pattern == '\0') return false;
        
        if(*(pattern + 1) == '*'){
            if((*str == *pattern) || (*pattern == '.' && *str != '\0')){
                return matchCore(str+1, pattern) || matchCore(str+1, pattern+2);
            }else{
                return matchCore(str, pattern+2);
            }
        }else if(*pattern == '.' && *str!= '\0'){
            return matchCore(str+1, pattern+1);
        }else if(*str == *pattern){
            return matchCore(str+1, pattern+1);
        }else if(*str == '\0' && *pattern != '\0') {
            if(*(pattern - 1) == '*' && *pattern == *(pattern - 2) && *(str-1) == *(pattern)) return true;
        }
        return false;
    }
};

3.汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

class Solution {
public:
    string LeftRotateString(string str, int n) {
        int len = str.size();
        string result;
        if(len < 1) return result;
        n = n % len;
        result += str.substr(n, len-n);
        result += str.substr(0, n);
        return result;
    }
};

4.牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

class Solution {
public:
    string ReverseSentence(string str) {
        string res;
        if(str.size() == 0) return res;
        string tmp;
        for(int i = 0; i < str.size(); i++){  
            if(str[i] == ' '){
                res = " " + tmp + res;  
                tmp = "";
            }else{
                tmp += str[i];
            }     
        }
        if(tmp.size()) {
            res = tmp + res;
        }
        return res;
    }
};

5.将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。

class Solution {
public:
    int StrToInt(string str) {
        int n = str.size();
        if(n == 0) return 0;
        if(n == 1 && !isNumChar(str[0])) return 0;
        char* charArr = new char[n];
        int index = 0;
        char sign = '+';
        for(int i = 0; i < n; i++){
            if(i == 0 && (str[i] == '+' || str[i] == '-')){
                sign = str[i];
                continue;
            }
            if(isNumChar(str[i])){
                charArr[index++] = str[i];
            }else{
                return 0;
            }
        }
        int res = 0;
        for(int i = 0; i < index; i++){
            res = 10 * res + (charArr[i] - '0');
        }
        return sign == '-' ? 0 - res : res;
    }
    
    bool isNumChar(char c){
        if(c >= '0' && c <= '9')
            return true;
        else
            return false;
    }
};

1.LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

思路：考虑不同的测试用例：

0，2，3，6，8；

1，0，0，1，0；

1，2，3，0，0；

1，2，3，8，0.

class Solution {
public:
    bool IsContinuous( vector<int> numbers ) {
        sort(numbers.begin(), numbers.end());
        int n = numbers.size();
        if(n == 0) return false;
        int count = 0;
        if(numbers[0] == 0) count++;
        for(int i = 1; i < n; i++){
            if(numbers[i] == 0) count++;
            else if(numbers[i-1] != 0){
                int sub = numbers[i] - numbers[i-1] - 1;
                if(sub < 0) return false;
                count = count - sub;
            }
            if(count < 0) return false;
        }
        
        if(count >= 0) return true;
        else return false;
    }
};

2.输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

思路：使用位运算，将1每次左移，与数字n进行&运算，如果成功，则返回1.

class Solution {
public:
     int  NumberOf1(int n) {
         int index = 1;
         int res = 0;
         while(index != 0){
             if((n&index) != 0) res++;
             index = index<<1;
         }
         return res;
     }
};

3.给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

思路：利用递归的思想，为节省空间，可以使用动态规划的方法。如果exponent > 0，则取base的次方；如果exponent < 0，则取1/base的次方。

class Solution {
public:
    double Power(double base, int exponent) {
        if(exponent >= 0){
            vector<double> res = vector<double>(exponent+1, 1);
            for(int i = 1; i < exponent + 1; i++){
                res[i] = res[i-1] * base;
            }
            return res[exponent];
        }else{
            exponent = abs(exponent);
            vector<double> res = vector<double>(exponent+1, 1);
            for(int i = 1; i < exponent + 1; i++){
                res[i] = res[i-1] * 1/ base;
            }
            return res[exponent];
        }
    }
};