



import math






class 						__a :



	def 		UpperCamelCase							(						self							:    Optional[Any]				,	snake_case_							:    list[list[float]]				,	snake_case_							:    list[int])->							int:
						__lowerCAmelCase	   =0.0
						__lowerCAmelCase	   =0.0
						for i in range(len(snake_case_)):
											da += math.pow((sample[i] - weights[0][i])				,	2)
											da += math.pow((sample[i] - weights[1][i])				,	2)
											return 0 if da > da else 1
						return 0



	def 		UpperCamelCase							(						self							:    Optional[int]				,	snake_case_							:    list[list[int | float]]				,	snake_case_							:    list[int]				,	snake_case_							:    int				,	snake_case_							:    float)->							list[list[int | float]]:
						for i in range(len(snake_case_)):
											weights[j][i] += alpha * (sample[i] - weights[j][i])
						return weights






def 					__lowerCAmelCase		(  )  ->						None:
					# Training Examples ( m, n )
					__lowerCAmelCase	   =[[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]

					# weight initialization ( n, C )
					__lowerCAmelCase	   =[[0.2, 0.6, 0.5, 0.9], [0.8, 0.4, 0.7, 0.3]]

					# training
					__lowerCAmelCase	   =SelfOrganizingMap()
					__lowerCAmelCase	   =3
					__lowerCAmelCase	   =0.5

					for _ in range(__lowerCamelCase	):
										for j in range(len(__lowerCamelCase	)	):
															# training sample
															__lowerCAmelCase	   =training_samples[j]

															# Compute the winning vector
															__lowerCAmelCase	   =self_organizing_map.get_winner(__lowerCamelCase				,   __lowerCamelCase	)

															# Update the winning vector
															__lowerCAmelCase	   =self_organizing_map.update(__lowerCamelCase				,   __lowerCamelCase				,   __lowerCamelCase				,   __lowerCamelCase	)

    # classify test sample
					__lowerCAmelCase	   =[0, 0, 0, 1]
					__lowerCAmelCase	   =self_organizing_map.get_winner(__lowerCamelCase				,   __lowerCamelCase	)

					# results
					print(f"""Clusters that the test sample belongs to : {winner}"""	)
					print(f"""Weights that have been trained : {weights}"""	)


# running the main() function
if __name__ == "__main__":
				main()









def 					__lowerCAmelCase		(  )  ->						Tuple:
					__lowerCAmelCase	   =[]
					__lowerCAmelCase	   =1

					while len(__lowerCamelCase	) < 1E6:
										constant.append(str(__lowerCamelCase	)	)
										i += 1

					__lowerCAmelCase	   ="""""".join(__lowerCamelCase	)

					return (
					    int(constant[0]	)
					    * int(constant[9]	)
					    * int(constant[99]	)
					    * int(constant[999]	)
					    * int(constant[9999]	)
					    * int(constant[99999]	)
					    * int(constant[999999]	)
					)


if __name__ == "__main__":
				print(solution())




