You would like to reformat the phone number in a certain manner. Firstly, remove all spaces and dashes. Then, group the digits from left to right into blocks of length 3 until there are 4 or fewer digits. The final digits are then grouped as follows:

• 2 digits: A single block of length 2.
• 3 digits: A single block of length 3.
• 4 digits: Two blocks of length 2 each.

The blocks are then joined by dashes. Notice that the reformatting process should never produce any blocks of length 1 and produce at most two blocks of length 2.

Return the phone number after formatting.

Example 1:

Input: number = "1-23-45 6"
Output: "123-456"
Explanation: The digits are "123456".
Step 1: There are more than 4 digits, so group the next 3 digits. The 1st block is "123".
Step 2: There are 3 digits remaining, so put them in a single block of length 3. The 2nd block is "456".
Joining the blocks gives "123-456".

Example 2:

Input: number = "123 4-567"
Output: "123-45-67"
Explanation: The digits are "1234567".
Step 1: There are more than 4 digits, so group the next 3 digits. The 1st block is "123".
Step 2: There are 4 digits left, so split them into two blocks of length 2. The blocks are "45" and "67".
Joining the blocks gives "123-45-67".

Example 3:

Input: number = "123 4-5678"
Output: "123-456-78"
Explanation: The digits are "12345678".
Step 1: The 1st block is "123".
Step 2: The 2nd block is "456".
Step 3: There are 2 digits left, so put them in a single block of length 2. The 3rd block is "78".
Joining the blocks gives "123-456-78".

Example 4:

Input: number = "12"
Output: "12"

Example 5:

Input: number = "--17-5 229 35-39475 "
Output: "175-229-353-94-75"

Constraints:

• 2 <= number.length <= 100
• number consists of digits and the characters '-' and ' '.
• There are at least two digits in number.

Solution:

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

