花花酱 LeetCode 2129. Capitalize the Title

By zxi on January 8, 2022

You are given a string title consisting of one or more words separated by a single space, where each word consists of English letters. Capitalize the string by changing the capitalization of each word such that:

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)

C++

// 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;

}

};

Python3

# 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()))

花花酱 LeetCode 1859. Sorting the Sentence

By zxi on May 29, 2021

A sentence is a list of words that are separated by a single space with no leading or trailing spaces. Each word consists of lowercase and uppercase English letters.

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)

Python3

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))

花花酱 LeetCode 557 Reverse Words in a String III

By zxi on March 2, 2018

题目大意：独立反转字符串中的每个单词。

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:

1 2	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(' ')))

花花酱 LeetCode 734. Sentence Similarity

By zxi on November 28, 2017

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|)

C++

// 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;

}

};

Java

// 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;

}

Python

"""

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

Posts tagged as “words”

花花酱 LeetCode 2129. Capitalize the Title

Solution: Straight forward

C++

Python3

花花酱 LeetCode 1859. Sorting the Sentence

Solution: String

Python3

花花酱 LeetCode 557 Reverse Words in a String III

花花酱 LeetCode 734. Sentence Similarity

Solution: HashTable

C++

Java

Python