Posts tagged as “string”

花花酱 LeetCode 125. Valid Palindrome

By zxi on April 10, 2019

Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.

Note: For the purpose of this problem, we define empty string as valid palindrome.

Example 1:

Input: "A man, a plan, a canal: Panama"
Output: true

Example 2:

Input: "race a car"
Output: false

Solution: Two pointers

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

C++

class Solution {

public:

bool isPalindrome(string s) {

int i = 0;

int j = s.length() - 1;

while (i < j) {

while (i < j && !isalnum(s[i])) ++i;

while (i < j && !isalnum(s[j])) --j;

if (tolower(s[i++]) != tolower(s[j--]))

return false;

}

return true;

}

};

花花酱 LeetCode 988. Smallest String Starting From Leaf

By zxi on February 2, 2019

Given the root of a binary tree, each node has a value from 0 to 25representing the letters 'a' to 'z': a value of 0 represents 'a', a value of 1 represents 'b', and so on.

Find the lexicographically smallest string that starts at a leaf of this tree and ends at the root.

(As a reminder, any shorter prefix of a string is lexicographically smaller: for example, "ab" is lexicographically smaller than "aba". A leaf of a node is a node that has no children.)

Example 1:

Input: [0,1,2,3,4,3,4]
Output: "dba"

Example 2:

Input: [25,1,3,1,3,0,2]
Output: "adz"

Example 3:

Input: [2,2,1,null,1,0,null,0]
Output: "abc"

Note:

The number of nodes in the given tree will be between 1 and 1000.
Each node in the tree will have a value between 0 and 25.

Solution: Recursion

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

C++

// Author: Huahua, running time: 0 ms

class Solution {

public:

string smallestFromLeaf(TreeNode* root) {

if (!root) return "|"; // '|' > 'z'

const char v = static_cast<char>('a' + root->val);

if (!root->left && !root->right) return string(1, v);

string l = smallestFromLeaf(root->left);

string r = smallestFromLeaf(root->right);

return min(l, r) + v;

}

};

Python3

class Solution:

def smallestFromLeaf(self, root: 'TreeNode') -> 'str':

if not root: return '~'

c = chr(root.val + ord('a'))

if not root.left and not root.right: return c

return min(self.smallestFromLeaf(root.left),

self.smallestFromLeaf(root.right)) + c

花花酱 LeetCode 984. String Without AAA or BBB

By zxi on January 27, 2019

Given two integers A and B, return any string S such that:

S has length A + B and contains exactly A 'a' letters, and exactly B 'b' letters;
The substring 'aaa' does not occur in S;
The substring 'bbb' does not occur in S.

Example 1:

Input: A = 1, B = 2
Output: "abb"
Explanation: "abb", "bab" and "bba" are all correct answers.

Example 2:

Input: A = 4, B = 1
Output: "aabaa"

Note:

0 <= A <= 100
0 <= B <= 100
It is guaranteed such an S exists for the given A and B.

C++

class Solution {

public:

string strWithout3a3b(int A, int B) {

char a = 'a';

char b = 'b';

if (B > A) {

swap(A, B);

swap(a, b);

}

string ans;

while (A || B) {

if (A > 0) { ans += a; --A; }

if (A > B) { ans += a; --A; }

if (B > 0) { ans += b; --B; }

}

return ans;

}

};

C++ / overload

class Solution {

public:

string strWithout3a3b(int A, int B, char a = 'a', char b = 'b') {

if (B > A) return strWithout3a3b(B, A, b, a);

string ans;

while (A || B) {

if (A > 0) { ans += a; --A; }

if (A > B) { ans += a; --A; }

if (B > 0) { ans += b; --B; }

}

return ans;

}

};

花花酱 LeetCode 972. Equal Rational Numbers

By zxi on January 5, 2019

Given two strings S and T, each of which represents a non-negative rational number, return True if and only if they represent the same number. The strings may use parentheses to denote the repeating part of the rational number.

