• s[i] = '0' denotes that the ith building is an office and
• s[i] = '1' denotes that the ith building is a restaurant.

As a city official, you would like to select 3 buildings for random inspection. However, to ensure variety, no two consecutive buildings out of the selected buildings can be of the same type.

• For example, given s = "001101", we cannot select the 1st, 3rd, and 5th buildings as that would form "011" which is not allowed due to having two consecutive buildings of the same type.

Return the number of valid ways to select 3 buildings.

Example 1:

Input: s = "001101"
Output: 6
Explanation: 
The following sets of indices selected are valid:
- [0,2,4] from "001101" forms "010"
- [0,3,4] from "001101" forms "010"
- [1,2,4] from "001101" forms "010"
- [1,3,4] from "001101" forms "010"
- [2,4,5] from "001101" forms "101"
- [3,4,5] from "001101" forms "101"
No other selection is valid. Thus, there are 6 total ways.

Example 2:

Input: s = "11100"
Output: 0
Explanation: It can be shown that there are no valid selections.

Constraints:

• 3 <= s.length <= 105
• s[i] is either '0' or '1'.

Solution: DP

The brute force solution will take O(n³) which will lead to TLE.

Since the only two valid cases are “010” and “101”.

We just need to count how many 0s and 1s, thus we can count 01s and 10s and finally 010s and 101s.

// Author: Huahua
class Solution {
public:
  long long numberOfWays(string s) {    
    long long c0 = 0, c1 = 0, c01 = 0, c10 = 0, c101 = 0, c010 = 0;
    for (char c : s) {
      if (c == '0') {
        ++c0;
        c10 += c1;
        c010 += c01;
      } else {
        ++c1;
        c01 += c0;
        c101 += c10;
      }
    }
    return c101 + c010;
  }
};

The post 花花酱 LeetCode 2222. Number of Ways to Select Buildings appeared first on Huahua's Tech Road.

Alice and Bob are playing a game where they take alternating turns removing pieces from the line. In this game, Alice moves first.

• Alice is only allowed to remove a piece colored 'A' if both its neighbors are also colored 'A'. She is not allowed to remove pieces that are colored 'B'.
• Bob is only allowed to remove a piece colored 'B' if both its neighbors are also colored 'B'. He is not allowed to remove pieces that are colored 'A'.
• Alice and Bob cannot remove pieces from the edge of the line.
• If a player cannot make a move on their turn, that player loses and the other player wins.

Assuming Alice and Bob play optimally, return true if Alice wins, or return false if Bob wins.

Example 1:

Input: colors = "AAABABB"
Output: true
Explanation:
AAABABB -> AABABB
Alice moves first.
She removes the second 'A' from the left since that is the only 'A' whose neighbors are both 'A'.

Now it's Bob's turn.
Bob cannot make a move on his turn since there are no 'B's whose neighbors are both 'B'.
Thus, Alice wins, so return true.

Example 2:

Input: colors = "AA"
Output: false
Explanation:
Alice has her turn first.
There are only two 'A's and both are on the edge of the line, so she cannot move on her turn.
Thus, Bob wins, so return false.

Example 3:

Input: colors = "ABBBBBBBAAA"
Output: false
Explanation:
ABBBBBBBAAA -> ABBBBBBBAA
Alice moves first.
Her only option is to remove the second to last 'A' from the right.

ABBBBBBBAA -> ABBBBBBAA
Next is Bob's turn.
He has many options for which 'B' piece to remove. He can pick any.

On Alice's second turn, she has no more pieces that she can remove.
Thus, Bob wins, so return false.

Constraints:

• 1 <= colors.length <= 105
• colors consists of only the letters 'A' and 'B'

Solution: Counting

Count how many ‘AAA’s and ‘BBB’s.

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

// Author: Huahua
class Solution {
public:
  bool winnerOfGame(string colors) {
    const int n = colors.size();
    int count = 0;
    for (int i = 1; i < n - 1; ++i)
      if (colors[i - 1] == colors[i] &&
          colors[i] == colors[i + 1])
        count += (colors[i] == 'A' ? 1 : -1);    
    return count > 0;
  }
};

