Add a pair of parentheses to expression such that after the addition of parentheses, expression is a valid mathematical expression and evaluates to the smallest possible value. The left parenthesis must be added to the left of '+' and the right parenthesis must be added to the right of '+'.

Return expression after adding a pair of parentheses such that expression evaluates to the smallest possible value. If there are multiple answers that yield the same result, return any of them.

The input has been generated such that the original value of expression, and the value of expression after adding any pair of parentheses that meets the requirements fits within a signed 32-bit integer.

Example 1:

Input: expression = "247+38"
Output: "2(47+38)"
Explanation: The expression evaluates to 2 * (47 + 38) = 2 * 85 = 170.
Note that "2(4)7+38" is invalid because the right parenthesis must be to the right of the '+'.
It can be shown that 170 is the smallest possible value.

Example 2:

Input: expression = "12+34"
Output: "1(2+3)4"
Explanation: The expression evaluates to 1 * (2 + 3) * 4 = 1 * 5 * 4 = 20.

Example 3:

Input: expression = "999+999"
Output: "(999+999)"
Explanation: The expression evaluates to 999 + 999 = 1998.

Constraints:

• 3 <= expression.length <= 10
• expression consists of digits from '1' to '9' and '+'.
• expression starts and ends with digits.
• expression contains exactly one '+'.
• The original value of expression, and the value of expression after adding any pair of parentheses that meets the requirements fits within a signed 32-bit integer.

Solution: Brute Force

Try all possible positions to add parentheses and evaluate the new expression.

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

// Author: Huahua
class Solution {
public:
  string minimizeResult(string expression) {
    const int n = expression.size();
    auto p = expression.find('+');
    int best = INT_MAX;
    string ans;
    for (int l = 0; l < p; ++l)
      for (int r = p + 2; r < n + 1; ++r) {
        const int m1 = l ? stoi(expression.substr(0, l)) : 1;
        const int m2 = (r < n) ? stoi(expression.substr(r)) : 1;
        const int n1 = stoi(expression.substr(l, p));
        const int n2 = stoi(expression.substr(p + 1, r - p - 1));
        const int cur = m1 * (n1 + n2) * m2;
        if (cur < best) {
          best = cur;
          ans = expression;
          ans.insert(l, "(");
          ans.insert(r + 1, ")");
        }
      }
    return ans;
  }
};

The post 花花酱 LeetCode 2232. Minimize Result by Adding Parentheses to Expression appeared first on Huahua's Tech Road.

• For example, "()1|1" and "(1)&()" are not valid while "1", "(((1))|(0))", and "1|(0&(1))" are valid expressions.

Return the minimum cost to change the final value of the expression.

• For example, if expression = "1|1|(0&0)&1", its value is 1|1|(0&0)&1 = 1|1|0&1 = 1|0&1 = 1&1 = 1. We want to apply operations so that the new expression evaluates to 0.

The cost of changing the final value of an expression is the number of operations performed on the expression. The types of operations are described as follows:

• Turn a '1' into a '0'.
• Turn a '0' into a '1'.
• Turn a '&' into a '|'.
• Turn a '|' into a '&'.

Note: '&' does not take precedence over '|' in the order of calculation. Evaluate parentheses first, then in left-to-right order.

Example 1:

Input: expression = "1&(0|1)"
Output: 1
Explanation: We can turn "1&(0|1)" into "1&(0&1)" by changing the '|' to a '&' using 1 operation.
The new expression evaluates to 0. 

Example 2:

<strong>Input:</strong> expression = "(0&amp;0)&amp;(0&amp;0&amp;0)"
<strong>Output:</strong> 3
<strong>Explanation:</strong> We can turn "(0<strong>&amp;0</strong>)<strong><u>&amp;</u></strong>(0&amp;0&amp;0)" into "(0<strong>|1</strong>)<strong>|</strong>(0&amp;0&amp;0)" using 3 operations.
The new expression evaluates to 1.

Example 3:

Input: expression = "(0|(1|0&1))"
Output: 1
Explanation: We can turn "(0|(1|0&1))" into "(0|(0|0&1))" using 1 operation.
The new expression evaluates to 0.

Constraints:

• 1 <= expression.length <= 105
• expression only contains '1','0','&','|','(', and ')'
• All parentheses are properly matched.
• There will be no empty parentheses (i.e: "()" is not a substring of expression).

Solution: DP, Recursion / Simulation w/ Stack

For each expression, stores the min cost to change value to 0 and 1.

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