In general a rational number can be represented using up to three parts: an integer part, a non-repeating part, and a repeating part. The number will be represented in one of the following three ways:

<IntegerPart> (e.g. 0, 12, 123)
<IntegerPart><.><NonRepeatingPart> (e.g. 0.5, 1., 2.12, 2.0001)
<IntegerPart><.><NonRepeatingPart><(><RepeatingPart><)> (e.g. 0.1(6), 0.9(9), 0.00(1212))

The repeating portion of a decimal expansion is conventionally denoted within a pair of round brackets. For example:

1 / 6 = 0.16666666… = 0.1(6) = 0.1666(6) = 0.166(66)

Both 0.1(6) or 0.1666(6) or 0.166(66) are correct representations of 1 / 6.

Example 1:

Input: S = "0.(52)", T = "0.5(25)"
Output: true
Explanation:
Because "0.(52)" represents 0.52525252..., and "0.5(25)" represents 0.52525252525..... , the strings represent the same number.

Example 2:

Input: S = "0.1666(6)", T = "0.166(66)"
Output: true

Example 3:

Input: S = "0.9(9)", T = "1."
Output: true
Explanation: 
"0.9(9)" represents 0.999999999... repeated forever, which equals 1.  [See this link for an explanation.]
"1." represents the number 1, which is formed correctly: (IntegerPart) = "1" and (NonRepeatingPart) = "".

Note:

Each part consists only of digits.
The <IntegerPart> will not begin with 2 or more zeros. (There is no other restriction on the digits of each part.)
1 <= <IntegerPart>.length <= 4
0 <= <NonRepeatingPart>.length <= 4
1 <= <RepeatingPart>.length <= 4

Solution1: Expend the string

Extend the string to 16+ more digits and covert it to double.

0.9(9) => 0.99999999999999
0.(52) => 0.525252525252525
0.5(25) => 0.5252525252525

C++

// Author: Huahua, running time: 4 ms

class Solution {

public:

bool isRationalEqual(string S, string T) {

auto convert = [](string s) {

// 0.1234(567)

// 01234567890

// i = 1, p = 6

auto i = s.find('.');

auto p = s.find('(');

if (p != string::npos) {

string r = s.substr(p + 1, s.length() - p - 2);

s = s.substr(0, p);

while (s.length() < 16)

s += r;

}

return stod(s);

};

return abs(convert(S) - convert(T)) < 1e-10;

}

};

Python3

class Solution:

def isRationalEqual(self, S, T):

def convert(s):

i = s.find('.')

p = s.find('(')

if p >= 0:

r = s[p+1:-1]

s = s[0:p]

while len(s) < 16:

s += r

return float(s)

return abs(convert(S) - convert(T)) < 1e-10

Solution 2: Convert to a friction number

C++

// Author: Huahua, running time: 24 ms.

class Friction {

public:

Friction(long n = 0, long d = 1) {

long g = __gcd(n, d);

n_ = n / g;

d_ = d / g;

}

Friction operator+(const Friction& o) const {

return Friction(n_ * o.d_ + d_ * o.n_, d_ * o.d_);

}

bool operator==(const Friction& o) const {

return this->n_ * o.d_ == this->d_ * o.n_;

}

private:

long n_;

long d_;

};

class Solution {

public:

bool isRationalEqual(string S, string T) {

auto convert = [](string s) {

std::regex re("(\\d+)\\.?(\\d+)?(\\((\\d+)\\))?");

std::smatch matches;

std::regex_match(s, matches, re);

string int_part = matches[1].str();

string nr_part = matches[2].str();

string r_part = matches[4].str();

Friction f(stoi(int_part), 1);

const int base = pow(10, nr_part.length());

if (nr_part.length())

f = f + Friction(stoi(nr_part), base);

if (r_part.length())

f = f + Friction(stoi(r_part), (pow(10, r_part.length()) - 1) * base);

return f;

};

return convert(S) == convert(T);

}

};

花花酱 LeetCode 966. Vowel Spellchecker

