• 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.

• For example, "a puppy has 2 eyes 4 legs" is a sentence with seven tokens: "2" and "4" are numbers and the other tokens such as "puppy" are words.

Given a string s representing a sentence, you need to check if all the numbers in s are strictly increasing from left to right (i.e., other than the last number, each number is strictly smaller than the number on its right in s).

Return true if so, or false otherwise.

Example 1:

Input: s = "1 box has 3 blue 4 red 6 green and 12 yellow marbles"
Output: true
Explanation: The numbers in s are: 1, 3, 4, 6, 12.
They are strictly increasing from left to right: 1 < 3 < 4 < 6 < 12.

Example 2:

Input: s = "hello world 5 x 5"
Output: false
Explanation: The numbers in s are: 5, 5. They are not strictly increasing.

Example 3:

Input: s = "sunset is at 7 51 pm overnight lows will be in the low 50 and 60 s"
Output: false
Explanation: The numbers in s are: 7, 51, 50, 60. They are not strictly increasing.

Example 4:

Input: s = "4 5 11 26"
Output: true
Explanation: The numbers in s are: 4, 5, 11, 26.
They are strictly increasing from left to right: 4 < 5 < 11 < 26.

Constraints:

• 3 <= s.length <= 200
• s consists of lowercase English letters, spaces, and digits from 0 to 9, inclusive.
• The number of tokens in s is between 2 and 100, inclusive.
• The tokens in s are separated by a single space.
• There are at least two numbers in s.
• Each number in s is a positive number less than 100, with no leading zeros.
• s contains no leading or trailing spaces.

Solution: String

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

// Author: Huahua
class Solution {
public:
  bool areNumbersAscending(string s) {
    stringstream ss(s);
    string token;
    int last = -1;
    while (ss >> token) {
      if (isdigit(token[0])) {
        int num = stoi(token);
        if (num <= last) return false;
        last = num;
      }
    }
    return true;
  }
};

The post 花花酱 LeetCode 2042. Check if Numbers Are Ascending in a Sentence appeared first on Huahua's Tech Road.

• For example, "Hello World", "HELLO", and "hello world hello world" are all sentences.

You are given a sentence s​​​​​​ and an integer k​​​​​​. You want to truncate s​​​​​​ such that it contains only the first k​​​​​​ words. Return s​​​​​​ after truncating it.

Example 1:

Input: s = "Hello how are you Contestant", k = 4
Output: "Hello how are you"
Explanation:
The words in s are ["Hello", "how" "are", "you", "Contestant"].
The first 4 words are ["Hello", "how", "are", "you"].
Hence, you should return "Hello how are you".

Example 2:

Input: s = "What is the solution to this problem", k = 4
Output: "What is the solution"
Explanation:
The words in s are ["What", "is" "the", "solution", "to", "this", "problem"].
The first 4 words are ["What", "is", "the", "solution"].
Hence, you should return "What is the solution".

Example 3:

Input: s = "chopper is not a tanuki", k = 5
Output: "chopper is not a tanuki"

Constraints:

• 1 <= s.length <= 500
• k is in the range [1, the number of words in s].
• s consist of only lowercase and uppercase English letters and spaces.
• The words in s are separated by a single space.
• There are no leading or trailing spaces.

Solution:

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

class Solution {
public:
  string truncateSentence(string s, int k) {
    string ans;
    stringstream ss(s);
    for (int i = 0; i < k && ss; ++i) {
      string word;
      ss >> word;
      ans += (ans.empty() ? "" : " ") + word;
    }
    return ans;
  }
};

class Solution:
  def truncateSentence(self, s: str, k: int) -> str:
    return " ".join(s.split()[:k])

The post 花花酱 LeetCode 1816. Truncate Sentence appeared first on Huahua's Tech Road.

Example 1:

Input: n = 987
Output: "987"

Example 2:

Input: n = 1234
Output: "1.234"

Example 3:

Input: n = 123456789
Output: "123.456.789"

Example 4:

Input: n = 0
Output: "0"

Constraints:

• 0 <= n < 2^31

Solution: Digit by digit

Time complexity: O(log^2(n)) -> O(logn)
Space complexity: O(log(n))

