• If the length of the word is 1 or 2 letters, change all letters to lowercase.
• Otherwise, change the first letter to uppercase and the remaining letters to lowercase.

Return the capitalized title.

Example 1:

Input: title = "capiTalIze tHe titLe"
Output: "Capitalize The Title"
Explanation:
Since all the words have a length of at least 3, the first letter of each word is uppercase, and the remaining letters are lowercase.

Example 2:

Input: title = "First leTTeR of EACH Word"
Output: "First Letter of Each Word"
Explanation:
The word "of" has length 2, so it is all lowercase.
The remaining words have a length of at least 3, so the first letter of each remaining word is uppercase, and the remaining letters are lowercase.

Example 3:

Input: title = "i lOve leetcode"
Output: "i Love Leetcode"
Explanation:
The word "i" has length 1, so it is lowercase.
The remaining words have a length of at least 3, so the first letter of each remaining word is uppercase, and the remaining letters are lowercase.

Constraints:

• 1 <= title.length <= 100
• title consists of words separated by a single space without any leading or trailing spaces.
• Each word consists of uppercase and lowercase English letters and is non-empty.

Solution: Straight forward

Without splitting the sentence into words, we need to take care the word of length one and two.

Tips: use std::tolower, std::toupper to transform letters.

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

// Author: Huahua
class Solution {
public:
  string capitalizeTitle(string title) {
    const int n = title.size();
    for (int i = 0; i < title.size(); ++i) {
      if ((i == 0 || title[i - 1] == ' ') 
          && i + 2 < n && title[i + 1] != ' ' && title[i + 2] != ' ')
        title[i] = toupper(title[i]);
      else
        title[i] = tolower(title[i]);         
    }
    return title;
  }
};

# Author: Huahua
class Solution:
  def capitalizeTitle(self, title: str) -> str:
    return " ".join(map(lambda w: w.lower() if len(w) <= 2 else w[0].upper() + w[1:].lower(), title.split()))

The post 花花酱 LeetCode 2129. Capitalize the Title appeared first on Huahua's Tech Road.

A sentence can be shuffled by appending the 1-indexed word position to each word then rearranging the words in the sentence.

• For example, the sentence "This is a sentence" can be shuffled as "sentence4 a3 is2 This1" or "is2 sentence4 This1 a3".

Given a shuffled sentence s containing no more than 9 words, reconstruct and return the original sentence.

Example 1:

Input: s = "is2 sentence4 This1 a3"
Output: "This is a sentence"
Explanation: Sort the words in s to their original positions "This1 is2 a3 sentence4", then remove the numbers.

Example 2:

Input: s = "Myself2 Me1 I4 and3"
Output: "Me Myself and I"
Explanation: Sort the words in s to their original positions "Me1 Myself2 and3 I4", then remove the numbers.

Constraints:

• 2 <= s.length <= 200
• s consists of lowercase and uppercase English letters, spaces, and digits from 1 to 9.
• The number of words in s is between 1 and 9.
• The words in s are separated by a single space.
• s contains no leading or trailing spaces.

Solution: String

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

class Solution:
  def sortSentence(self, s: str) -> str:
    p = [(w[:-1], int(w[-1])) for w in s.split()]
    p.sort(key=lambda x : x[1])
    return " ".join((w for w, _ in p))

The post 花花酱 LeetCode 1859. Sorting the Sentence appeared first on Huahua's Tech Road.

Given a string, you need to reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.

Example 1:

Input: "Let's take LeetCode contest"
Output: "s'teL ekat edoCteeL tsetnoc"

Note: In the string, each word is separated by single space and there will not be any extra space in the string.

Idea: Brute Force

C++

// Author: Huahua
// Running time: 23 ms
class Solution {
public:
  string reverseWords(string s) {    
    int index = 0;  
    for (int i = 0; i <= s.length(); ++i) {
      if (i == s.length() || s[i] == ' ') {
        std::reverse(s.begin() + index, s.begin() + i);
        index = i + 1;
      }
    }
    return s;
  }
};

Python3

"""
Author: Huahua
Running time: 44 ms (beats 100%)
"""
class Solution:
  def reverseWords(self, s):        
    return ' '.join(map(lambda x: x[::-1], s.split(' ')))

