文章目录
978 · 基础计算器
实现一个基础的计算器来计算一个简单表达式。
这个表达式字符串可能包含左括号 ‘(’ 与右括号 ‘)’，加号 ‘+’ 或者 减号 ‘-’，非负整数以及空格 ’ '。
给出的表达式总是合理的。
学习了eval的用法。
遇到了一个错误：
其他的都可以过，这个十进制不能以0开头，不会解决。新学了个方法eval，很好用。
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()
# 对li进行计算
li.reverse()
stack.append(str(eval(''.join(li))))
li = []
return eval(''.join(stack))
看了一个答案，比较好理解的。学习到了关于number和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 · 用栈模拟汉诺塔问题
在经典的汉诺塔问题中，有 3 个塔和 N 个大小不同的盘子，盘子可移动到任一塔上。要求盘子必须按照从小到大的顺序从上往下堆 （如，任意一个盘子，其必须堆在比它大的盘子上面）。同时，你必须满足以下限制条件：
(1) 每次只能移动一个盘子。
(2) 只能移动位于塔顶的盘子。
(3) 每个盘子只能放在比它大的盘子上面。
请写一段程序，实现将第一个塔的盘子移动到最后一个塔中。
不会
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]
"""
答案用了递归：
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]
"""
这个代码中，self这里我看着还是有点迷糊：
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 · 通用子数组个数
给定一个由 2 或 4 组成的数组。如果一个数组的子数组 (子数组是数组中相邻的一组元素且不能为空) 符合以下条件，则称为“通用”:
- 2 和 4 被连续分组(如[4, 2],[2, 4],[4, 4, 2, 2],[2, 2, 4, 4],[4, 4, 4, 2, 2, 2]等等)。
- 子数组中 4 的个数等于子数组中 2 的个数。
- 相同元素但位置不同的子数组视为不同，如数组[4, 2, 4, 2]中有两个[4, 2]子数组。
你需要返回一个整数值，即给定数组中“通用”子数组的数量。
不会，直接看答案了：
class Solution:
"""
@param array: An given array.
@return: Return the number of "universal" subarrays.
"""
def subarrays(self, array):
size = len(array)
# 记录当前连续2，4的个数
count_2 = 0
count_4 = 0
# 存放连续2，4个数的数组
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或4
if array[size-1] == 4:
queue.append(count_4)
else:
queue.append(count_2)
# 相邻的两个数取min累加到结果
result = 0
for i in range(1, len(queue)):
result += min(queue[i], queue[i-1])
return result