class Solution {
public:
  int minOperationsToFlip(string expression) {
    stack<array<int, 3>> s;
    s.push({0, 0, 0});
    for (char e : expression) {
      if (e == '(')
        s.push({0, 0, 0});
      else if (e == '&' || e == '|')
        s.top()[2] = e;
      else {        
        if (isdigit(e)) s.push({e != '0', e != '1', 0});
        auto [r0, r1, _] = s.top(); s.pop();
        auto [l0, l1, op] = s.top(); s.pop();
        if (op == '&') {
          s.push({min(l0, r0),
                  min(l1 + r1, min(l1, r1) + 1),
                  0});
        } else if (op == '|') {
          s.push({min(l0 + r0, min(l0, r0) + 1),
                  min(l1, r1),
                  0});
        } else {
          s.push({r0, r1, 0});
        }
      }
    }
    return max(s.top()[0], s.top()[1]);
  }
};

The post 花花酱 LeetCode 1896. Minimum Cost to Change the Final Value of Expression appeared first on Huahua's Tech Road.

Implement atoi which converts a string to an integer.

The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible, and interprets them as a numerical value.

The string can contain additional characters after those that form the integral number, which are ignored and have no effect on the behavior of this function.

If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.

If no valid conversion could be performed, a zero value is returned.

Note:

• Only the space character ' ' is considered as whitespace character.
• Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2³¹,  2³¹ − 1]. If the numerical value is out of the range of representable values, INT_MAX (2³¹ − 1) or INT_MIN (−2³¹) is returned.

Example 1:

Input: "42"
Output: 42

Example 2:

Input: "   -42"
Output: -42
Explanation: The first non-whitespace character is '-', which is the minus sign.
             Then take as many numerical digits as possible, which gets 42.

Example 3:

Input: "4193 with words"
Output: 4193
Explanation: Conversion stops at digit '3' as the next character is not a numerical digit.

Example 4:

Input: "words and 987"
Output: 0
Explanation: The first non-whitespace character is 'w', which is not a numerical 
             digit or a +/- sign. Therefore no valid conversion could be performed.

Example 5:

Input: "-91283472332"
Output: -2147483648
Explanation: The number "-91283472332" is out of the range of a 32-bit signed integer.
             Thefore INT_MIN (−231) is returned.

Solution: Simulation

You need to handle all corner cases in order to pass…

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int myAtoi(const string& s) {
    long long ans = 0;
    int neg = 0;
    int pos = 0;
    bool p = false; // has '.'
    bool a = false; // has letters
    bool n = false; // has number
    for (int i = 0; i < s.length(); ++i) {      
      if (s[i] == ' ') { if (n || neg || pos) break; }
      else if (s[i] == '-') { if (n) break; else neg++; }
      else if (s[i] == '+') { if (n) break; else pos++; }
      else if (s[i] == '.') p = true;
      else if (s[i] >= '0' && s[i] <= '9' && !p && !a) {
        ans = ans * 10 + (s[i] - '0');
        n = true;
      } else {
        a = true;
      }
      if (ans / 10 > INT_MAX) break; // ans can be > 64 bit
    }

    if (neg) ans = -ans;

    if (ans > INT_MAX) ans = INT_MAX;
    if (ans < INT_MIN) ans = INT_MIN;

    if (pos + neg > 1) ans = 0;

    return ans;
  }
};

The post 花花酱 LeetCode 8. String to Integer (atoi) appeared first on Huahua's Tech Road.

题目大意：给你一个字符串，让你在数字之间加上+,-,*使得等式的值等于target。让你输出所有满足条件的表达式。

Given a string that contains only digits 0-9 and a target value, return all possibilities to add binary operators (not unary) +, -, or * between the digits so they evaluate to the target value.

Examples:

"123", 6 -> ["1+2+3", "1*2*3"] 
"232", 8 -> ["2*3+2", "2+3*2"]
"105", 5 -> ["1*0+5","10-5"]
"00", 0 -> ["0+0", "0-0", "0*0"]
"3456237490", 9191 -> []

Slides:

Solution 1: DFS

Time complexity: O(4^n)

Space complexity: O(n^2) -> O(n)