The post 花花酱 LeetCode 557 Reverse Words in a String III appeared first on Huahua's Tech Road.

Problem:

Given two sentences words1, words2 (each represented as an array of strings), and a list of similar word pairs pairs, determine if two sentences are similar.

For example, “great acting skills” and “fine drama talent” are similar, if the similar word pairs are pairs = [["great", "fine"], ["acting","drama"], ["skills","talent"]].

Note that the similarity relation is not transitive. For example, if “great” and “fine” are similar, and “fine” and “good” are similar, “great” and “good” are not necessarily similar.

However, similarity is symmetric. For example, “great” and “fine” being similar is the same as “fine” and “great” being similar.

Also, a word is always similar with itself. For example, the sentences words1 = ["great"], words2 = ["great"], pairs = [] are similar, even though there are no specified similar word pairs.

Finally, sentences can only be similar if they have the same number of words. So a sentence like words1 = ["great"] can never be similar to words2 = ["doubleplus","good"].

Note:

• The length of words1 and words2 will not exceed 1000.
• The length of pairs will not exceed 2000.
• The length of each pairs[i] will be 2.
• The length of each words[i] and pairs[i][j] will be in the range [1, 20].

题目大意：

给你两个句子（由单词数组表示）和一些近义词对，问你这两个句子是否相似，即每组相对应的单词都要相似。

注意相似性不能传递，比如给只你”great”和”fine”相似、”fine”和”good”相似，这种情况下”great”和”good”不相似。

Idea:

Use hashtable to store mapping from word to its similar words.

Solution: HashTable

Time complexity: O(|pairs| + |words1|)

Space complexity: O(|pairs|)

// Author: Huahua
// Runtime: 9 ms
class Solution {
public:
    bool areSentencesSimilar(vector<string>& words1, vector<string>& words2, vector<pair<string, string>> pairs) {
        if (words1.size() != words2.size()) return false;
        
        unordered_map<string, unordered_set<string>> similar_words;
        for (const auto& pair : pairs) {            
            similar_words[pair.first].insert(pair.second);
            similar_words[pair.second].insert(pair.first);
        }
        
        for (int i = 0; i < words1.size(); ++i) {
            if (words1[i] == words2[i]) continue;
            if (!similar_words[words1[i]].count(words2[i])) return false;
        }
        
        return true;
    }
};

// Author: Huahua
// Runtime: 10 ms
class Solution {
    public boolean areSentencesSimilar(String[] words1, String[] words2, String[][] pairs) {
        if (words1.length != words2.length) return false;
        
        Map<String, Set<String>> similar_words = new HashMap<>();
        
        for (String[] pair : pairs) {
            if (!similar_words.containsKey(pair[0]))
                similar_words.put(pair[0], new HashSet<>());
            if (!similar_words.containsKey(pair[1]))
                similar_words.put(pair[1], new HashSet<>());
            similar_words.get(pair[0]).add(pair[1]);
            similar_words.get(pair[1]).add(pair[0]);
        }
        
        for (int i = 0; i < words1.length; ++i) {
            if (words1[i].equals(words2[i])) continue;
            if (!similar_words.containsKey(words1[i])) return false;
            if (!similar_words.get(words1[i]).contains(words2[i])) return false;
        }
        
        return true;
    }
}

"""
Author: Huahua
Runtime: 62 ms
"""
class Solution:
    def areSentencesSimilar(self, words1, words2, pairs):
        if len(words1) != len(words2): return False
        
        similar_words = {}
        
        for w1, w2 in pairs:
            if not w1 in similar_words: similar_words[w1] = set()
            if not w2 in similar_words: similar_words[w2] = set()
            similar_words[w1].add(w2)
            similar_words[w2].add(w1)
        
        for w1, w2 in zip(words1, words2):
            if w1 == w2: continue
            if w1 not in similar_words: return False
            if w2 not in similar_words[w1]: return False
        
        return True

Related Problems:

• [解题报告] LeetCode 737. Sentence Similarity II

The post 花花酱 LeetCode 734. Sentence Similarity appeared first on Huahua's Tech Road.