// Author: Huahua
class Solution {
public:
  string reformatNumber(string number) {
    string ans;
    const int total = count_if(begin(number), end(number), 
                               [](char c) { return isdigit(c); });
    int l = 0;
    for (char c : number) {
      if (!isdigit(c)) continue;      
      ans += c;
      ++l;
      if ((l % 3 == 0 && total - l >= 4) ||
          (total % 3 != 0 && total - l == 2)
          || (total % 3 == 0 && total - l == 3))
        ans += "-";
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1694. Reformat Phone Number appeared first on Huahua's Tech Road.

Problem

Print a binary tree in an m*n 2D string array following these rules:

1. The row number m should be equal to the height of the given binary tree.
2. The column number n should always be an odd number.
3. The root node’s value (in string format) should be put in the exactly middle of the first row it can be put. The column and the row where the root node belongs will separate the rest space into two parts (left-bottom part and right-bottom part). You should print the left subtree in the left-bottom part and print the right subtree in the right-bottom part. The left-bottom part and the right-bottom part should have the same size. Even if one subtree is none while the other is not, you don’t need to print anything for the none subtree but still need to leave the space as large as that for the other subtree. However, if two subtrees are none, then you don’t need to leave space for both of them.
4. Each unused space should contain an empty string "".
5. Print the subtrees following the same rules.

Example 1:

Input:
     1
    /
   2
Output:
[["", "1", ""],
 ["2", "", ""]]

Example 2:

Input:
     1
    / \
   2   3
    \
     4
Output:
[["", "", "", "1", "", "", ""],
 ["", "2", "", "", "", "3", ""],
 ["", "", "4", "", "", "", ""]]

Example 3:

Input:
      1
     / \
    2   5
   / 
  3 
 / 
4 
Output:

[["",  "",  "", "",  "", "", "", "1", "",  "",  "",  "",  "", "", ""]
 ["",  "",  "", "2", "", "", "", "",  "",  "",  "",  "5", "", "", ""]
 ["",  "3", "", "",  "", "", "", "",  "",  "",  "",  "",  "", "", ""]
 ["4", "",  "", "",  "", "", "", "",  "",  "",  "",  "",  "", "", ""]]

Note: The height of binary tree is in the range of [1, 10].

Solution: Recursion

Compute the layers h of the tree.

shape of the output matrix: h * w (w = 2^h – 1)

pre-order to fill the output matrix

first layer’s root: y1 = 0, x1 = (l1 + r1) / 2 = (0 + w – 1) / 2 (center)

first layer’s left child (2nd layer): y2 = 1, x2 = (l2 + r2) = (l1 + (x1 – 1)) / 2 (center of the left half)

first layer’s right child(2nd layer): y1 = 2, x2 = (l2′ + r2′) = ((x1+1) + r1) / 2 (center of the right half)

…

Time complexity: O(m*n)

Space complexity: O(m*n)

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  vector<vector<string>> printTree(TreeNode* root) {
    int h = getHeight(root);
    int w = (1 << h) - 1; // 2 ^ h - 1
    vector<vector<string>> ans(h, vector<string>(w, ""));
    fill(root, ans, 0, 0, w - 1);
    return ans;
  }
private:
  int getHeight(TreeNode* root) {
    if (!root) return 0;
    return max(getHeight(root->left), getHeight(root->right)) + 1;
  }
    
  void fill(TreeNode* root, vector<vector<string>>& ans, int h, int l, int r){
    if (!root) return;
    int mid = (l + r) / 2;
    ans[h][mid] = std::to_string(root->val);
    fill(root->left, ans, h + 1, l, mid - 1);
    fill(root->right, ans, h + 1, mid + 1, r);
  }
};

"""
Author: Huahua
Running time: 44 ms
"""
class Solution:
  def printTree(self, root):
    def height(root):
      if not root: return 0
      return max(height(root.left), height(root.right)) + 1
    
    def fill(root, h, l, r):
      if not root: return
      mid = (l + r) // 2
      m[h][mid] = str(root.val)
      if root.left: fill(root.left, h + 1, l, mid - 1)
      if root.right: fill(root.right, h + 1, mid + 1, r)
    
    h = height(root)
    w = 2**h - 1
    m = [[""] * w for _ in range(h)]
    fill(root, 0, 0, w - 1)
    return m

The post 花花酱 LeetCode 655. Print Binary Tree appeared first on Huahua's Tech Road.

题目大意：把一串数字分成两段，输出所有合法的分法（可以加小数点）。

https://leetcode.com/problems/ambiguous-coordinates/description/

We had some 2-dimensional coordinates, like "(1, 3)" or "(2, 0.5)".  Then, we removed all commas, decimal points, and spaces, and ended up with the string S.  Return a list of strings representing all possibilities for what our original coordinates could have been.

Our original representation never had extraneous zeroes, so we never started with numbers like “00”, “0.0”, “0.00”, “1.0”, “001”, “00.01”, or any other number that can be represented with less digits.  Also, a decimal point within a number never occurs without at least one digit occuring before it, so we never started with numbers like “.1”.

The final answer list can be returned in any order.  Also note that all coordinates in the final answer have exactly one space between them (occurring after the comma.)

Example 1:
Input: "(123)"
Output: ["(1, 23)", "(12, 3)", "(1.2, 3)", "(1, 2.3)"]

Example 2:
Input: "(00011)"
Output:  ["(0.001, 1)", "(0, 0.011)"]
Explanation: 
0.0, 00, 0001 or 00.01 are not allowed.

Example 3:
Input: "(0123)"
Output: ["(0, 123)", "(0, 12.3)", "(0, 1.23)", "(0.1, 23)", "(0.1, 2.3)", "(0.12, 3)"]

Example 4:
Input: "(100)"
Output: [(10, 0)]
Explanation: 
1.0 is not allowed.

Solution: Brute Force

Time complexity: O(n^3)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: 16 ms
class Solution {
public:
  vector<string> ambiguousCoordinates(string S) {
    vector<string> ans;
    int n = S.length();
    for (int l1 = 1; l1 <= n - 3; ++l1) {      
      int l2 = n - l1 - 2;
      string s1 = S.substr(1, l1);
      string s2 = S.substr(l1 + 1, l2);      
      if (valid(s1) && valid(s2))
        ans.push_back("(" + s1 + ", " + s2 + ")");
      
      for (int i = 0; i < l1; ++i) {
        string ts1 = s1;
        if (i > 0) ts1.insert(i, ".");        
        if (!valid(ts1)) continue;
        for (int j = 0; j < l2; ++j) {
          if (i == 0 && j == 0) continue;
          string ts2 = s2;
          if (j > 0) ts2.insert(j, ".");          
          if (!valid(ts2)) continue;          
          ans.push_back("(" + ts1 + ", " + ts2 + ")");
        }
      }
    }
    
    return ans;
  }
private:    
  bool valid(const string& s) {
    bool p = false; // has "."
    bool d = false; // has digits in front of "."
    int zeros = 0;  // leading zeros
    int i = 0;
    while (s[zeros] == '0' && zeros < s.length()) ++zeros;
    for (int i = zeros; i < s.length(); ++i) {
      if (!p && isdigit(s[i])) d = true;
      if (s[i] == '.') p = true;
    }
    if (zeros == 1 && s != "0" && !p || zeros > 1) return false;
    if (p && (s.back() == '0' || s.back() == '.' || zeros > 0 && d)) return false;    
    return true;
  }
};

The post 花花酱 LeetCode 816. Ambiguous Coordinates appeared first on Huahua's Tech Road.