jquery 判断input输入是否与前面重复_python小技巧—输入若干个数字，并将其组合成各个位上无重复数字的数...

104 阅读 0 评论 69 点赞

我是靠谱客的博主坚定自行车，这篇文章主要介绍jquery 判断input输入是否与前面重复_python小技巧—输入若干个数字，并将其组合成各个位上无重复数字的数...，现在分享给大家，希望可以做个参考。

要求：

1.操作者可以随意定义自己想输入的数字的个数，并可以输入比这个数更多或更少的数字，但至少要输入1个数字，例如：

有四个数字：6、9、3、4，能组成多少个互不相同且无重复数字的4位数？各是多少？用户可以输入4个或4个以上的数字，

也可以最少只输入1个数字，其余数字默认为0（用户也可以只输入一个0。但必须输入的是数字，否则报错，要求重新输入。）

2.当用户输入第1个数字后，询问用户“是否继续输入？”

3.当用户输入数字个数达到要求的时候，提示，并询问是否继续。

4.当用户输入4，0，0，3这样的数字的时候，是无法组成互不相同且无重复数字的4位数的，只能组成相应的3位数

5.将最终的结果以列表的方式打印出来。

复制代码

#导入模块
import itertools
 
##————————创建父类————————#
 
class NumberList:
	