// Author: Huahua
// Running time: 128 ms (<79.97%)
class Solution {
public:
  vector<string> addOperators(string num, int target) {
    vector<string> ans;
    dfs(num, target, 0, "", 0, 0, &ans);
    return ans;
  }
private:
  void dfs(const string& num, const int target,  // input
           int pos, const string& exp, long prev, long curr, // state
           vector<string>* ans) {  // output
    if (pos == num.length()) {
      if (curr == target) ans->push_back(exp);
      return;
    }
    
    for (int l = 1; l <= num.size() - pos; ++l) {
      string t = num.substr(pos, l);    
      if (t[0] == '0' && t.length() > 1) break; // 0X...
      long n = std::stol(t);
      if (n > INT_MAX) break;
      if (pos == 0) {
        dfs(num, target, l, t, n, n, ans);
        continue;
      }
      dfs(num, target, pos + l, exp + '+' + t, n, curr + n, ans);
      dfs(num, target, pos + l, exp + '-' + t, -n, curr - n, ans);
      dfs(num, target, pos + l, exp + '*' + t, prev * n, curr - prev + prev * n, ans);
    }    
  }
};

// Author: Huahua
// Running time: 13 ms (< 99.14%)
class Solution {
public:
  vector<string> addOperators(string num, int target) {
    vector<string> ans;
    string exp(num.length() * 2, '\0');    
    dfs(num, target, 0, exp, 0, 0, 0, &ans);
    return ans;
  }
private:
  void dfs(const string& num, const int target,
           int pos, string& exp, int len, long prev, long curr,
           vector<string>* ans) {    
    if (pos == num.length()) {      
      if (curr == target) ans->push_back(exp.substr(0, len));
      return;
    }
    
    long n = 0;
    int s = pos;
    int l = len;
    if (s != 0) ++len;    
    while (pos < num.size()) {      
      n = n * 10 + (num[pos] - '0');
      if (num[s] == '0' && pos - s > 0) break; // 0X... invalid number
      if (n > INT_MAX) break; // too long
      exp[len++] = num[pos++];
      if (s == 0) {
        dfs(num, target, pos, exp, len, n, n, ans);
        continue;
      }
      exp[l] = '+'; dfs(num, target, pos, exp, len, n, curr + n, ans);
      exp[l] = '-'; dfs(num, target, pos, exp, len, -n, curr - n, ans);
      exp[l] = '*'; dfs(num, target, pos, exp, len, prev * n, curr - prev + prev * n, ans);
    }
  }
};

// Author: Huahua
// Running time: 16 ms (<99.17%)
class Solution {
  private List<String> ans;
  private char[] num;
  private char[] exp;
  private int target;
  
  public List<String> addOperators(String num, int target) {
    this.num = num.toCharArray();
    this.ans = new ArrayList<>();
    this.target = target;
    this.exp = new char[num.length() * 2];
    dfs(0, 0, 0, 0);
    return ans;
  }
  
  private void dfs(int pos, int len, long prev, long curr) {
    if (pos == num.length) {      
      if (curr == target)
        ans.add(new String(exp, 0, len));
      return;
    }
    
    int s = pos;
    int l = len;
    if (s != 0) ++len;
    
    long n = 0;
    while (pos < num.length) {
      if (num[s] == '0' && pos - s > 0) break; // 0X...
      n = n * 10 + (int)(num[pos] - '0');      
      if (n > Integer.MAX_VALUE) break; // too long
      exp[len++] = num[pos++]; // copy exp
      if (s == 0) {
        dfs(pos, len, n, n);
        continue;
      }
      exp[l] = '+'; dfs(pos, len, n, curr + n);
      exp[l] = '-'; dfs(pos, len, -n, curr - n);
      exp[l] = '*'; dfs(pos, len, prev * n, curr - prev + prev * n);
    }
  }
}

The post 花花酱 LeetCode 282. Expression Add Operators appeared first on Huahua's Tech Road.

Problem:

You are given a string expression representing a Lisp-like expression to return the integer value of.

The syntax for these expressions is given as follows.

• An expression is either an integer, a let-expression, an add-expression, a mult-expression, or an assigned variable. Expressions always evaluate to a single integer.
• (An integer could be positive or negative.)
• A let-expression takes the form (let v1 e1 v2 e2 ... vn en expr), where let is always the string "let", then there are 1 or more pairs of alternating variables and expressions, meaning that the first variable v1is assigned the value of the expression e1, the second variable v2 is assigned the value of the expression e2, and so on sequentially; and then the value of this let-expression is the value of the expression expr.
• An add-expression takes the form (add e1 e2) where add is always the string "add", there are always two expressions e1, e2, and this expression evaluates to the addition of the evaluation of e1 and the evaluation of e2.
• A mult-expression takes the form (mult e1 e2) where mult is always the string "mult", there are always two expressions e1, e2, and this expression evaluates to the multiplication of the evaluation of e1 and the evaluation of e2.
• For the purposes of this question, we will use a smaller subset of variable names. A variable starts with a lowercase letter, then zero or more lowercase letters or digits. Additionally for your convenience, the names “add”, “let”, or “mult” are protected and will never be used as variable names.
• Finally, there is the concept of scope. When an expression of a variable name is evaluated, within the context of that evaluation, the innermost scope (in terms of parentheses) is checked first for the value of that variable, and then outer scopes are checked sequentially. It is guaranteed that every expression is legal. Please see the examples for more details on scope.