The post 花花酱 LeetCode 2038. Remove Colored Pieces if Both Neighbors are the Same Color appeared first on Huahua's Tech Road.

In one operation, pick two distinct indices i and j, where words[i] is a non-empty string, and move any character from words[i] to any position in words[j].

Return true if you can make every string in words equal using any number of operations, and false otherwise.

Example 1:

Input: words = ["abc","aabc","bc"]
Output: true
Explanation: Move the first 'a' in words[1] to the front of words[2],
to make words[1] = "abc" and words[2] = "abc".
All the strings are now equal to "abc", so return true.

Example 2:

Input: words = ["ab","a"]
Output: false
Explanation: It is impossible to make all the strings equal using the operation.

Constraints:

• 1 <= words.length <= 100
• 1 <= words[i].length <= 100
• words[i] consists of lowercase English letters.

Solution: Hashtable

Count the frequency of each character, it must be a multiplier of n such that we can evenly distribute it to all the words.
e.g. n = 3, a = 9, b = 6, c = 3, each word will be “aaabbc”.

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

// Author: Huahua
class Solution {
public:
  bool makeEqual(vector<string>& words) {
    vector<int> freq(26);
    for (const auto& word : words)
      for (char c : word)
        ++freq[c - 'a'];    
    for (int f : freq)
      if (f % words.size()) return false;        
    return true;
  }
};

# Author: Huahua
class Solution:
  def makeEqual(self, words: List[str]) -> bool:
    return all(c % len(words) == 0 for c in Counter(''.join(words)).values())

The post 花花酱 LeetCode 1897. Redistribute Characters to Make All Strings Equal appeared first on Huahua's Tech Road.

• For example, if the sticks are arranged [1,3,2,5,4], then the sticks with lengths 1, 3, and 5 are visible from the left.

Given n and k, return the number of such arrangements. Since the answer may be large, return it modulo 109 + 7.

Example 1:

Input: n = 3, k = 2
Output: 3
Explanation: [1,3,2], [2,3,1], and [2,1,3] are the only arrangements such that exactly 2 sticks are visible.
The visible sticks are underlined.

Example 2:

Input: n = 5, k = 5
Output: 1
Explanation: [1,2,3,4,5] is the only arrangement such that all 5 sticks are visible.
The visible sticks are underlined.

Example 3:

Input: n = 20, k = 11
Output: 647427950
Explanation: There are 647427950 (mod 109 + 7) ways to rearrange the sticks such that exactly 11 sticks are visible.

Constraints:

• 1 <= n <= 1000
• 1 <= k <= n

Solution: DP

dp(n, k) = dp(n – 1, k – 1) + (n-1) * dp(n-1, k)

Time complexity: O(n*k)
Space complexity: O(n*k) -> O(k)

// Author: Huahua
class Solution {
public:
  int rearrangeSticks(int n, int k) {
    constexpr int kMod = 1e9 + 7;
    vector<vector<long>> dp(n + 1, vector<long>(k + 1));        
    for (int j = 1; j <= k; ++j) {
      dp[j][j] = 1;
      for (int i = j + 1; i <= n; ++i)
        dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j] * (i - 1)) % kMod;
    }
    return dp[n][k];
  }
};

# Author: Huahua
class Solution:
  @lru_cache(maxsize=None)
  def rearrangeSticks(self, n: int, k: int) -> int:
    if k == 0: return 0
    if k == n or n <= 2: return 1
    return (self.rearrangeSticks(n - 1, k - 1) + 
            (n - 1) * self.rearrangeSticks(n - 1, k)) % (10**9 + 7)

The post 花花酱 LeetCode 1866. Number of Ways to Rearrange Sticks With K Sticks Visible appeared first on Huahua's Tech Road.

Multiple users can perform actions simultaneously, and a single user can perform multiple actions in the same minute.

The user active minutes (UAM) for a given user is defined as the number of unique minutes in which the user performed an action on LeetCode. A minute can only be counted once, even if multiple actions occur during it.

You are to calculate a 1-indexed array answer of size k such that, for each j (1 <= j <= k), answer[j] is the number of users whose UAM equals j.

Return the array answer as described above.

Example 1:

Input: logs = [[0,5],[1,2],[0,2],[0,5],[1,3]], k = 5
Output: [0,2,0,0,0]
Explanation:
The user with ID=0 performed actions at minutes 5, 2, and 5 again. Hence, they have a UAM of 2 (minute 5 is only counted once).
The user with ID=1 performed actions at minutes 2 and 3. Hence, they have a UAM of 2.
Since both users have a UAM of 2, answer[2] is 2, and the remaining answer[j] values are 0.

Example 2:

Input: logs = [[1,1],[2,2],[2,3]], k = 4
Output: [1,1,0,0]
Explanation:
The user with ID=1 performed a single action at minute 1. Hence, they have a UAM of 1.
The user with ID=2 performed actions at minutes 2 and 3. Hence, they have a UAM of 2.
There is one user with a UAM of 1 and one with a UAM of 2.
Hence, answer[1] = 1, answer[2] = 1, and the remaining values are 0.

Constraints:

• 1 <= logs.length <= 104
• 0 <= IDi <= 109
• 1 <= timei <= 105
• k is in the range [The maximum UAM for a user, 105].

Solution: Hashsets in a Hashtable

key: user_id, value: set{time}

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

class Solution {
public:
  vector<int> findingUsersActiveMinutes(vector<vector<int>>& logs, int k) {
    unordered_map<int, unordered_set<int>> m;
    vector<int> ans(k);
    for (const auto& log : logs)
      m[log[0]].insert(log[1]);
    for (const auto& [id, s] : m)
      ++ans[s.size() - 1];
    return ans;
  }
};

The post 花花酱 LeetCode 1817. Finding the Users Active Minutes appeared first on Huahua's Tech Road.

A string is homogenous if all the characters of the string are the same.

A substring is a contiguous sequence of characters within a string.

Example 1:

Input: s = "abbcccaa"
Output: 13
Explanation: The homogenous substrings are listed as below:
"a"   appears 3 times.
"aa"  appears 1 time.
"b"   appears 2 times.
"bb"  appears 1 time.
"c"   appears 3 times.
"cc"  appears 2 times.
"ccc" appears 1 time.
3 + 1 + 2 + 1 + 3 + 2 + 1 = 13.

Example 2:

Input: s = "xy"
Output: 2
Explanation: The homogenous substrings are "x" and "y".

Example 3:

Input: s = "zzzzz"
Output: 15

Constraints:

• 1 <= s.length <= 105
• s consists of lowercase letters.

Solution: Counting

Let m be the length of the longest homogenous substring, # of homogenous substring is m * (m + 1) / 2.
e.g. aaabb
“aaa” => m = 3, # = 3 * (3 + 1) / 2 = 6
“bb” => m = 2, # = 2 * (2+1) / 2 = 3
Total = 6 + 3 = 9

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

// Author: Huahua
class Solution {
public:
  int countHomogenous(string s) {
    constexpr int kMod = 1e9 + 7;
    const int n = s.length();
    long ans = 0;
    for (long i = 0, j = 0; i < n; i = j) {
      while (j < n && s[i] == s[j]) ++j;
      ans += (j - i) * (j - i + 1) / 2;
    }
    return ans % kMod;
  }
};

The post 花花酱 LeetCode 1759. Count Number of Homogenous Substrings appeared first on Huahua's Tech Road.

The string is called alternating if no two adjacent characters are equal. For example, the string "010" is alternating, while the string "0100" is not.

Return the minimum number of operations needed to make s alternating.

Example 1:

Input: s = "0100"
Output: 1
Explanation: If you change the last character to '1', s will be "0101", which is alternating.

Example 2:

Input: s = "10"
Output: 0
Explanation: s is already alternating.

Example 3:

Input: s = "1111"
Output: 2
Explanation: You need two operations to reach "0101" or "1010".

Constraints:

• 1 <= s.length <= 104
• s[i] is either '0' or '1'.

Solution: Two Counters

The final string is either 010101… or 101010…
We just need two counters to record the number of changes needed to transform the original string to those two final strings.

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

// Author: Huahua
class Solution {
public:
  int minOperations(string s) {
    int c1 = 0, c2 = 0;
    for (int i = 0; i < s.length(); ++i) {
      c1 += (s[i] - '0' == i % 2);
      c2 += (s[i] - '0' != i % 2);
    }
    return min(c1, c2);
  }
};