#————————将输入的数据放入一个列表中————————#
	def get_input_number(self):
		self.numbers = int(input('请问你要输入几个数？'))
		self.numbers_1 = [] #用于放置输入的参数
		self.stop_or_not = ''
		self.j = 0	#记录输入的次数
		self.after_del_sameNumber = []
		while True:
			try:
				self.j = self.j + 1
				self.input_num = int(input('请输入第%d个数字：'%self.j)) #输入数字
				if self.input_num not in range(0,10):
					print ('请输入0~9之间的整数！')
					self.j = self.j -1
					continue
			#发生类型错误,重新输入
			except ValueError:
				print('你输入的不是一个整数，请重新输入！')
				self.j = self.j - 1
				continue #返回重新输入
			else:
				self.numbers_1.append(self.input_num) #将输入的数字放入一个列表中，便于读取
			#如果输入到指定个数，则每多输入一次数字，就提示一次“是否要继续输入”
			if self.j >= self.numbers:
				#try:
				self.stop_or_not = input('你已经输入了%d个数字，数字个数已经达到要求，是否继续输入？y，继续。n，停止。请选择：'%self.j)
				if self.stop_or_not == 'y':
					continue
				elif self.stop_or_not == 'n':
					print('用户输入的列表self.numbers_1：')
					print(self.numbers_1)
					#在类中定义的函数调用时，也要用self调用，如下：
					self.after_del_sameNumber=self.del_sameNumber(self.numbers_1) #去重
					return self.after_del_sameNumber  #返回列表
				else:
					print('选择错误，请重新输入!')
					self.j = self.j - 1	
					print('请输入‘y’或‘n’!')
					#将之前输入的数字去除，重新输入
					self.numbers_1.pop()
					continue
			#当输入的个数小于原定个数时：
			else:
				self.stop_or_not = input('你现在输入了%d个数字，还差%d个数字，是否继续输入？y，继续。n，停止。请选择：'%(self.j,self.numbers-self.j))
				if self.stop_or_not == 'y':
					continue
				elif self.stop_or_not == 'n':
					for i in range(0,self.numbers - self.j):
						print(i)	
						self.numbers_1.append(0)
					print('用户输入的列表self.numbers_1：')				
					print(self.numbers_1)
				else:
					print('选择错误，请重新输入!')
					self.numbers_1.pop()
					self.j = self.j - 1
					continue
		#调用去0函数并返回去0后的新列表
		#在类中定义的函数调用时，也要用self调用，如下：
		return self.del_zero(self.numbers_1)
 
 
 
 
					#break
	#————————将列表后面的0删除（去0）————————#	
	def del_zero(self,list_ofNumber):
		self.list_ofNumber = list_ofNumber
		#如果末尾加0，为了最后不影响结果，要进行去0处理，也就是要把列表self.numbers_1中末尾多余的0去除，只保留一个！
		#【当然，也可以一步到位，利用函数对列表（或者对最终结果的列表）进行去重处理（就向后面的代码那样）】，但为了达到练习的目的，我还是一点点来写
		#（注意：）实际上去0后，依然需要去重，比如要输7个数，只输入了1，0，1，2，这几个数，去零后结果仍有重值，需要对输入列表或结果列表去重。
		#方法：先把末尾所有的0去除，再添加一个0
		#(方法1)从最后一个元素开始遍历，找到第一个不为0的元素，把前面元素和一个0放到一个新的列表中
		#(方法2)也可以先反向排列，找出第一个不为0的元素，再把前面的0删除，再反向排序成正常列表(实际上排序或者不排序对结果没有影响！)
		#-------------------方法1-------------------#
		self.numbers_2 = []
		#index()返回的是索引位置，而不是对应的值！
 
		'''
		self.index_ind = 0
		#从最后一个元素开始遍历，找到第一个不为0的元素
		for i in range(len(self.numbers_1) - 1,-1,-1):
			if(self.numbers_1[i] != 0):
				#找到索引
				self.index_ind = self.numbers_1.index(self.numbers_1[i])
				break
			else:
				continue
		#放入新的列表中去,+2的原因是：要包含那个不为0的元素和‘后面’的一个0
		#从后往前添加元素
		for j in range(0,self.index_ind + 2):
			self.numbers_2.append(self.numbers_1[j])
		#也可以self.index_ind + 1，再像下面这样在最后加一个0
		#self.numbers_2.append(0)	
		print(self.numbers_2)
		'''
		#-------------------方法2-------------------#
		#用内置函数对列表self.numbers_1进行反向排序：
		self.index_ind2 = 0
		#反向排列
		self.numbers_1.reverse()
		print('反向排序后的列表self.numbers_1：')
		print(self.numbers_1)
		for m in self.numbers_1:
			if m != 0:
				self.index_ind2 = self.numbers_1.index(m)
				break
			else:
				continue
		#-2的原因是：要包含那个不为0的元素和‘前面’的一个0
		#从后往前添加元素
		for n in range(len(self.numbers_1) - 1,self.index_ind2-2,-1):
			self.numbers_2.append(self.numbers_1[n])
		print('去0后的列表self.numbers_3：')
		print(self.numbers_2)
		#在类中定义的函数调用时，也要用self调用，如下：
		self.numbers_2 = self.del_sameNumber(self.numbers_2)
		return self.numbers_2
 
 
	#————————将列表中的重复元素删除（去重）————————#
	def del_sameNumber(self,sameNumbers_inside):
		self.sameNumbers_inside = sameNumbers_inside
		#如果用户输入的数字有重复如[1, 2, 0, 2, 1, 0]，还要进行【去重处理】
		self.numbers_3=sorted(set(self.sameNumbers_inside),key=self.sameNumbers_inside.index)
		print('去重后的列表self.numbers_3：')
		print(self.numbers_3)
		return self.numbers_3 #返回最终的列表，而不是补0的列表
	
 
#————————定义子类————————#
class ResultNumbers(NumberList):
	
#————————取出列表值并判断(如果百位数为0，则不算在内！)，参数是get_input_number函数所返回的列表————————#		
	def find_all_numbers(self,list_of_number):
		self.list_of_number = list_of_number
		#self.numbers_2 = [] #用于存储符合要求的三位数
		#定义一个列表b,用于存放遍历后的所有可能
		self.b = []
		#遍历所有可能
		for i in itertools.permutations(self.list_of_number):
		   if i[0] != 0:
		   		self.b.append(i)
		print('重组列表,其长度为：'+str(len(self.b))+'如下：' )
		print(self.b)
		#单个元组的长度，也就是最后要遍历的层数
		self.item_len = len(self.b[0])
		print('长度为，也就是最后要遍历的层数：' + str(self.item_len))
		self.x = self.item_len-1#2
		self.c = 0
		#存放最终组合的列表
		self.final = []
 
		#遍历列表j
		for items in self.b:
			#遍历j中的每一个元组items
			for i in items :
				#计算符合要要求的数据
				self.c = self.c + i*(10**(self.x))
				self.x = self.x - 1 #10的次方数减1
			if self.x >= 0:#如果x>=0,说明还没有算完，则什么都不做，直到算完一个数为止
				pass
			#一旦x变为0，则重新进行初始化，以便下一次循环
			else:
				self.final.append(self.c)
				self.x = self.item_len-1
				self.c = 0
				continue
		print('这样的数字共有：' + str(len(self.final)) + '个！如下所示：n%s'%self.final)
 
