Weekly Contest 80

Most Common Word

Given a paragraph and a list of banned words, return the most frequent word that is not in the list of banned words.  It is guaranteed there is at least one word that isn't banned, and that the answer is unique.

Words in the list of banned words are given in lowercase, and free of punctuation.  Words in the paragraph are not case sensitive.  The answer is in lowercase.

Example:
Input: 
paragraph = "Bob hit a ball, the hit BALL flew far after it was hit."
banned = ["hit"]
Output: "ball"
Explanation: 
"hit" occurs 3 times, but it is a banned word.
"ball" occurs twice (and no other word does), so it is the most frequent non-banned word in the paragraph. 
Note that words in the paragraph are not case sensitive,
that punctuation is ignored (even if adjacent to words, such as "ball,"), 
and that "hit" isn't the answer even though it occurs more because it is banned.

 

Note:

• 1 <= paragraph.length <= 1000.
• 1 <= banned.length <= 100.
• 1 <= banned[i].length <= 10.
• The answer is unique, and written in lowercase (even if its occurrences in paragraph may have uppercase symbols, and even if it is a proper noun.)
• paragraph only consists of letters, spaces, or the punctuation symbols !?',;.
• Different words in paragraph are always separated by a space.
• There are no hyphens or hyphenated words.
• Words only consist of letters, never apostrophes or other punctuation symbols.

查看除banned里字符串外频率最多的字符串。

class Solution {
public:
    string mostCommonWord(string paragraph, vector<string>& banned) {
        for(int i = 0; i < paragraph.length(); i ++) {
            if(!isalpha(paragraph[i])) paragraph[i] = ' ';
            if(paragraph[i] >= 'A' && paragraph[i] <= 'Z') paragraph[i] += 32;
        }
        map<string,int> mp;
        string s, ss;
        istringstream sss(paragraph);
        while(sss >> s) {
        //    cout << s << endl;
            bool flag = false;
            for(int i = 0; i < banned.size(); i ++) {
                if(s == banned[i]) flag = true;
            }
            if(!flag) {
                mp[s]++;
            }
        }
        map<string,int>::iterator it = mp.begin();
        int MAX = 0;
        for(; it != mp.end(); it++) {
            if((*it).second > MAX) {
                MAX = (*it).second;
                ss = (*it).first;
            }
        }
        for(int i = 0; i < ss.length(); i ++) {
            if(ss[i] >= 'A' && ss[i] <= 'Z') ss[i] += 32;
        }
        return ss;
    }
};

Linked List Components

We are given head, the head node of a linked list containing unique integer values.

We are also given the list G, a subset of the values in the linked list.

Return the number of connected components in G, where two values are connected if they appear consecutively in the linked list.

Example 1:

Input: 
head: 0->1->2->3
G = [0, 1, 3]
Output: 2
Explanation: 
0 and 1 are connected, so [0, 1] and [3] are the two connected components.

Example 2:

Input: 
head: 0->1->2->3->4
G = [0, 3, 1, 4]
Output: 2
Explanation: 
0 and 1 are connected, 3 and 4 are connected, so [0, 1] and [3, 4] are the two connected components.

Note:

• If N is the length of the linked list given by head, 1 <= N <= 10000.
• The value of each node in the linked list will be in the range [0, N - 1].
• 1 <= G.length <= 10000.
• G is a subset of all values in the linked list.

求G被分成一个部分。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int numComponents(ListNode* head, vector<int>& G) {
        bool vis[10010];
        memset(vis,0,sizeof(vis));
        for(int i = 0; i < G.size(); i ++) {
            vis[G[i]] = true;
        }
        int ans = 0, pre, flag = 0;
        ListNode *p;
        p = head;
        while(p) {
            if(!flag &&vis[p->val]) {
                ans++;
            } 
            if(!vis[p->val]) flag = false;
            else flag = true;
            p = p->next;
        }
        return ans;
    }
};

Ambiguous Coordinates