The post 花花酱 LeetCode 1758. Minimum Changes To Make Alternating Binary String appeared first on Huahua's Tech Road.

Two strings are alike if they have the same number of vowels ('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'). Notice that s contains uppercase and lowercase letters.

Return true if a and b are alike. Otherwise, return false.

Example 1:

Input: s = "book"
Output: true
Explanation: a = "bo" and b = "ok". a has 1 vowel and b has 1 vowel. Therefore, they are alike.

Example 2:

Input: s = "textbook"
Output: false
Explanation: a = "text" and b = "book". a has 1 vowel whereas b has 2. Therefore, they are not alike.
Notice that the vowel o is counted twice.

Example 3:

Input: s = "MerryChristmas"
Output: false

Example 4:

Input: s = "AbCdEfGh"
Output: true

Constraints:

• 2 <= s.length <= 1000
• s.length is even.
• s consists of uppercase and lowercase letters.

Solution: Counting

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

# Author: Huahua
class Solution:
  def halvesAreAlike(self, s: str) -> bool:
    def count(s: str) -> int:
      return sum(c in 'aeiouAEIOU' for c in s)
    n = len(s)
    return count(s[:n//2]) == count(s[n//2:])

The post 花花酱 LeetCode 1704. Determine if String Halves Are Alike appeared first on Huahua's Tech Road.

• Operation 1: If the number contains the substring "00", you can replace it with "10".
  • For example, "00010" -> "10010“
• Operation 2: If the number contains the substring "10", you can replace it with "01".
  • For example, "00010" -> "00001"

Return the maximum binary string you can obtain after any number of operations. Binary string x is greater than binary string y if x‘s decimal representation is greater than y‘s decimal representation.

Example 1:

Input: binary = "000110"
Output: "111011"
Explanation: A valid transformation sequence can be:
"000110" -> "000101" 
"000101" -> "100101" 
"100101" -> "110101" 
"110101" -> "110011" 
"110011" -> "111011"

Example 2:

Input: binary = "01"
Output: "01"
Explanation: "01" cannot be transformed any further.

Constraints:

• 1 <= binary.length <= 105
• binary consist of '0' and '1'.

Solution: Greedy + Counting

Leading 1s are good, no need to change them.
For the rest of the string
1. Apply operation 2 to make the string into 3 parts, leading 1s, middle 0s and tailing 1s.
e.g. 11010101 => 11001101 => 11001011 => 11000111
2. Apply operation 1 to make flip zeros to ones except the last one.
e.g. 11000111 => 11100111 => 11110111

There will be only one zero (if the input string is not all 1s) is the final largest string, the position of the zero is leading 1s + zeros – 1.

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

class Solution {
public:
  string maximumBinaryString(string s) {
    const int n = s.length();
    int l = 0;
    int z = 0;
    for (char& c : s) {
      if (c == '0') {
        ++z;
      } else if (z == 0) { // leading 1s      
        ++l;
      }
      c = '1';
    }
    if (l != n) s[l + z - 1] = '0';
    return s;
  }
};

The post 花花酱 LeetCode 1702. Maximum Binary String After Change appeared first on Huahua's Tech Road.

A pattern is a subarray (consecutive sub-sequence) that consists of one or more values, repeated multiple times consecutively without overlapping. A pattern is defined by its length and the number of repetitions.

Return true if there exists a pattern of length m that is repeated k or more times, otherwise return false.

Example 1:

Input: arr = [1,2,4,4,4,4], m = 1, k = 3
Output: true
Explanation: The pattern (4) of length 1 is repeated 4 consecutive times. Notice that pattern can be repeated k or more times but not less.

Example 2:

Input: arr = [1,2,1,2,1,1,1,3], m = 2, k = 2
Output: true
Explanation: The pattern (1,2) of length 2 is repeated 2 consecutive times. Another valid pattern (2,1) is also repeated 2 times.

Example 3:

Input: arr = [1,2,1,2,1,3], m = 2, k = 3
Output: false
Explanation: The pattern (1,2) is of length 2 but is repeated only 2 times. There is no pattern of length 2 that is repeated 3 or more times.

Example 4:

Input: arr = [1,2,3,1,2], m = 2, k = 2
Output: false
Explanation: Notice that the pattern (1,2) exists twice but not consecutively, so it doesn't count.

Example 5:

Input: arr = [2,2,2,2], m = 2, k = 3
Output: false
Explanation: The only pattern of length 2 is (2,2) however it's repeated only twice. Notice that we do not count overlapping repetitions.

Constraints:

• 2 <= arr.length <= 100
• 1 <= arr[i] <= 100
• 1 <= m <= 100
• 2 <= k <= 100

Solution 1: Brute Force

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

class Solution {
public:
  bool containsPattern(vector<int>& arr, int m, int k) {
    const int n = arr.size();
    for (int i = 0; i + m * k <= n; ++i) {
      bool valid = true;
      for (int j = 1; j < k && valid; ++j)
        for (int p = 0; p < m && valid; ++p)
          if (arr[i + j * m + p] != arr[i + p])
            valid = false;
      if (valid) return true;
    }
    return false;
  }
};

Solution 2: Shift and count

Since we need k consecutive subarrays, we can compare arr[i] with arr[i + m], if they are the same, increase the counter, otherwise reset the counter. If the counter reaches (k – 1) * m, it means we found k consecutive subarrays of length m.

ex1: arr = [1,2,4,4,4,4], m = 1, k = 3
i arr[i], arr[i + m] counter
0 1. 2. 0
0 2. 4. 0
0 4. 4. 1
0 4. 4. 2. <– found

ex2: arr = [1,2,1,2,1,1,1,3], m = 2, k = 2
i arr[i], arr[i + m] counter
0 1. 1. 1
0 2. 2. 2 <– found

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

class Solution {
public:
  bool containsPattern(vector<int>& arr, int m, int k) {
    const int n = arr.size();
    int count = 0;
    for (int i = 0; i + m < n; ++i) {      
      if (arr[i] == arr[i + m]) {
        if (++count == (k - 1) * m) return true;
      } else {
        count = 0;
      }      
    }
    return false;
  }
};

The post 花花酱 LeetCode 1566. Detect Pattern of Length M Repeated K or More Times appeared first on Huahua's Tech Road.

Example 1:

Input: arr = [2,6,4,1]
Output: false
Explanation: There are no three consecutive odds.

Example 2:

Input: arr = [1,2,34,3,4,5,7,23,12]
Output: true
Explanation: [5,7,23] are three consecutive odds.

Constraints:

• 1 <= arr.length <= 1000
• 1 <= arr[i] <= 1000

Solution: Counting

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

class Solution {
public:
  bool threeConsecutiveOdds(vector<int>& arr) {       
    int count = 0;
    for (int x : arr) {
      if (x & 1) {
        if (++count == 3) return true;
      } else {
        count = 0;
      }
    }
    return false;      
  }
};

The post 花花酱 LeetCode 1550. Three Consecutive Odds appeared first on Huahua's Tech Road.

• Any left parenthesis '(' must have a corresponding two consecutive right parenthesis '))'.
• Left parenthesis '(' must go before the corresponding two consecutive right parenthesis '))'.

For example, "())", "())(())))" and "(())())))" are balanced, ")()", "()))" and "(()))" are not balanced.

You can insert the characters ‘(‘ and ‘)’ at any position of the string to balance it if needed.

Return the minimum number of insertions needed to make s balanced.

Example 1:

Input: s = "(()))"
Output: 1
Explanation: The second '(' has two matching '))', but the first '(' has only ')' matching. We need to to add one more ')' at the end of the string to be "(())))" which is balanced.

Example 2:

Input: s = "())"
Output: 0
Explanation: The string is already balanced.

Example 3:

Input: s = "))())("
Output: 3
Explanation: Add '(' to match the first '))', Add '))' to match the last '('.

Example 4:

Input: s = "(((((("
Output: 12
Explanation: Add 12 ')' to balance the string.

Example 5:

Input: s = ")))))))"
Output: 5
Explanation: Add 4 '(' at the beginning of the string and one ')' at the end. The string becomes "(((())))))))".

Constraints:

• 1 <= s.length <= 10^5
• s consists of '(' and ')' only.

Solution: Counting

Count how many close parentheses we need.

1. if s[i] is ‘)’, we decrease the counter.
   1. if counter becomes negative, means we need to insert ‘(‘
      1. increase ans by 1, increase the counter by 2, we need one more ‘)’
      2. ‘)’ -> ‘()’
