Posts published in “String”

花花酱 LeetCode 796. Rotate String

By zxi on March 10, 2018

题目大意：给你两个字符串A, B, 问能否通过旋转A得到B。

Problem:

https://leetcode.com/problems/rotate-string/description/

We are given two strings, A and B.

A shift on A consists of taking string A and moving the leftmost character to the rightmost position. For example, if A = 'abcde', then it will be 'bcdea' after one shift on A. Return True if and only if A can become B after some number of shifts on A.

Example 1:

Input: A = 'abcde', B = 'cdeab'

Output: true

Example 2:

Input: A = 'abcde', B = 'abced'

Output: false

Note:

A and B will have length at most 100.

Solution 1: Brute Force

Time complexity: O(n^2)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 3 ms

class Solution {

public:

bool rotateString(string A, string B) {

if (A.length() != B.length()) return false;

for (int i = 1; i < A.length(); ++i)

if (check(A, B, i)) return true;

return false;

}

private:

bool check(const string& A, const string& B, int offset) {

for (int i = 0; i < A.length(); ++i)

if (A[(i + offset) % A.length()] != B[i])

return false;

return true;

}

};

花花酱 LeetCode 647. Palindromic Substrings

By zxi on March 10, 2018

Problem:

https://leetcode.com/problems/palindromic-substrings/description/

Given a string, your task is to count how many palindromic substrings in this string.

The substrings with different start indexes or end indexes are counted as different substrings even they consist of same characters.

Example 1:

Input: "abc"

Output: 3

Explanation: Three palindromic strings: "a", "b", "c".

Example 2:

Input: "aaa"

Output: 6

Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".

Note:

The input string length won’t exceed 1000.

Solution 1: Brute Force

Time complexity: O(n^2)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 5 ms

class Solution {

public:

int countSubstrings(string s) {

int ans = 0;

for (int i = 0; i < s.length(); ++i) {

ans += count(s, i, i); // odd length

ans += count(s, i, i + 1); // even length

}

return ans;

}

private:

int count(const string& s, int l, int r) {

int ans = 0;

while (l >= 0 & r < s.length() && s[l--] == s[r++])

++ans;

return ans;

}

};

花花酱 LeetCode 521. Longest Uncommon Subsequence I

By zxi on March 7, 2018

题目大意：求2个字符串最长的不同子序列的长度。

Problem:

https://leetcode.com/problems/longest-uncommon-subsequence-i/description/

Given a group of two strings, you need to find the longest uncommon subsequence of this group of two strings. The longest uncommon subsequence is defined as the longest subsequence of one of these strings and this subsequence should not be any subsequence of the other strings.

A subsequence is a sequence that can be derived from one sequence by deleting some characters without changing the order of the remaining elements. Trivially, any string is a subsequence of itself and an empty string is a subsequence of any string.

The input will be two strings, and the output needs to be the length of the longest uncommon subsequence. If the longest uncommon subsequence doesn’t exist, return -1.

Example 1:

Input: "aba", "cdc"

Output: 3

Explanation: The longest uncommon subsequence is "aba" (or "cdc"),

because "aba" is a subsequence of "aba",

but not a subsequence of any other strings in the group of two strings.

Note:

Both strings’ lengths will not exceed 100.
Only letters from a ~ z will appear in input strings.

Idea:

If two strings are the same, then the longest uncommon sequence does not exist, return -1.

e.g. aaa vs aaa, return -1

Otherwise, the longer string is always a uncommon sequence of the shorter one.

e.g. aaab vs aaa, return 4

Solution 1:

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 3 ms

class Solution {

public:

int findLUSlength(string a, string b) {

return a == b ? -1 : max(a.length(), b.length());

}

};

Java

// Author: Huahua

// Running time: 3 ms

class Solution {

public int findLUSlength(String a, String b) {

return a.equals(b) ? -1 : Math.max(a.length(), b.length());

}

Python3

"""

Author: Huahua

Running time: 40 ms (beats 100%)

Website: http://zxi.mytechroad.com/blog/string/leetcode-521-longest-uncommon-subsequence-i/

"""

class Solution:

def findLUSlength(self, a, b):

la, lb = len(a), len(b)

if la != lb: return max(la, lb)

return -1 if a == b else la

花花酱 LeetCode 696. Count Binary Substrings

By zxi on March 6, 2018

题目大意：给你一个二进制的字符串，问有多少子串的0个数量等于1的数量。

Problem:

https://leetcode.com/problems/count-binary-substrings/description/

Give a string s, count the number of non-empty (contiguous) substrings that have the same number of 0’s and 1’s, and all the 0’s and all the 1’s in these substrings are grouped consecutively.

Substrings that occur multiple times are counted the number of times they occur.

Example 1:

Input: "00110011"

Output: 6

Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".

Notice that some of these substrings repeat and are counted the number of times they occur.

Also, "00110011" is not a valid substring because all the 0's (and 1's) are not grouped together.

Example 2:

Input: "10101"

Output: 4

Explanation: There are 4 substrings: "10", "01", "10", "01" that have equal number of consecutive 1's and 0's.

Note:

s.length will be between 1 and 50,000.
s will only consist of “0” or “1” characters.

Solution 0: Search

Try all possible substrings and check whether it’s a valid one or not.

Time complexity O(2^n * n) TLE

Space complexity: O(n)

Solution 1: Running Length

