The special characters and their entities for HTML are:

• Quotation Mark: the entity is " and symbol character is ".
• Single Quote Mark: the entity is ' and symbol character is '.
• Ampersand: the entity is & and symbol character is &.
• Greater Than Sign: the entity is > and symbol character is >.
• Less Than Sign: the entity is < and symbol character is <.
• Slash: the entity is ⁄ and symbol character is /.

Given the input text string to the HTML parser, you have to implement the entity parser.

Return the text after replacing the entities by the special characters.

Example 1:

Input: text = "& is an HTML entity but &ambassador; is not."
Output: "& is an HTML entity but &ambassador; is not."
Explanation: The parser will replace the & entity by &

Example 2:

Input: text = "and I quote: "...""
Output: "and I quote: \"...\""

Example 3:

Input: text = "Stay home! Practice on Leetcode :)"
Output: "Stay home! Practice on Leetcode :)"

Example 4:

Input: text = "x > y && x < y is always false"
Output: "x > y && x < y is always false"

Example 5:

Input: text = "leetcode.com⁄problemset⁄all"
Output: "leetcode.com/problemset/all"

Constraints:

• 1 <= text.length <= 10^5
• The string may contain any possible characters out of all the 256 ASCII characters.

Solution: Simulation

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

// Author: Huahua
class Solution {
public:
  string entityParser(string text) {    
    map<string, string> m{
      {"&quot;", "\""}, {"&apos;", "'"}, {"&amp;", "&"}, 
      {"&gt;", ">"}, {"&lt;", "<"}, {"&frasl;", "/"}};
    string ans;
    string buf;
    for (char c : text) {
      buf += c;
      if (buf.back() != ';') continue;
      const int l = buf.size();
      for (const auto& [k, v] : m) {
        const int kl = k.length();
        if (l >= kl && buf.substr(l - kl) == k) {
          ans += buf.substr(0, l - kl) + v;
          buf.clear();
          break;
        }            
      }      
    }    
    return ans + buf;
  }
};

The post 花花酱 LeetCode 1410. HTML Entity Parser appeared first on Huahua's Tech Road.

https://leetcode.com/problems/replace-words/description/

In English, we have a concept called root, which can be followed by some other words to form another longer word – let’s call this word successor. For example, the root an, followed by other, which can form another word another.

Now, given a dictionary consisting of many roots and a sentence. You need to replace all the successor in the sentence with the root forming it. If a successor has many roots can form it, replace it with the root with the shortest length.

You need to output the sentence after the replacement.

Example 1:

Input: dict = ["cat", "bat", "rat"]
sentence = "the cattle was rattled by the battery"
Output: "the cat was rat by the bat"

Note:

1. The input will only have lower-case letters.
2. 1 <= dict words number <= 1000
3. 1 <= sentence words number <= 1000
4. 1 <= root length <= 100
5. 1 <= sentence words length <= 1000

Solution 1: HashTable

Time complexity: O(sum(w^2))

Space complexity: O(sum(l))

// Author: Huahua, Running time: 84 ms
class Solution {
public:
  string replaceWords(vector<string>& dict, string sentence) {
    unordered_set<string> d(begin(dict), end(dict));
    sentence.push_back(' ');
    string output;
    string word;
    bool found = false;
    for (char c : sentence) {
      if (c == ' ') {
        if (!output.empty()) output += ' ';
        output += word;
        word = "";
        found = false;
        continue;
      }
      if (found) continue;
      word += c;
      if (d.count(word)) {
        found = true;
      }
    }
    return output;
  }
};

Solution2: Trie

Time complexity: O(sum(l) + n)

Space complexity: O(sum(l) * 26)

// Author: Huahua, running time: 48 ms
class TrieNode {
public:
  TrieNode(): children(26), is_word(false) {}
  ~TrieNode() {
    for (int i = 0; i < 26; ++i)
      if (children[i]) {
        delete children[i];
        children[i] = nullptr;
      }
  }
  vector<TrieNode*> children;
  bool is_word;
};
class Solution {
public:
  string replaceWords(vector<string>& dict, string sentence) {    
    TrieNode root;
    for (const string& word : dict) {
      TrieNode* cur = &root;
      for (char c : word) {        
        if (!cur->children[c - 'a']) cur->children[c - 'a'] = new TrieNode();
        cur = cur->children[c - 'a'];
      }
      cur->is_word = true;
    }
    
    string ans;
    stringstream ss(sentence);
    string word;
    while (ss >> word) {      
      TrieNode* cur = &root;
      bool found = false;
      int len = 0;
      for (char c : word) {        
        cur = cur->children[c - 'a'];        
        if (!cur) break;
        ++len;
        if (cur->is_word) {
          found = true;
          break;
        }
      }      
      if (!ans.empty()) ans += ' ';      
      ans += found ? word.substr(0, len) : word;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 648. Replace Words appeared first on Huahua's Tech Road.