class Solution {

public:

    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {

        unordered_map<int, int> dict;

        vector<int> res;

        for(int i = ; i < (int)nums1.size(); i++) dict[nums1[i]]++;

        for(int i = ; i < (int)nums2.size(); i++)

            if(dict.find(nums2[i]) != dict.end() && --dict[nums2[i]] >= ) res.push_back(nums2[i]);

        return res;

    }

};

class Solution {

public:

    string reverseVowels(string s) {

        int i = , j = s.size() - ;

        while (i < j) {

            i = s.find_first_of("aeiouAEIOU", i);

            j = s.find_last_of("aeiouAEIOU", j);

            if (i < j) {

                swap(s[i++], s[j--]);

            }

        }

        return s;

    }

};

Brute force solution, traverse string s  times. First time, store counts of every character into the hash table, second time, find the first character that appears only once.

//遍历两次string

class Solution {

public:

    int firstUniqChar(string s) {

        unordered_map<char, int> m;

        for (auto &c : s) {

            m[c]++;

        }

        for (int i = ; i < s.size(); i++) {

            if (m[s[i]] == ) return i;

        }

        return -;

    }

};

if the string is extremely long, we wouldn't want to traverse it twice, so instead only storing just counts of a char, we also store the index, and then traverse the hash table.

//遍历一次string和一次map

class Solution {

public:

    int firstUniqChar(string s) {

        unordered_map<char, pair<int, int>> m;

        int idx = s.size();

        for (int i = ; i < s.size(); i++) {

            m[s[i]].first++;

            m[s[i]].second = i;

        }

        for (auto &p : m) {

            if (p.second.first == ) idx = min(idx, p.second.second);

        }

        return idx == s.size() ? - : idx;

    }

};

Python:

def longestPalindrome(self, s):

    odds = sum(v &  for v in collections.Counter(s).values())

    return len(s) - odds + bool(odds)

C++:

int longestPalindrome(string s) {

    int odds = ;

    for (char c='A'; c<='z'; c++)

        odds += count(s.begin(), s.end(), c) & ; //如果是奇数则加1，偶数不加

    return s.size() - odds + (odds > );

}

class Solution {

public:

    vector<string> fizzBuzz(int n) {

        vector<string> ret_vec(n);

        for(int i=; i<=n; ++i)

        {

            if( == i%)

            {

                ret_vec[i-] += "Fizz";

            }

            if( == i%)

            {

                ret_vec[i-] += "Buzz";

            }

            if(ret_vec[i-].empty())

            {

                ret_vec[i-] += to_string(i);

            }

        }

        return ret_vec;

    }

};

class Solution {

public:

    int thirdMax(vector<int>& nums) {

    set<int> top3;

    for (int num : nums) {

        top3.insert(num);

        if (top3.size() > )

            top3.erase(top3.begin());

    }

    return top3.size() ==  ? *top3.begin() : *top3.rbegin();

}

};

class Solution {

public:

string addStrings(string num1, string num2) {

    int i = num1.size() - ;

    int j = num2.size() - ;

    int carry = ;

    string res = "";

    while(i>= || j>= || carry){

        long sum = ;

        if(i >= ){sum += (num1[i] - '');i--;}

        if(j >= ){sum += (num2[j] - '');j--;}

        sum += carry;

        carry = sum / ;

        sum = sum % ;

        res =  res + to_string(sum);

    }

    reverse(res.begin(), res.end());

    return res;

}

};

class Solution {

public:

    int pathSum(TreeNode* root, int sum) {

        if(!root) return ;

        return dfs(root,,sum)+pathSum(root->left,sum)+pathSum(root->right,sum);

    }

    int dfs(TreeNode* root,int pre,int sum)

    {

       if(!root) return ;

       int cur=pre+root->val;

       return (cur==sum)+dfs(root->left,cur,sum)+dfs(root->right,cur,sum);

    }

};

class Solution {

public:

    vector<int> findAnagrams(string s, string p) {

        vector<int> pv(,), sv(,), res;

        if(s.size() < p.size())

           return res;

        for(int i = ; i < p.size(); ++i)

        {

            ++pv[p[i]];

            ++sv[s[i]];

        }

        if(pv == sv)

           res.push_back();

        for(int i = p.size(); i < s.size(); ++i)

        {

            ++sv[s[i]];

            --sv[s[i-p.size()]];

            if(pv == sv)

               res.push_back(i-p.size()+);

        }

        return res;

    }

};