Posts published in “String”

花花酱 LeetCode 539. Minimum Time Difference

By zxi on March 21, 2018

Problem

Given a list of 24-hour clock time points in “Hour:Minutes” format, find the minimum minutes difference between any two time points in the list.

Example 1:

Input: ["23:59","00:00"]
Output: 1

Note:

The number of time points in the given list is at least 2 and won’t exceed 20000.
The input time is legal and ranges from 00:00 to 23:59.

Solution

Time complexity: O(nlog1440)

Space complexity: O(n)

C++

// Author: huahua

// Running time: 16 ms

class Solution {

public:

int findMinDifference(vector<string>& timePoints) {

constexpr int kMins = 24 * 60;

set<int> seen;

for (const string& time : timePoints) {

int m = stoi(time.substr(0, 2)) * 60 + stoi(time.substr(3));

if (!seen.insert(m).second) return 0;

}

int ans = (*seen.begin() - *seen.rbegin() + kMins) % kMins;

const int* l = nullptr;

for (const int& t : seen) {

if (l) ans = min(ans, t - *l);

l = &t;

}

return ans;

}

};

花花酱 LeetCode 609. Find Duplicate File in System

By zxi on March 20, 2018

Problem

https://leetcode.com/problems/find-duplicate-file-in-system/description/

题目大意：输出系统中文件内容相同的文件名。

Given a list of directory info including directory path, and all the files with contents in this directory, you need to find out all the groups of duplicate files in the file system in terms of their paths.

A group of duplicate files consists of at least two files that have exactly the same content.

A single directory info string in the input list has the following format:

"root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)"

It means there are n files (f1.txt, f2.txt … fn.txt with content f1_content, f2_content … fn_content, respectively) in directory root/d1/d2/.../dm. Note that n >= 1 and m >= 0. If m = 0, it means the directory is just the root directory.

The output is a list of group of duplicate file paths. For each group, it contains all the file paths of the files that have the same content. A file path is a string that has the following format:

"directory_path/file_name.txt"

Example 1:

Input:
["root/a 1.txt(abcd) 2.txt(efgh)", "root/c 3.txt(abcd)", "root/c/d 4.txt(efgh)", "root 4.txt(efgh)"]
Output:  
[["root/a/2.txt","root/c/d/4.txt","root/4.txt"],["root/a/1.txt","root/c/3.txt"]]

Note:

No order is required for the final output.
You may assume the directory name, file name and file content only has letters and digits, and the length of file content is in the range of [1,50].
The number of files given is in the range of [1,20000].
You may assume no files or directories share the same name in the same directory.
You may assume each given directory info represents a unique directory. Directory path and file info are separated by a single blank space.

Follow-up beyond contest:

Imagine you are given a real file system, how will you search files? DFS or BFS?
If the file content is very large (GB level), how will you modify your solution?
If you can only read the file by 1kb each time, how will you modify your solution?
What is the time complexity of your modified solution? What is the most time-consuming part and memory consuming part of it? How to optimize?
How to make sure the duplicated files you find are not false positive?

Solution: HashTable

Key: content, Value: Array of filenames

Time complexity: O(n)

Space complexity: O(n)

C++

// Author: Huahua

// Running time: 80ms (beats 94.68%)