class Solution {
class Solution {
public:
  string thousandSeparator(int n) {    
    string ans;
    int count = 0;
    do {
      if (count++ % 3 == 0 && ans.size())
        ans = "." + ans;
      ans = to_string(n % 10) + ans;
      n /= 10;      
    } while (n);
    return ans;
  }
};

The post 花花酱 LeetCode 1556. Thousand Separator appeared first on Huahua's Tech Road.

• Day is in the set {"1st", "2nd", "3rd", "4th", ..., "30th", "31st"}.
• Month is in the set {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}.
• Year is in the range [1900, 2100].

Convert the date string to the format YYYY-MM-DD, where:

• YYYY denotes the 4 digit year.
• MM denotes the 2 digit month.
• DD denotes the 2 digit day.

Example 1:

Input: date = "20th Oct 2052"
Output: "2052-10-20"

Example 2:

Input: date = "6th Jun 1933"
Output: "1933-06-06"

Example 3:

Input: date = "26th May 1960"
Output: "1960-05-26"

Constraints:

• The given dates are guaranteed to be valid, so no error handling is necessary.

Solution: String + HashTable

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

// Author: Huahua
class Solution {
public:
  string reformatDate(string date) {
    stringstream ss(date);
    string day, month, year;
    ss >> day >> month >> year;
    unordered_map<string, string> m{{"Jan", "01"},
                                    {"Feb", "02"},
                                    {"Mar", "03"},
                                    {"Apr", "04"},
                                    {"May", "05"},
                                    {"Jun", "06"},
                                    {"Jul", "07"},
                                    {"Aug", "08"},
                                    {"Sep", "09"},
                                    {"Oct", "10"},
                                    {"Nov", "11"},
                                    {"Dec", "12"}};
    day = day.substr(0, day.length() - 2);
    if (day.length() == 1) day = "0" + day;
    return year + "-" + m[month] + "-" + day;
  }
};

// Author: Huahua
class Solution {
  public String reformatDate(String date) {
    Map<String, String> m = new HashMap<String, String>();
    m.put("Jan", "01");
    m.put("Feb", "02");
    m.put("Mar", "03");
    m.put("Apr", "04");
    m.put("May", "05");
    m.put("Jun", "06");
    m.put("Jul", "07");
    m.put("Aug", "08");
    m.put("Sep", "09");
    m.put("Oct", "10");
    m.put("Nov", "11");
    m.put("Dec", "12");
    String[] items = date.split(" ");    
    String day = items[0].substring(0, items[0].length() - 2);
    if (day.length() == 1) day = "0" + day;
    return items[2] + "-" + m.get(items[1]) + "-" + day;
  }
}

# Author: Huahua
class Solution:
  def reformatDate(self, date: str) -> str:
    m = {"Jan": "01", "Feb": "02", "Mar": "03", 
         "Apr": "04", "May": "05", "Jun": "06", 
         "Jul": "07", "Aug": "08", "Sep": "09", 
         "Oct": "10", "Nov": "11", "Dec": "12"}
    items = date.split(" ")
    day = items[0][:-2]
    if len(day) == 1: day = "0" + day
    return items[2] + "-" + m[items[1]] + "-" + day

The post 花花酱 LeetCode 1507. Reformat Date appeared first on Huahua's Tech Road.

A program was supposed to print an array of integers. The program forgot to print whitespaces and the array is printed as a string of digits and all we know is that all integers in the array were in the range [1, k] and there are no leading zeros in the array.

Given the string s and the integer k. There can be multiple ways to restore the array.

Return the number of possible array that can be printed as a string s using the mentioned program.

The number of ways could be very large so return it modulo 10^9 + 7

Example 1:

Input: s = "1000", k = 10000
Output: 1
Explanation: The only possible array is [1000]

Example 2:

Input: s = "1000", k = 10
Output: 0
Explanation: There cannot be an array that was printed this way and has all integer >= 1 and <= 10.

Example 3:

Input: s = "1317", k = 2000
Output: 8
Explanation: Possible arrays are [1317],[131,7],[13,17],[1,317],[13,1,7],[1,31,7],[1,3,17],[1,3,1,7]

Example 4:

Input: s = "2020", k = 30
Output: 1
Explanation: The only possible array is [20,20]. [2020] is invalid because 2020 > 30. [2,020] is ivalid because 020 contains leading zeros.

Example 5:

Input: s = "1234567890", k = 90
Output: 34

Constraints:

• 1 <= s.length <= 10^5.
• s consists of only digits and doesn’t contain leading zeros.
• 1 <= k <= 10^9.

Solution: DP

dp[i] := # of ways to restore the array for s[i:n].

dp[i] = sum(dp[j]), where 0 < j < n, int(s[i:j]) <= k, s[i] != 0

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

Top-down

// Author: Huahua
class Solution {
public:
  int numberOfArrays(string s, int k) {
    constexpr int kMod = 1e9 + 7;
    const int n = s.length();
    vector<int> mem(n, -1);
    // dp(i) returns # of ways for s[i:n]
    function<int(int)> dp = [&](int i) {
      if (i == n) return 1;
      if (s[i] == '0') return 0;
      if (mem[i] >= 0) return mem[i];
      long num = 0;
      int ans = 0;
      for (int j = i + 1; j <= n; ++j) {
        num = num * 10 + (s[j - 1] - '0');
        if (num > k) break;
        ans = (ans + dp(j)) % kMod;
      }
      return mem[i] = ans;
    };
    return dp(0);
  }
};

bottom-up

// Author: Huahua
class Solution {
public:
  int numberOfArrays(string s, int k) {
    constexpr int kMod = 1e9 + 7;
    const int n = s.length();
    vector<int> dp(n + 1); // # of ways for s[i:n]
    dp.back() = 1;
    for (int i = n - 1; i >= 0; --i) {
      if (s[i] == '0') continue;
      long num = 0;
      for (int j = i + 1; j <= n; ++j) {
        num = num * 10 + (s[j - 1] - '0');
        if (num > k) break;
        dp[i] = (dp[i] + dp[j]) % kMod;
      }
    }
    return dp[0];
  }
};

The post 花花酱 LeetCode 1416. Restore The Array appeared first on Huahua's Tech Road.

Given an array A of 0s and 1s, divide the array into 3 non-empty parts such that all of these parts represent the same binary value.

If it is possible, return any [i, j] with i+1 < j, such that:

• A[0], A[1], ..., A[i] is the first part;
• A[i+1], A[i+2], ..., A[j-1] is the second part, and
• A[j], A[j+1], ..., A[A.length - 1] is the third part.
• All three parts have equal binary value.

If it is not possible, return [-1, -1].

Note that the entire part is used when considering what binary value it represents.  For example, [1,1,0] represents 6 in decimal, not 3.  Also, leading zeros are allowed, so [0,1,1] and [1,1] represent the same value.

Example 1:

Input: [1,0,1,0,1]
Output: [0,3]

Example 2:

Input: [1,1,0,1,1]
Output: [-1,-1]

Note:

1. 3 <= A.length <= 30000
2. A[i] == 0 or A[i] == 1

Solution:

each part should have the same number of 1 s.

Find the suffix (without leading os) of the last part which should have 1/3 of the total ones.

Time complexity: O(n^2) in theory but close to O(n) in practice

Space complexity: O(n)

// Author: Huahua, 44 ms
class Solution {
public:
  vector<int> threeEqualParts(vector<int>& A) {    
    string s(begin(A), end(A));
    int ones = accumulate(begin(A), end(A), 0);
    if (ones % 3 != 0) return {-1, -1};
    if (ones == 0) return {0, A.size() - 1};
    ones /= 3;
    int right = A.size() - 1;
    while (ones) if (A[right--]) --ones;
    string suffix(begin(s) + right + 1, end(s));
    size_t l = suffix.length();
    size_t left = s.find(suffix);
    if (left == std::string::npos) return {-1, -1};
    size_t mid = s.find(suffix, left + l);
    if (mid == std::string::npos 
       || mid + 2 * l > s.length()) return {-1, -1};
    return {left + l - 1, mid + l};
  }
};

The post 花花酱 LeetCode 927. Three Equal Parts appeared first on Huahua's Tech Road.

题目大意：问能否将一个数组分成两部分，每部分的平均值相同。

In a given integer array A, we must move every element of A to either list B or list C. (B and C initially start empty.)

Return true if and only if after such a move, it is possible that the average value of B is equal to the average value of C, and B and C are both non-empty.

Example :
Input: 
[1,2,3,4,5,6,7,8]
Output: true
Explanation: We can split the array into [1,4,5,8] and [2,3,6,7], and both of them have the average of 4.5.

Note:

• The length of A will be in the range [1, 30].
• A[i] will be in the range of [0, 10000].

Solution: Search

Time complexity: O(2^n)

Space complexity: O(n)

// Author: Huahua
// Running time: 771 ms
class Solution {
public:
  bool splitArraySameAverage(vector<int>& A) {
    std::sort(A.begin(), A.end());
    sum = std::accumulate(A.begin(), A.end(), 0);
    n = A.size();
    return dfs(A, 1, 0, 0);
  }
private:
  int sum;
  int n;
  bool dfs(const vector<int>& A, int c, int s, int cur) {
    if (c > A.size() / 2) return false;
    for (int i = s; i < A.size(); ++i) {
      cur += A[i];      
      if (cur * (n - c)  == (sum - cur) * c) return true;
      if (cur * (n - c)  > (sum - cur) * c) break;
      if (dfs(A, c + 1, i + 1, cur)) return true;
      cur -= A[i];
    }
    return false;
  } 
};

The post 花花酱 LeetCode 805. Split Array With Same Average appeared first on Huahua's Tech Road.