For S = “000110”, there are two virtual blocks “[00011]0” and “000[110]” which contains consecutive 0s and 1s or (1s and 0s)

Keep tracking of the running length of 0, 1 for each block

“00011” => ‘0’: 3, ‘1’:2

ans += min(3, 2) => ans = 2 (“[0011]”, “0[01]1”)

“110” => ‘0’: 1, ‘1’: 2

ans += min(1, 2) => ans = 3 (“[0011]”, “0[01]1”, “1[10]”)

We can reuse part of the running length from last block.

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 43 ms

class Solution {

public:

int countBinarySubstrings(string s) {

vector<int> lens(128, 0);

int i = 0;

int l = 0;

int ans = 0;

while (true) {

while (i < s.length() && s[i] == s[l]) ++i;

lens[s[l]] = i - l;

ans += min(lens['0'], lens['1']);

if (i == s.length()) break;

lens[s[i]] = 0;

l = i;

}

return ans;

}

};

花花酱 LeetCode 792. Number of Matching Subsequences

By zxi on March 3, 2018

题目大意：给你一些单词，问有多少单词出现在字符串S的子序列中。

https://leetcode.com/problems/number-of-matching-subsequences/description/

Given string S and a dictionary of words words, find the number of words[i] that is a subsequence of S.

Example :

Input:

S = "abcde"

words = ["a", "bb", "acd", "ace"]

Output: 3

Explanation: There are three words in <code>words</code> that are a subsequence of <code>S</code>: "a", "acd", "ace".

Note:

All words in words and S will only consists of lowercase letters.
The length of S will be in the range of [1, 50000].
The length of words will be in the range of [1, 5000].
The length of words[i] will be in the range of [1, 50].

Solution 1: Brute Force

Time complexity: O((S + L) * W)

C++ w/o cache TLE

Space complexity: O(1)

C++ w/ cache 155 ms

Space complexity: O(W * L)

// Author: Huahua

// Running time: 155 ms

class Solution {

public:

int numMatchingSubseq(const string& S, vector<string>& words) {

int ans = 0;

unordered_map<string, bool> m;

for (const string& word : words) {

auto it = m.find(word);

if (it == m.end()) {

bool match = isMatch(word, S);

ans += m[word] = match;

} else {

ans += it->second;

}

return ans;

}

private:

bool isMatch(const string& word, const string& S) {

int start = 0;

for (const char c : word) {

bool found = false;

for (int i = start; i < S.length(); ++i)

if (S[i] == c) {

found = true;

start = i + 1;

break;

}

if (!found) return false;

}

return true;

}

};

Solution 2: Indexing+ Binary Search

Time complexity: O(S + W * L * log(S))

Space complexity: O(S)

S: length of S

W: number of words

L: length of a word

C++

// Author: Huahua

// Running time: 183 ms

class Solution {

public:

int numMatchingSubseq(const string& S, vector<string>& words) {

vector<vector<int>> pos(128);

for (int i = 0; i < S.length(); ++i)

pos[S[i]].push_back(i);

int ans = 0;

for (const string& word : words)

ans += isMatch(word, pos);

return ans;

}

private:

unordered_map<string, bool> m_;

bool isMatch(const string& word, const vector<vector<int>>& pos) {

if (m_.count(word)) return m_[word];

int last_index = -1;

for (const char c : word) {

const vector<int>& p = pos[c];

const auto it = std::lower_bound(p.begin(), p.end(), last_index + 1);

if (it == p.end()) return m_[word] = false;

last_index = *it;

}

return m_[word] = true;

}

};

Java

// Author: Huahua

// Running time: 135 ms

class Solution {

private List<List<Integer>> pos;

private boolean isMatch(String word) {

int l = -1;

for (char c : word.toCharArray()) {

List<Integer> p = pos.get(c);

int index = Collections.binarySearch(p, l + 1);

if (index < 0) index = -index - 1;

if (index >= p.size()) return false;

l = p.get(index);

}

return true;

}

public int numMatchingSubseq(String S, String[] words) {

pos = new ArrayList<>();

for (int i = 0; i < 128; ++i)

pos.add(new ArrayList<Integer>());

char[] s = S.toCharArray();

for (int i = 0; i < s.length; ++i)

pos.get(s[i]).add(i);

int ans = 0;

for (String word : words)

if (isMatch(word)) ++ans;

return ans;

}

Python 3:

w/o cache

"""

Author: Huahua

Running time: 1120 ms

"""

class Solution:

def numMatchingSubseq(self, S, words):

import bisect

def isMatch(word):

l = -1

for c in word:

index = bisect.bisect_left(pos[c], l + 1)

if index == len(pos[c]): return 0

l = pos[c][index]

return 1

pos = {chr(i + ord('a')) : [] for i in range(26)}

for i, c in enumerate(S):

pos[c].append(i)

return sum(map(isMatch, words))

w/ cache

"""

Author: Huahua

Running time: 632 ms

"""

class Solution:

def numMatchingSubseq(self, S, words):

import bisect

def isMatch(word):

if word in m: return m[word]

l = -1

for c in word:

index = bisect.bisect_left(pos[c], l + 1)

if index == len(pos[c]):

m[word] = 0

return 0

l = pos[c][index]

m[word] = 1

return 1

m = {}

pos = {chr(i + ord('a')) : [] for i in range(26)}

for i, c in enumerate(S):

pos[c].append(i)

return sum(map(isMatch, words))