【算法与数据结构1伴学】作业和解答

注意：

class SLList(object):
	def __init__(self,x):
		self.one = IntNode(x,None)

	def add_first(self,x):
		self.next = IntNode(x,self.one)

class SLList(object):
	def __init__(self,x):
		self.one = IntNode(x,None)

	def add_first(self,x):
		self.one = IntNode(x,self.one)

下面是对的
当加入一个元素没差别，两个就不一样了

修改更正：

l.one.name.first = 8

添加更正：

class IntNode(object):
	def __init__(self,i,n):
		self.__first = i
		self.name = n

class SLList(object):
	def __init__(self,x):
		self.__one = IntNode(x,None)

	def add_first(self,x):
		self.__one = IntNode(x,self.__one)

	def add_last(self,x):
		p = self.__one
		while p.name is not None:
			p = p.name
		p.name = IntNode(x,None)



l = SLList(5)
l.add_first(10)
l.add_first(15)
#l.one.name.first = 8
l.add_last(0)

伴学：

作业1：链表添加元素、
给定一组数字，将他们用链表的形式进行存储。另外再给一个数字，将它插入到链表的末尾。输出这个链表。
Input
一共有两行，第一行是多个数字，以空格隔开，最多100000个数字。
第二行是一个数字。
数字均在int范围内。
Output
一行输出，数字之间用“->”来表示链表方向。比如：1->2->3->4
Sample Input 1 
1 2 3
4
Sample Output 1
1->2->3->4
Hint
请谨慎考虑是否需要使用递归来解决问题

作业2：链表中翻转
Description
给定一个单向链表，要求将第m位到第n位（从0开始编号位数）的元素翻转过来。
注1：m和n一定都在链表长度内
注2：待翻转的元素包括第m和n位
Input
两行数据
第一行为链表元素，用空格隔开各个元素
第二行有两个数字，分别是m和n
注：链表元素个数最大为1000
Output
翻转后的链表结果
元素之间用->表示连接方向
Sample Input 1 
1 2 3 4 5 6 7
2 5
Sample Output 1
1->2->6->5->4->3->7
Sample Input 2 
1 2 3 4 5 6 7
0 1
Sample Output 2
2->1->3->4->5->6->7
Hint
一定注意各种边界情况

作业3：小明买东西
Description
小明去商店买东西，他手里有一些零花钱，他希望能通过购买商店里的不同商品来正好花完他的零花钱（不然回家就要上交给老妈了）。
现在已知商店里各个商品的价格以及小明手里零花钱的总数，请问小明能够正好花完他的零花钱吗？
Input
一共两行数据。
第一行为一组数字，用空格隔开，表示商店里不同商品的价格。
第二行为小明手里零花钱的总数。
注1：商品和小明零花钱的金额都是整数。
注2：商品数量不超过25个。
注3：每个数字代表的商品数量有且只有一个。
Output
如果能够正好花完零花钱输出True，否则输出False。
Sample Input 1 
1 2 3 4 5 6 7 8 9
12
Sample Output 1
True
Sample Input 2 
10 20 30 40
33
Sample Output 2
False

参考答案：

class IntNode(object):
	"""docstring for IntNode"""
	def __init__(self, i, n):
		self.item = i
		self.next = n

class SLList(object):
	"""docstring for SLList"""
	def __init__(self, x):
		self.__first = IntNode(x, None)
		self.__last = self.__first
		self.__second_last = None
		self.__size = 1

	def add_last(self, x):
		self.__second_last = self.__last
		self.__last = IntNode(x, None)
		self.__second_last.next = self.__last
		self.__size += 1

	def size(self):
		return self.__size

	def output(self):
		s = ''
		p = self.__first
		count = 0
		while count < self.__size - 1:
			s += p.item + '->'
			p = p.next
			count += 1
		s += p.item
		print(s)

s = input()
last_item = input()
s_list = s.split(' ')
l = SLList(s_list[0])
for item in s_list[1:]:
	l.add_last(item)
l.add_last(last_item)
l.output()

class IntNode(object):
	"""docstring for IntNode"""
	def __init__(self, i, n):
		self.item = i
		self.next = n

class SLList(object):
	"""docstring for SLList"""
	def __init__(self, x):
		self.__first = IntNode(x, None)
		self.__size = 1

	def add_first(self, x):
		self.__first = IntNode(x, self.__first)
		self.__size += 1

	def get_first(self):
		return self.__first.item

	def add_last(self, x):
		self.__size += 1
		p = self.__first
		while p.next is not None:
			p = p.next

		p.next = IntNode(x, None)

	def size(self):
		return self.__size

	def output(self):
		s = ''
		p = self.__first
		count = 0
		while count < self.__size - 1:
			s += p.item + '->'
			p = p.next
			count += 1
		s += p.item
		print(s)

	def reverse(self, m, n):
		p1 = self.__first
		count = 0
		while count<m-1:
			p1 = p1.next
			count += 1
		if m==0:
			left_tail = None
			new_tail = p1
		else:
			left_tail = p1
			p1 = p1.next
			new_tail = p1
			count += 1

		pre = p1
		if p1.next is not None:
			current = p1.next
			p1 = current.next
			count += 1
			while count<=n:
				current.next = pre
				pre = current
				current = p1
				if p1 is not None:
					p1 = p1.next
				count += 1
			if left_tail is not None:
				left_tail.next = pre
			else:
				self.__first = pre
			new_tail.next = current


s = input()
s_list = s.split(' ')

start_end = input()
start_end = start_end.split(' ')

start_reverse_pos = int(start_end[0])
end_reverse_pos = int(start_end[1])

l = SLList(s_list[0])
for item in s_list[1:]:
	l.add_last(item)

l.reverse(start_reverse_pos, end_reverse_pos)
l.output()

def sub_sum(arr, index, target):
	if target == 0:
		return True
	elif index == 0:
		return arr[0] == target
	elif arr[index] > target:
		return sub_sum(arr, index - 1, target)
	else:
		return sub_sum(arr, index - 1, target - arr[index]) or sub_sum(arr, index - 1, target)


s = input().split(' ')
target = int(input())
array = [int(i) for i in s]
index = len(array) - 1
print(sub_sum(array, index, target))