By zxi on December 30, 2018

Problem

Given a wordlist, we want to implement a spellchecker that converts a query word into a correct word.

For a given query word, the spell checker handles two categories of spelling mistakes:

Capitalization: If the query matches a word in the wordlist (case-insensitive), then the query word is returned with the same case as the case in the wordlist.
- Example: wordlist = ["yellow"], query = "YellOw": correct = "yellow"
- Example: wordlist = ["Yellow"], query = "yellow": correct = "Yellow"
- Example: wordlist = ["yellow"], query = "yellow": correct = "yellow"
Vowel Errors: If after replacing the vowels (‘a’, ‘e’, ‘i’, ‘o’, ‘u’) of the query word with any vowel individually, it matches a word in the wordlist (case-insensitive), then the query word is returned with the same case as the match in the wordlist.
- Example: wordlist = ["YellOw"], query = "yollow": correct = "YellOw"
- Example: wordlist = ["YellOw"], query = "yeellow": correct = "" (no match)
- Example: wordlist = ["YellOw"], query = "yllw": correct = "" (no match)

In addition, the spell checker operates under the following precedence rules:

When the query exactly matches a word in the wordlist (case-sensitive), you should return the same word back.
When the query matches a word up to capitlization, you should return the first such match in the wordlist.
When the query matches a word up to vowel errors, you should return the first such match in the wordlist.
If the query has no matches in the wordlist, you should return the empty string.

Given some queries, return a list of words answer, where answer[i] is the correct word for query = queries[i].

Example 1:

Input: wordlist = ["KiTe","kite","hare","Hare"], queries = ["kite","Kite","KiTe","Hare","HARE","Hear","hear","keti","keet","keto"]
Output: ["kite","KiTe","KiTe","Hare","hare","","","KiTe","","KiTe"]

Note:

1 <= wordlist.length <= 5000
1 <= queries.length <= 5000
1 <= wordlist[i].length <= 7
1 <= queries[i].length <= 7
All strings in wordlist and queries consist only of english letters.

Solution: HashTable

Using 3 hashtables: original words, lower cases, lower cases with vowels replaced to “*”

Time complexity: O(|W|+|Q|)
Space complexity: O(|W|)

C++

class Solution {

public:

vector<string> spellchecker(vector<string>& wordlist, vector<string>& queries) {

vector<string> ans;

unordered_map<string, string> m_org;

unordered_map<string, string> m_low;

unordered_map<string, string> m_vow;

for (const string& w : wordlist) {

// Original word

m_org[w] = w;

// Case-insensitive

string l = toLower(w);

if (!m_low.count(l)) m_low[l] = w;

// Vowel-insensitive

string o = replaceVowels(l);

if (!m_vow.count(o)) m_vow[o] = w;

}

for (const string& q : queries) {

if (m_org.count(q)) {

ans.push_back(q);

continue;

}

string l = toLower(q);

if (m_low.count(l)) {

ans.push_back(m_low[l]);

continue;

}

string o = replaceVowels(l);

if (m_vow.count(o)) {

ans.push_back(m_vow[o]);

continue;

}

ans.push_back("");

}

return ans;

}

private:

string toLower(const string& s) {

string l(s);

std::transform(begin(s), end(s), begin(l), ::tolower);

return l;

}

string replaceVowels(const string& s) {

string o(s);

for (char& c : o)

if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')

c = '*';

return o;

}

};

Python3

class Solution:

def spellchecker(self, wordlist, queries):

org = dict()

low = dict()

vow = dict()

for w in wordlist:

org[w] = w

l = w.lower()

if l not in low: low[l] = w

v = re.sub(r'[aeiou]', '*', l)

if v not in vow: vow[v] = w

ans = []

for q in queries:

if q in org:

ans.append(q)

continue

l = q.lower()

if l in low:

ans.append(low[l])

continue

v = re.sub(r'[aeiou]', '*', l)

if v in vow:

ans.append(vow[v])

continue

ans.append("")

return ans