#————————类的使用————————#
#创建子类的实例
result_number = ResultNumbers()
numberList = NumberList()
result_number.find_all_numbers(numberList.get_input_number())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
#导入模块
import itertools
 
##————————创建父类————————#
 
class NumberList:
	
#————————将输入的数据放入一个列表中————————#
	def get_input_number(self):
		self.numbers = int(input('请问你要输入几个数？'))
		self.numbers_1 = [] #用于放置输入的参数
		self.stop_or_not = ''
		self.j = 0	#记录输入的次数
		self.after_del_sameNumber = []
		while True:
			try:
				self.j = self.j + 1
				self.input_num = int(input('请输入第%d个数字：'%self.j)) #输入数字
				if self.input_num not in range(0,10):
					print ('请输入0~9之间的整数！')
					self.j = self.j -1
					continue
			#发生类型错误,重新输入
			except ValueError:
				print('你输入的不是一个整数，请重新输入！')
				self.j = self.j - 1
				continue #返回重新输入
			else:
				self.numbers_1.append(self.input_num) #将输入的数字放入一个列表中，便于读取
			#如果输入到指定个数，则每多输入一次数字，就提示一次“是否要继续输入”
			if self.j >= self.numbers:
				#try:
				self.stop_or_not = input('你已经输入了%d个数字，数字个数已经达到要求，是否继续输入？y，继续。n，停止。请选择：'%self.j)
				if self.stop_or_not == 'y':
					continue
				elif self.stop_or_not == 'n':
					print('用户输入的列表self.numbers_1：')
					print(self.numbers_1)
					#在类中定义的函数调用时，也要用self调用，如下：
					self.after_del_sameNumber=self.del_sameNumber(self.numbers_1) #去重
					return self.after_del_sameNumber  #返回列表
				else:
					print('选择错误，请重新输入!')
					self.j = self.j - 1	
					print('请输入‘y’或‘n’!')
					#将之前输入的数字去除，重新输入
					self.numbers_1.pop()
					continue
			#当输入的个数小于原定个数时：
			else:
				self.stop_or_not = input('你现在输入了%d个数字，还差%d个数字，是否继续输入？y，继续。n，停止。请选择：'%(self.j,self.numbers-self.j))
				if self.stop_or_not == 'y':
					continue
				elif self.stop_or_not == 'n':
					for i in range(0,self.numbers - self.j):
						print(i)	
						self.numbers_1.append(0)
					print('用户输入的列表self.numbers_1：')				
					print(self.numbers_1)
				else:
					print('选择错误，请重新输入!')
					self.numbers_1.pop()
					self.j = self.j - 1
					continue
		#调用去0函数并返回去0后的新列表
		#在类中定义的函数调用时，也要用self调用，如下：
		return self.del_zero(self.numbers_1)
 
 
 
 
					#break
	#————————将列表后面的0删除（去0）————————#	
	def del_zero(self,list_ofNumber):
		self.list_ofNumber = list_ofNumber
		#如果末尾加0，为了最后不影响结果，要进行去0处理，也就是要把列表self.numbers_1中末尾多余的0去除，只保留一个！
		#【当然，也可以一步到位，利用函数对列表（或者对最终结果的列表）进行去重处理（就向后面的代码那样）】，但为了达到练习的目的，我还是一点点来写
		#（注意：）实际上去0后，依然需要去重，比如要输7个数，只输入了1，0，1，2，这几个数，去零后结果仍有重值，需要对输入列表或结果列表去重。
		#方法：先把末尾所有的0去除，再添加一个0
		#(方法1)从最后一个元素开始遍历，找到第一个不为0的元素，把前面元素和一个0放到一个新的列表中
		#(方法2)也可以先反向排列，找出第一个不为0的元素，再把前面的0删除，再反向排序成正常列表(实际上排序或者不排序对结果没有影响！)
		#-------------------方法1-------------------#
		self.numbers_2 = []
		#index()返回的是索引位置，而不是对应的值！
 
		'''
		self.index_ind = 0
		#从最后一个元素开始遍历，找到第一个不为0的元素
		for i in range(len(self.numbers_1) - 1,-1,-1):
			if(self.numbers_1[i] != 0):
				#找到索引
				self.index_ind = self.numbers_1.index(self.numbers_1[i])
				break
			else:
				continue
		#放入新的列表中去,+2的原因是：要包含那个不为0的元素和‘后面’的一个0
		#从后往前添加元素
		for j in range(0,self.index_ind + 2):
			self.numbers_2.append(self.numbers_1[j])
		#也可以self.index_ind + 1，再像下面这样在最后加一个0
		#self.numbers_2.append(0)	
		print(self.numbers_2)
		'''
		#-------------------方法2-------------------#
		#用内置函数对列表self.numbers_1进行反向排序：
		self.index_ind2 = 0
		#反向排列
		self.numbers_1.reverse()
		print('反向排序后的列表self.numbers_1：')
		print(self.numbers_1)
		for m in self.numbers_1:
			if m != 0:
				self.index_ind2 = self.numbers_1.index(m)
				break
			else:
				continue
		#-2的原因是：要包含那个不为0的元素和‘前面’的一个0
		#从后往前添加元素
		for n in range(len(self.numbers_1) - 1,self.index_ind2-2,-1):
			self.numbers_2.append(self.numbers_1[n])
		print('去0后的列表self.numbers_3：')
		print(self.numbers_2)
		#在类中定义的函数调用时，也要用self调用，如下：
		self.numbers_2 = self.del_sameNumber(self.numbers_2)
		return self.numbers_2
 
 
	#————————将列表中的重复元素删除（去重）————————#
	def del_sameNumber(self,sameNumbers_inside):
		self.sameNumbers_inside = sameNumbers_inside
		#如果用户输入的数字有重复如[1, 2, 0, 2, 1, 0]，还要进行【去重处理】
		self.numbers_3=sorted(set(self.sameNumbers_inside),key=self.sameNumbers_inside.index)
		print('去重后的列表self.numbers_3：')
		print(self.numbers_3)
		return self.numbers_3 #返回最终的列表，而不是补0的列表
	
 
