string刷題筆記

942. 增減字符串匹配

給定只含 “I”（增大）或 “D”（減小）的字符串 S ，令 N = S.length。

返回 [0, 1, …, N] 的任意排列 A 使得對於所有 i = 0, …, N-1，都有：

如果 S[i] == “I”，那麼 A[i] < A[i+1]
如果 S[i] == “D”，那麼 A[i] > A[i+1]

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/di-string-match

class Solution {
public:
    vector<int> diStringMatch(string S) {
	int i = S.size();
	int contb = 0, conte = i;
	vector<int> num;
	for (int j = 0; j <=i; ++j)
	{
		if (S[j] == 'I')
			num.push_back(contb++);
		if (S[j] == 'D')
			num.push_back(conte--);
	}

	num.push_back(conte);

	return num;
}
};

557. 反轉字符串中的單詞 III

給定一個字符串，你需要反轉字符串中每個單詞的字符順序，同時仍保留空格和單詞的初始順序。

示例 1:

輸入: “Let’s take LeetCode contest”
輸出: “s’teL ekat edoCteeL tsetnoc”

class Solution {
public:
    string reverseWords(string s) {
        int begin =0;
        int end;
        for(int i=0;i<= s.size();i++)
        {
            if(s[i] ==' ' || s[i] =='\0')
            {
                for(end = i-1;begin < end;begin++,end--)
                {
                    swap(s[begin],s[end]);
                }
                begin = i+1;
            }
            
        }
            return s;
    }
};

1047.給出由小寫字母組成的字符串 S，重複項刪除操作會選擇兩個相鄰且相同的字母，並刪除它們。

在 S 上反覆執行重複項刪除操作，直到無法繼續刪除。

在完成所有重複項刪除操作後返回最終的字符串。答案保證唯一。

示例：

輸入：“abbaca”
輸出：“ca”
解釋：
例如，在 “abbaca” 中，我們可以刪除 “bb” 由於兩字母相鄰且相同，這是此時唯一可以執行刪除操作的重複項。之後我們得到字符串 “aaca”，其中又只有 “aa” 可以執行重複項刪除操作，所以最後的字符串爲 “ca”。

class Solution {
public:
    string removeDuplicates(string S) 
    {
        int flag = 1;
        while(flag == 1)
        {
            flag = 0;
           for(int i=0;i< S.size();i++)
        {
            if(i!= S.size()-1)
            {
                if(S[i] == S[i+1])
                {
                    S.erase(i,2);
                    flag = 1;
                    
                }
            }
        } 
        }
        
        return S;
    }
};

844. 比較含退格的字符串
     給定 S 和 T 兩個字符串，當它們分別被輸入到空白的文本編輯器後，判斷二者是否相等，並返回結果。 # 代表退格字符

class Solution {
public:
    bool backspaceCompare(string S, string T) {
        vector<char> T1,S1;
        for(auto& e: S)
        {
            if(e != '#')
                S1.push_back(e);
            if(e == '#'&& S1.empty() != 1)
                S1.pop_back();
        }
        for(auto& e: T)
        {
            if(e != '#')
                T1.push_back(e);
            if(e == '#' && T1.empty() != 1)
                T1.pop_back();
        }
        if(T1 == S1)
            return true;
        else
            return false;
    }
};

415. 字符串相加
     給定兩個字符串形式的非負整數 num1 和num2 ，計算它們的和。

注意：

num1 和num2 的長度都小於 5100.
num1 和num2 都只包含數字 0-9.
num1 和num2 都不包含任何前導零。
你不能使用任何內建 BigInteger 庫， 也不能直接將輸入的字符串轉換爲整數形式。

class Solution {
public:
    string addStrings(string num1, string num2) 
    {
        int count = 0;
        string num3;
        int i = num1.size()-1;
        int j = num2.size()-1;
       while(i>=0||j>=0||count!=0)
       {
           if(i >=0)
               count += num1[i--]-'0';
           if(j>=0)
               count += num2[j--]-'0';
           num3 += to_string(count%10);
           count /=10;
       }
        reverse(num3.begin(),num3.end());
        return num3;
    }
};

567. 字符串的排列
     給定兩個字符串 s1 和 s2，寫一個函數來判斷 s2 是否包含 s1 的排列。

換句話說，第一個字符串的排列之一是第二個字符串的子串。

思路分析：利用滑窗法來解決，可以先用兩個vector儲存前s1.size（）的元素的頻率，如果相同返回真，否則，向後移動，再根據窗口的左閉右開的性質，最後再判斷一次。

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
       if(s1.size() > s2.size())
           return false;
        vector<int> m1(26,0);
        vector<int> m2(26,0);
        
        int windosize = s1.size();
        
        for(int i=0;i<s1.size();i++)
        {
            m1[s1[i] - 'a']++;
            m2[s2[i] - 'a']++;
        }
        for(int i=windosize;i<s2.size();i++)
        {
            if(m1 == m2)
                return true;
            m2[s2[i-windosize]-'a']--;
            m2[s2[i]-'a']++;            
        }
        if(m1 == m2)
            return true;
        return false;
    }
};