2. if s[i] is ‘(‘
   1. if we have an odd counter, means there is a unbalanced ‘)’ e.g. ‘(()(‘, counter is 3
      1. need to insert ‘)’, decrease counter, increase ans
      2. ‘(()(‘ -> ‘(())(‘, counter = 2
   2. increase counter by 2, each ‘(‘ needs two ‘)’s. ‘(())(‘ -> counter = 4
3. Once done, if counter is greater than zero, we need insert that much ‘)s’
   1. counter = 5, ‘((()’ -> ‘((())))))’

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

class Solution {
public:
  int minInsertions(string s) {
    int ans = 0;
    int close = 0; // # of ')' needed.    
    for (char c : s) {
      if (c == ')') {
        if (--close < 0) {          
          // need to insert one '('
          // ')' -> '()'
          ++ans;
          close += 2;
        }
      } else {
        if (close & 1) {          
          // need to insert one ')'
          // case '(()(' -> '(())('
          --close;
          ++ans;
        }
        close += 2; // need two ')'s
      }
    }
    return ans + close;
  }
};

The post 花花酱 LeetCode 1541. Minimum Insertions to Balance a Parentheses String appeared first on Huahua's Tech Road.

You should build the array arr which has the following properties:

• arr has exactly n integers.
• 1 <= arr[i] <= m where (0 <= i < n).
• After applying the mentioned algorithm to arr, the value search_cost is equal to k.

Return the number of ways to build the array arr under the mentioned conditions. As the answer may grow large, the answer must be computed modulo 10^9 + 7.

Example 1:

Input: n = 2, m = 3, k = 1
Output: 6
Explanation: The possible arrays are [1, 1], [2, 1], [2, 2], [3, 1], [3, 2] [3, 3]

Example 2:

Input: n = 5, m = 2, k = 3
Output: 0
Explanation: There are no possible arrays that satisify the mentioned conditions.

Example 3:

Input: n = 9, m = 1, k = 1
Output: 1
Explanation: The only possible array is [1, 1, 1, 1, 1, 1, 1, 1, 1]

Example 4:

Input: n = 50, m = 100, k = 25
Output: 34549172
Explanation: Don't forget to compute the answer modulo 1000000007

Example 5:

Input: n = 37, m = 17, k = 7
Output: 418930126

Constraints:

• 1 <= n <= 50
• 1 <= m <= 100
• 0 <= k <= n

Solution: DP

dp[n][m][k] := ways to build given n,m,k.

dp[n][m][k] = sum(dp[n-1][m][k] + dp[n-1][i-1][k-1] – dp[n-1][i-1][k]), 1 <= i <= m
dp[1][m][1] = m
dp[n][m][k] = 0 if k < 1 or k > m or k > n

Time complexity: O(n*m^2*k)
Space complexity: O(n*m*k)

// Author: Huahua
int mem[51][101][51] = {0};
class Solution {
public:
  int numOfArrays(int n, int m, int k) {
    const int kMod = 1e9 + 7;    
    function<int(int, int, int)> dp = [&dp](int n, int m, int k) {
      if (k < 1 || k > m || k > n) return 0;
      if (n == 1 && k == 1) return m;
      if (mem[n][m][k]) return mem[n][m][k];      
      long ans = 0;
      for (int i = 1; i <= m; ++i) {
        ans += dp(n - 1, m, k);
        ans += dp(n - 1, i - 1, k - 1);
        ans -= dp(n - 1, i - 1, k);
        ans = (ans + kMod) % kMod;
      }
      return mem[n][m][k] = ans;
    };    
    return dp(n, m, k);
  }
};

The post 花花酱 LeetCode 1420. Build Array Where You Can Find The Maximum Exactly K Comparisons appeared first on Huahua's Tech Road.

1. Pick the smallest character from s and append it to the result.
2. Pick the smallest character from s which is greater than the last appended character to the result and append it.
3. Repeat step 2 until you cannot pick more characters.
4. Pick the largest character from s and append it to the result.
5. Pick the largest character from s which is smaller than the last appended character to the result and append it.
6. Repeat step 5 until you cannot pick more characters.
7. Repeat the steps from 1 to 6 until you pick all characters from s.

In each step, If the smallest or the largest character appears more than once you can choose any occurrence and append it to the result.

Return the result string after sorting s with this algorithm.

Example 1:

Input: s = "aaaabbbbcccc"
Output: "abccbaabccba"
Explanation: After steps 1, 2 and 3 of the first iteration, result = "abc"
After steps 4, 5 and 6 of the first iteration, result = "abccba"
First iteration is done. Now s = "aabbcc" and we go back to step 1
After steps 1, 2 and 3 of the second iteration, result = "abccbaabc"
After steps 4, 5 and 6 of the second iteration, result = "abccbaabccba"

Example 2:

Input: s = "rat"
Output: "art"
Explanation: The word "rat" becomes "art" after re-ordering it with the mentioned algorithm.

Example 3:

Input: s = "leetcode"
Output: "cdelotee"

Example 4:

Input: s = "ggggggg"
Output: "ggggggg"

Example 5:

Input: s = "spo"
Output: "ops"

Constraints:

• 1 <= s.length <= 500
• s contains only lower-case English letters.

Solution: Counting frequency of each character

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

// Author: Huahua
class Solution {
public:
  string sortString(string s) {
    vector<int> count(26);
    for (char c : s) ++count[c - 'a'];
    string ans;
    while (ans.length() != s.length()) {
      for (char c = 'a'; c <= 'z'; ++c)
        if (--count[c - 'a'] >= 0)
          ans += c;
      for (char c = 'z'; c >= 'a'; --c)
        if (--count[c - 'a'] >= 0)
          ans += c;      
    }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def sortString(self, s: str) -> str:
    seq = string.ascii_lowercase + string.ascii_lowercase[::-1]
    count = collections.Counter(s)
    ans = ""
    while len(ans) != len(s):
      for c in seq:
        if count[c] > 0:
          ans += c
          count[c] -= 1
    return ans

The post 花花酱 LeetCode 1370. Increasing Decreasing String appeared first on Huahua's Tech Road.

Return the answer in an array.

Example 1:

Input: nums = [8,1,2,2,3]
Output: [4,0,1,1,3]
Explanation: 
For nums[0]=8 there exist four smaller numbers than it (1, 2, 2 and 3). 
For nums[1]=1 does not exist any smaller number than it.
For nums[2]=2 there exist one smaller number than it (1). 
For nums[3]=2 there exist one smaller number than it (1). 
For nums[4]=3 there exist three smaller numbers than it (1, 2 and 2).

Example 2:

Input: nums = [6,5,4,8]
Output: [2,1,0,3]

Example 3:

Input: nums = [7,7,7,7]
Output: [0,0,0,0]

Constraints:

• 2 <= nums.length <= 500
• 0 <= nums[i] <= 100

Solution 1: Brute Force

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

// Author: Huahua
class Solution {
public:
  vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
    const int n = nums.size();
    vector<int> ans(n);
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < n; ++j)
        if (i != j && nums[j] < nums[i]) ++ans[i];          
    return ans;
  }
};

Solution 2: Sort + Binary Search

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

// Author: Huahua
class Solution {
public:
  vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
    const int n = nums.size();
    vector<int> s(nums);
    sort(begin(s), end(s));    
    vector<int> ans(n);
    for (int i = 0; i < n; ++i)
      ans[i] = distance(begin(s), lower_bound(begin(s), end(s), nums[i]));
    return ans;
  }
};

Solution 3: Cumulative frequency

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

// Author: Huahua
class Solution {
public:
  vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
    vector<int> f(101);
    for (int x : nums) ++f[x];
    partial_sum(begin(f), end(f), begin(f));    
    for (int& x : nums) 
      x = x == 0 ? 0 : f[x - 1];
    return nums;
  }
};

The post 花花酱 LeetCode 1365. How Many Numbers Are Smaller Than the Current Number appeared first on Huahua's Tech Road.