# 978 · basic calculator

Implement a basic calculator to calculate a simple expression.

The expression string may contain left parenthesis' ('and right parenthesis'), plus sign' + 'or minus sign' - ', non negative integer and space'.

The expression given is always reasonable.

Learned the usage of eval.

An error was encountered:

Everything else is OK. This decimal system cannot start with 0 and will not be solved. Learned a new method eval, very easy to use.

class Solution: """ @param s: the given expression @return: the result of expression """ def calculate(self, s): # Write your code here stack = [] li = [] for ch in s: if ch != ')': stack.append(ch) else: while stack[-1] != '(': li.append(stack.pop()) stack.pop() # Calculate li li.reverse() stack.append(str(eval(''.join(li)))) li = [] return eval(''.join(stack))

I read an answer, which is easier to understand. Learned about the use of number and sign.

def calculate(self, s): # Write your code here stack = [] number = 0 for ch in s: if ch == '(': stack.append(ch) elif ch.isdigit(): number = number * 10 + int(ch) elif ch == '+' or ch == '-': stack.append(number) stack.append(ch) number = 0 elif ch == ')': stack.append(number) strs = [] while stack and stack[-1] != '(': strs.append(stack.pop()) strs.reverse() result = self.helper(strs) if stack[-1] == '(': stack.pop() stack.append(result) number = 0 stack.append(number) output = self.helper(stack) return output def helper(self, strs): result = 0 sign = 1 for element in strs: if isinstance(element, int): result += sign * element elif element == '+': sign = 1 elif element == '-': sign = -1 return result

# 227. Simulation of Hanoi Tower problem with stack

In the classical Hanoi Tower problem, there are three towers and N plates of different sizes, and the plates can be moved to any tower. It is required that the plates must be stacked from top to bottom in the order from small to large (for example, any plate must be stacked on a plate larger than it). At the same time, you must meet the following restrictions:

(1) Only one plate can be moved at a time.

(2) Only the plates at the top of the tower can be moved.

(3) Each plate can only be placed on a plate larger than it.

Please write a program to move the plate of the first tower to the last tower.

can't

class Tower: """ @param: i: An integer from 0 to 2 """ def __init__(self, i): # create three towers self.disks = [] """ @param: d: An integer @return: nothing """ def add(self, d): # Add a disk into this tower if len(self.disks) > 0 and self.disks[-1] <= d: print("Error placing disk %s" % d) else: self.disks.append(d) """ @param: t: a tower @return: nothing """ def moveTopTo(self, t): # Move the top disk of this tower to the top of t. t.disks.append(self.disks.pop()) """ @param: n: An integer @param: destination: a tower @param: buffer: a tower @return: nothing """ def move_disks(self, n, destination, buffer): # Move n Disks from this tower to destination by buffer tower for i in range(n): buffer.disks.append(self.moveTopTo(buffer)) for i in range(n): destination.disks.append(self.moveTopTo(destination)) """ @return: Disks """ def getDisks(self): # write your code here return self.disks """ Your Tower object will be instantiated and called as such: towers = [Tower(0), Tower(1), Tower(2)] for i in xrange(n - 1, -1, -1): towers[0].add(i) towers[0].move_disks(n, towers[2], towers[1]) print towers[0], towers[1], towers[2] """

The answer is recursive:

class Tower(object): # create three towers (i from 0 to 2) def __init__(self, i): self.disks = [] # Add a disk into this tower def add(self, d): if len(self.disks) > 0 and self.disks[-1] <= d: print("Error placing disk %s") else: self.disks.append(d); # @param {Tower} t a tower # Move the top disk of this tower to the top of t. def move_top_to(self, t): # Write your code here t.add(self.disks.pop()) # @param {int} n an integer # @param {Tower} destination a tower # @param {Tower} buffer a tower # Move n Disks from this tower to destination by buffer tower def move_disks(self, n, destination, buffer): # Write your code here if n > 0: self.move_disks(n - 1, buffer, destination) self.move_top_to(destination) buffer.move_disks(n - 1, destination, self) def get_disks(self): return self.disks """ Your Tower object will be instantiated and called as such: towers = [Tower(0), Tower(1), Tower(2)] for i in xrange(n - 1, -1, -1): towers[0].add(i) towers[0].move_disks(n, towers[2], towers[1]) print towers[0], towers[1], towers[2] """

In this code, I'm still a little confused about self here:

def move_disks(self, n, destination, buffer): # Write your code here if n > 0: self.move_disks(n - 1, buffer, destination) self.move_top_to(destination) buffer.move_disks(n - 1, destination, self)

# 264. Number of general subarrays

Give an array of 2 or 4. If the subarray of an array (subarray is a group of adjacent elements in the array and cannot be empty) meets the following conditions, it is called "general":

- 2 and 4 are grouped consecutively (e.g. [4, 2], [2, 4], [4, 4, 2, 2], [2, 2, 4, 4], [4, 4, 2, 2, 2], etc.).
- The number of 4 in the subarray is equal to the number of 2 in the subarray.
- Subarrays with the same elements but different positions are regarded as different. For example, there are two [4,2] subarrays in the array [4,2,4,2].

You need to return an integer value, that is, the number of "general" subarrays in a given array.

No, just look at the answer:

class Solution: """ @param array: An given array. @return: Return the number of "universal" subarrays. """ def subarrays(self, array): size = len(array) # Record the current number of consecutive 2 and 4 count_2 = 0 count_4 = 0 # An array of 2 or 4 consecutive numbers queue = [] for i in range(size): if array[i] == 4: if i > 0 and array[i-1] == 2: queue.append(count_2) count_2 = 0 count_4 += 1 if array[i] == 2: if i > 0 and array[i-1] == 4: queue.append(count_4) count_4 = 0 count_2 += 1 # 2 or 4 consecutive processing if array[size-1] == 4: queue.append(count_4) else: queue.append(count_2) # Two adjacent numbers are added to the result in min result = 0 for i in range(1, len(queue)): result += min(queue[i], queue[i-1]) return result