class Solution {

public:

vector<vector<string>> findDuplicate(vector<string>& paths) {

unordered_map<string, vector<string>> files; // content -> filenames

for (const string& path : paths) {

string folder;

int i = 0;

while (path[i] != ' ') folder += path[i++];

while (i < path.length()) {

string filename;

string content;

++i; // ' '

while (path[i] != '(') filename += path[i++];

++i; // '('

while (path[i] != ')') content += path[i++];

++i; // ')'

files[content].push_back(folder + "/" + filename);

}

vector<vector<string>> ans;

for (auto& kv : files)

if (kv.second.size() > 1)

ans.push_back(std::move(kv.second));

return ans;

}

};

花花酱 LeetCode 800. Simple RGB Color

By zxi on March 17, 2018

Problem

In the following, every capital letter represents some hexadecimal digit from 0 to f.

The red-green-blue color "#AABBCC" can be written as "#ABC" in shorthand. For example, "#15c" is shorthand for the color "#1155cc".

Now, say the similarity between two colors "#ABCDEF" and "#UVWXYZ" is -(AB - UV)^2 - (CD - WX)^2 - (EF - YZ)^2.

Given the color "#ABCDEF", return a 7 character color that is most similar to #ABCDEF, and has a shorthand (that is, it can be represented as some "#XYZ"

Example 1:
Input: color = "#09f166"
Output: "#11ee66"
Explanation:  
The similarity is -(0x09 - 0x11)^2 -(0xf1 - 0xee)^2 - (0x66 - 0x66)^2 = -64 -9 -0 = -73.
This is the highest among any shorthand color.

Note:

color is a string of length 7.
color is a valid RGB color: for i > 0, color[i] is a hexadecimal digit from 0 to f
Any answer which has the same (highest) similarity as the best answer will be accepted.
All inputs and outputs should use lowercase letters, and the output is 7 characters.

Solution: Brute Force

R, G, B are independent, find the closest color for each channel separately.

Time complexity: O(3 * 16)

Space complexity: O(1)

// Author: Huahua

// Running time: 7 ms

class Solution {

public:

string similarRGB(string color) {

const string hex{"0123456789abcdef"};

vector<int> rgb(3, 0);

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

rgb[i] = hex.find(color[2 * i + 1]) * 16 + hex.find(color[2 * i + 2]);

string ans(7, '#');

for (int i = 0; i < 3; ++i) {

int best = INT_MAX;

for (int j = 0; j < 16; ++j) {

int diff = abs(j * 16 + j - rgb[i]);

if (diff >= best) continue;

best = diff;

ans[2 * i + 1] = ans[2 * i + 2] = hex[j];

}

return ans;

}

};

花花酱 LeetCode 415. Add Strings

By zxi on March 17, 2018

Problem

Given two non-negative integers num1 and num2 represented as string, return the sum of num1 and num2.

Note:

The length of both num1 and num2 is < 5100.
Both num1 and num2 contains only digits 0-9.
Both num1 and num2 does not contain any leading zero.
You must not use any built-in BigInteger library or convert the inputs to integer directly.

Solution: Brute Force

Time complexity: O(n)

Space complexity: O(n)

C++

// Author: Huahua

// Running time: 13 ms

class Solution {

public:

string addStrings(string num1, string num2) {

if (num1.length() < num2.length()) swap(num1, num2);

num1 = "0" + num1;

int l1 = num1.length();

int l2 = num2.length();

for (int i = 0; i < l1 - 1; ++i) {

if (i < l2) num1[l1 - i - 1] += (num2[l2 - i - 1] - '0');

if (num1[l1 - i - 1] > '9') {

num1[l1 - i - 1] -= 10;

++num1[l1 - i - 2];

}

return (num1[0] != '0') ? num1 : num1.substr(1);

}

};

花花酱 LeetCode 392. Is Subsequence

By zxi on March 16, 2018

题目大意：问s是不是t的子序列。

Problem:

https://leetcode.com/problems/is-subsequence/description/

Given a string s and a string t, check if s is subsequence of t.

You may assume that there is only lower case English letters in both s and t. t is potentially a very long (length ~= 500,000) string, and sis a short string (<=100).

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ace" is a subsequence of "abcde" while "aec" is not).

Example 1:
s = "abc", t = "ahbgdc"

Return true.

Example 2:
s = "axc", t = "ahbgdc"

Return false.

Follow up:
If there are lots of incoming S, say S1, S2, … , Sk where k >= 1B, and you want to check one by one to see if T has its subsequence. In this scenario, how would you change your code?

Solution: Brute force

Time Complexity: O(|s| + |t|)

Space Complexity: O(1)

C++

// Author: Huahua

// Running time: 65 ms (beats 99.37%)

class Solution {

public:

bool isSubsequence(const string& s, const string& t) {

int i = 0;

const int n = t.length();

for (const char c : s) {

while (i < n && t[i] != c) ++i;

if (i++ == n) return false;

}

return true;

}

};