We had some 2-dimensional coordinates, like "(1, 3)" or "(2, 0.5)".  Then, we removed all commas, decimal points, and spaces, and ended up with the string S.  Return a list of strings representing all possibilities for what our original coordinates could have been.

Our original representation never had extraneous zeroes, so we never started with numbers like "00", "0.0", "0.00", "1.0", "001", "00.01", or any other number that can be represented with less digits.  Also, a decimal point within a number never occurs without at least one digit occuring before it, so we never started with numbers like ".1".

The final answer list can be returned in any order.  Also note that all coordinates in the final answer have exactly one space between them (occurring after the comma.)

Example 1:
Input: "(123)"
Output: ["(1, 23)", "(12, 3)", "(1.2, 3)", "(1, 2.3)"]

Example 2:
Input: "(00011)"
Output:  ["(0.001, 1)", "(0, 0.011)"]
Explanation: 
0.0, 00, 0001 or 00.01 are not allowed.

Example 3:
Input: "(0123)"
Output: ["(0, 123)", "(0, 12.3)", "(0, 1.23)", "(0.1, 23)", "(0.1, 2.3)", "(0.12, 3)"]

Example 4:
Input: "(100)"
Output: [(10, 0)]
Explanation: 
1.0 is not allowed.

 

Note:

• 4 <= S.length <= 12.
• S[0] = "(", S[S.length - 1] = ")", and the other elements in S are digits.

模拟题，小数点前不能出现超过两个零，小数点后最后不能出现0

class Solution {
public:
    vector<string> ambiguousCoordinates(string S) {
        vector<string> vs, vs1, vs2;
        for(int i = 1; i < S.length()-2; i ++) {
            string s,ss;
            s = S.substr(1,i);
            ss = S.substr(i+1,S.length()-i-2);
            if(s.length() == 1) vs1.push_back(s);
            else{
                for(int j = 1; j <= s.length(); j ++) {
                    string s1, s2;
                    s1 = s.substr(0,j);
                    s2 = s.substr(j,s.length());
                    if(s1.length()>=2&&s1[0]=='0')continue;
                    if(s2.length()>=2&&s2[s2.length()-1]=='0')continue;
                    if(j == s.length()) {
                        vs1.push_back(s1);
                        continue;
                    }
                    int ans = 0;
                    for(int k = 0; k < s2.length(); k ++) {
                        if(s2[k] == '0') ans++;
                    }
                    if(ans == s2.length()) continue;
                    vs1.push_back(s1+"."+s2);
                }
            }
            if(ss.length() == 1) vs2.push_back(ss);
            else{
                for(int j = 1; j <= ss.length(); j ++) {
                    string ss1, ss2;
                    ss1 = ss.substr(0,j);
                    ss2 = ss.substr(j,ss.length());
                    if(ss1.length()>=2&&ss1[0]=='0')continue;
                    if(ss2.length()>=2&&ss2[ss2.length()-1]=='0')continue;
                    if(j == ss.length()) {
                        vs2.push_back(ss1);
                        continue;
                    }
                    int ans = 0;
                    for(int k = 0; k < ss2.length(); k ++) {
                        if(ss2[k] == '0') ans++;
                    }
                    if(ans == ss2.length()) continue;
                    vs2.push_back(ss1+"."+ss2);
                }
            }
            //cout << s << ' ' << ss << endl;
        }
        for(int i = 0; i < vs1.size(); i ++) {
            for(int j = 0; j < vs2.size(); j ++) {
                int ans1 = 0;
                if(vs1[i].find(".") != string::npos) ans1 = 1;
                if(vs2[j].find(".") !=  string::npos) ans1++;
                if(vs1[i].length()+vs2[j].length() == S.length()-2+ans1) {
                    vs.push_back("("+vs1[i]+", "+vs2[j]+")");    
                    //cout << "("+vs1[i]+", "+vs2[j]+")" << endl;
                }
            }
        }
        return vs;
    }
};