1122. 陣列的相對排序

題解: 自定義排序

vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
    unordered_map<int, int> rank;
    for (int i = 0; i < arr2.size(); ++i) rank[arr2[i]] = i;
    sort(arr1.begin(), arr1.end(), [&](int x, int y) {
        if (rank.count(x)) 
            return rank.count(y) ? rank[x] < rank[y] : true;
        else 
            return rank.count(y) ? false : x < y;
    });
    return arr1;
}
 

//自定義元組進行排序:
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        unordered_map<int, int> rank;
        for (int i = 0; i < arr2.size(); ++i) {
            rank[arr2[i]] = i;
        }
        auto mycmp = [&](int x) -> pair<int, int> {
            return rank.count(x) ? pair{0, rank[x]} : pair{1, x};
        };
        sort(arr1.begin(), arr1.end(), [&](int x, int y) {
            return mycmp(x) < mycmp(y);
        });
        return arr1;
    }
};
 

//自己: 模擬
vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
    unordered_map<int,int> um;
    for(auto i:arr1) um[i]++;
    vector<int> res;
    for(auto i:arr2){
        int n = um[i];
        while(n--)
            res.push_back(i);
        um.erase(i);
    }
    int n = res.size();
    for(auto [key,val]:um){
        for(int i = 0;i<val;i++){
            res.push_back(key); 
        }
    }
    sort(res.begin()+n,res.end());
    return res;
}
 

292. Nim 遊戲

程式碼就一行: bool canWinNim(int n) {return n%4;}

其實還給了一個技巧, 就是說 我們可以看到: 不管>4是什麼, 我作為後手總能給他搞到 4的倍數去.

canwin[1] = canwin[2] = canwin[3] = true; 
canwin[4-n] = !canwin[n-1] || !canwin[n-2] || !canwin[n-3]; 如果這三步都贏不了 就輸了.

520. 檢測大寫字母

'a' > 'A'

'A' : 0100 0001

'a': 0110 0001

我自己模擬很容易出現模擬不清晰的情況.

還有儘量用 islower和 isupper.

bool detectCapitalUse(string word) {
    // 若第 1 個字母為小寫，則需額外判斷第 2 個字母是否為小寫
    if (word.size() >= 2 && islower(word[0]) && isupper(word[1])) {
        return false;
    }
    // 無論第 1 個字母是否大寫，其他字母必須與第 2 個字母的大小寫相同
    for (int i = 2; i < word.size(); ++i) {
        if (islower(word[i]) ^ islower(word[1])) {
            return false;
        }
    }
    return true;
}
作者：LeetCode-Solution

bool detectCapitalUse(string word) {
    if(word.size()==1) return true;
    bool capi = word[0]<'a';
    bool capi2= word[1]<'a';
    if(!capi && capi2) return false;
    for(int i = 2;i<word.size();i++){
        if(word[i]<'a') {
            if(!capi2 || !capi) return false;
        }else{
            if(capi2) return false;
        }
    }
    return true;
}

168. Excel表列名稱

這個題有點繞... 不過因為是在[1,26]範圍內 進行26進位制轉換的, 所以每次轉換前先n--

string convertToTitle(int n) {
    string res = "";
    while(n){
        n--; // 這個很重要 要不然會出現 A@Y 等錯誤...
        res+= n%26+'A';
        n/=26;
    }
    reverse(res.begin(), res.end());
    return res;
}

1005. K 次取反後最大化的陣列和

非常的繞..

int largestSumAfterKNegations(vector<int>& nums, int k) {
    sort(nums.begin(),nums.end());
    int neg = 0;
    for(int i = 0;i<nums.size();i++) if(nums[i]<0) neg++;
    for(int i = 0;i<k && i<neg;i++){
        nums[i] = -nums[i];
    } 
    int sum = accumulate(nums.begin(),nums.end(),0);
    if(k>neg && (k-neg)%2 == 1){
        sum -=  2*(*min_element(nums.begin(), nums.end()));
    }
    return sum;
}

459. 重複的子字串

為什麼成立呢? 如果重複, 一定可以通過移位和換行得來的. 這樣子2倍的字串, 一定包含了這些, 所以可行.

//KMP 做法, 非常的簡潔 O(3n)
public boolean repeatedSubstringPattern(String s) {
    String str = s + s;
    return str.substring(1, str.length() - 1).contains(s);
}

1013. 將陣列分成和相等的三個部分

模擬題, 記得最後是 return l+1<r 因為我們需要把整個區間分成3段.

1446. 連續字元

    int maxPower(string s) {
        char pre = 1; 
        int precnt = 0;
        int res = 1;
        // 尋找連續的常用程式碼...
        for(auto c:s){
            if(c==pre){
                precnt++;
                res = max(res,precnt);
            }else pre=c, precnt = 1;
        }
        return res; 
    }

1078. Bigram 分詞

儘量自己實現一個python的.split(' ')函式吧..

vector<string> split(string s){
    vector<string> vs;
    int l = 0;
    for(int i = 0;i<s.size();i++){
        if(s[i] == ' '){
            vs.push_back(s.substr(l,i-l));
            l = i+1;
        }
    }
    if(l<s.size()) vs.push_back(s.substr(l,s.size()-l));
    return vs;
}