For example, in alice@leetcode.com, alice is the local name, and leetcode.com is the domain name.

Besides lowercase letters, these emails may contain '.'s or '+'s.

If you add periods ('.') between some characters in the local name part of an email address, mail sent there will be forwarded to the same address without dots in the local name.  For example, "alice.z@leetcode.com" and "alicez@leetcode.com" forward to the same email address.  (Note that this rule does not apply for domain names.)

If you add a plus ('+') in the local name, everything after the first plus sign will be ignored. This allows certain emails to be filtered, for example m.y+name@email.com will be forwarded to my@email.com.  (Again, this rule does not apply for domain names.)

It is possible to use both of these rules at the same time.

Given a list of emails, we send one email to each address in the list.  How many different addresses actually receive mails?

Example 1:

Input: ["test.email+alex@leetcode.com","test.e.mail+bob.cathy@leetcode.com","testemail+david@lee.tcode.com"]
Output: 2
Explanation: "testemail@leetcode.com" and "testemail@lee.tcode.com" actually receive mails

Note:

• 1 <= emails[i].length <= 100
• 1 <= emails.length <= 100
• Each emails[i] contains exactly one '@' character.

Solution: 

Time complexity: O(n*l)
Space complexity: O(n*l)

// Author: Huahua, 24 ms
class Solution {
public:
  int numUniqueEmails(vector<string>& emails) {
    unordered_set<string> s;
    for (const string& email : emails) {
      string e;
      bool at = false;
      bool plus = false;
      for (char c : email) {
        if (c == '.') {
          if (!at) continue;
        } else if (c == '@') {
          at = true;          
        } else if (c == '+') {
          if (!at) {
            plus = true;
            continue;
          }
        }        
        if (!at && plus) continue;
        e += c;        
      }      
      s.insert(std::move(e));
    }
    return s.size();
  }
};

The post 花花酱 LeetCode 929. Unique Email Addresses appeared first on Huahua's Tech Road.

n a deck of cards, each card has an integer written on it.

Return true if and only if you can choose X >= 2 such that it is possible to split the entire deck into 1 or more groups of cards, where:

• Each group has exactly X cards.
• All the cards in each group have the same integer.

Example 1:

Input: [1,2,3,4,4,3,2,1]
Output: true
Explanation: Possible partition [1,1],[2,2],[3,3],[4,4]

Input: [1,1,1,2,2,2,3,3]
Output: false
Explanation: No possible partition.

Input: [1]
Output: false
Explanation: No possible partition.

Input: [1,1]
Output: true
Explanation: Possible partition [1,1]

Input: [1,1,2,2,2,2]
Output: true
Explanation: Possible partition [1,1],[2,2],[2,2]

// Author: Huahua, 16 ms
class Solution {
public:
  bool hasGroupsSizeX(vector<int>& deck) {
    unordered_map<int, int> counts;
    for (int card : deck) ++counts[card];
    for (int i = 2; i <= deck.size(); ++i) {
      if (deck.size() % i) continue;
      bool ok = true;
      for (const auto& pair : counts)
        if (pair.second % i) {
          ok = false;
          break;
        }
      if (ok) return true;
    }
    return false;
  }
};

// Author: Huahua, 16 ms
class Solution {
public:
  bool hasGroupsSizeX(vector<int>& deck) {
    unordered_map<int, int> counts;
    for (int card : deck) ++counts[card];
    int X = deck.size();
    for (const auto& p : counts) 
      X = __gcd(X, p.second);
    return X >= 2;
  }
};

// Author: Somebody
class Solution {
    public boolean hasGroupsSizeX(int[] deck) {
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i=0; i<deck.length; i++) {
            int curr = deck[i];
            if (map.containsKey(curr)) {
                map.put(curr, map.get(curr) + 1);
            } else {
                map.put(curr, 1);
            }
        }
        
        // O(nLogn)
        int gcd = 0;
        for(Integer key: map.keySet()) {
            gcd = findGCDOfTwoNumbers(map.get(key), gcd);
        }
        
        return gcd >= 2;      
    }
    
    // O(Log n)
    public static int findGCDOfTwoNumbers (int a, int b) {
        if (b == 0) {
            return a;
        }
        return findGCDOfTwoNumbers(b, a%b);
    }
}

The post 花花酱 LeetCode 914. X of a Kind in a Deck of Cards appeared first on Huahua's Tech Road.