Evaluation Examples:

Input: (add 1 2)
Output: 3

Input: (mult 3 (add 2 3))
Output: 15

Input: (let x 2 (mult x 5))
Output: 10

Input: (let x 2 (mult x (let x 3 y 4 (add x y))))
Output: 14
Explanation: In the expression (add x y), when checking for the value of the variable x,
we check from the innermost scope to the outermost in the context of the variable we are trying to evaluate.
Since x = 3 is found first, the value of x is 3.

Input: (let x 3 x 2 x)
Output: 2
Explanation: Assignment in let statements is processed sequentially.

Input: (let x 1 y 2 x (add x y) (add x y))
Output: 5
Explanation: The first (add x y) evaluates as 3, and is assigned to x.
The second (add x y) evaluates as 3+2 = 5.

Input: (let x 2 (add (let x 3 (let x 4 x)) x))
Output: 6
Explanation: Even though (let x 4 x) has a deeper scope, it is outside the context
of the final x in the add-expression.  That final x will equal 2.

Input: (let a1 3 b2 (add a1 1) b2) 
Output 4
Explanation: Variable names can contain digits after the first character.

Note:

• The given string expression is well formatted: There are no leading or trailing spaces, there is only a single space separating different components of the string, and no space between adjacent parentheses. The expression is guaranteed to be legal and evaluate to an integer.
• The length of expression is at most 2000. (It is also non-empty, as that would not be a legal expression.)
• The answer and all intermediate calculations of that answer are guaranteed to fit in a 32-bit integer.

Idea:

Recursive parsing

Time complexity: O(n^2) in worst case O(n) in practice

Space complexity: O(n)

// Author: Huahua
// Runtime: 3 ms
class Solution {
public:
    int evaluate(string expression) {        
        scopes_.clear();
        int pos = 0;
        return eval(expression, pos);
    }
private:
    int eval(const string& s, int& pos) {
        scopes_.push_front(unordered_map<string, int>());
        int value = 0; // The return value of current expr        
        if (s[pos] == '(') ++pos;

        // command, variable or number
        const string token = getToken(s, pos);

        if (token == "add") {
            int v1 = eval(s, ++pos);
            int v2 = eval(s, ++pos);
            value = v1 + v2;
        } else if (token == "mult") {
            int v1 = eval(s, ++pos);
            int v2 = eval(s, ++pos);
            value = v1 * v2;
        } else if (token == "let") {
            string var;
            // expecting " var1 exp1 var2 exp2 ... last_expr)"
            while (s[pos] != ')') {
                ++pos;
                // Must be last_expr
                if (s[pos] == '(') {
                    value = eval(s, ++pos);
                    break;
                }                
                // Get a token, could be "x" or "-12" for last_expr
                var = getToken(s, pos);                
                // End of let, var is last_expr
                if (s[pos] == ')') {
                    if (isalpha(var[0]))
                        value = getValue(var);
                    else
                        value = stoi(var);
                    break;
                }
                // x -12 -> set x to -12 and store in the current scope and take it as the current return value
                value = scopes_.front()[var] = eval(s, ++pos);
            }
        } else if (isalpha(token[0])) {            
            value = getValue(token); // symbol
        } else {            
            value = std::stoi(token); // number
        }
        if (s[pos] == ')') ++pos;        
        scopes_.pop_front();        
        return value;
    }
    
    int getValue(const string& symbol) {
        for (const auto& scope : scopes_)        
            if (scope.count(symbol)) return scope.at(symbol);
        return 0;
    }
    
    // Get a token from current pos.
    // "let x" -> "let"
    // "-12 (add x y)" -> "-12"
    string getToken(const string& s, int& pos) {        
        string token;
        while (pos < s.length()) {            
            if (s[pos] == ')' || s[pos] == ' ') break;
            token += s[pos++];
        }
        return token;
    }
    
    deque<unordered_map<string, int>> scopes_; 
};

The post 花花酱 LeetCode 736. Parse Lisp Expression appeared first on Huahua's Tech Road.