#————————定义子类————————#
class ResultNumbers(NumberList):
	
#————————取出列表值并判断(如果百位数为0，则不算在内！)，参数是get_input_number函数所返回的列表————————#		
	def find_all_numbers(self,list_of_number):
		self.list_of_number = list_of_number
		#self.numbers_2 = [] #用于存储符合要求的三位数
		#定义一个列表b,用于存放遍历后的所有可能
		self.b = []
		#遍历所有可能
		for i in itertools.permutations(self.list_of_number):
		   if i[0] != 0:
		   		self.b.append(i)
		print('重组列表,其长度为：'+str(len(self.b))+'如下：' )
		print(self.b)
		#单个元组的长度，也就是最后要遍历的层数
		self.item_len = len(self.b[0])
		print('长度为，也就是最后要遍历的层数：' + str(self.item_len))
		self.x = self.item_len-1#2
		self.c = 0
		#存放最终组合的列表
		self.final = []
 
		#遍历列表j
		for items in self.b:
			#遍历j中的每一个元组items
			for i in items :
				#计算符合要要求的数据
				self.c = self.c + i*(10**(self.x))
				self.x = self.x - 1 #10的次方数减1
			if self.x >= 0:#如果x>=0,说明还没有算完，则什么都不做，直到算完一个数为止
				pass
			#一旦x变为0，则重新进行初始化，以便下一次循环
			else:
				self.final.append(self.c)
				self.x = self.item_len-1
				self.c = 0
				continue
		print('这样的数字共有：' + str(len(self.final)) + '个！如下所示：n%s'%self.final)
 
#————————类的使用————————#
#创建子类的实例
result_number = ResultNumbers()
numberList = NumberList()
result_number.find_all_numbers(numberList.get_input_number())