




import math
class       a__   :






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A      ):




											"""simple docstring"""



											__lowerCAmelCase           =	0.0
											__lowerCAmelCase           =	0.0
											for i in range(len(_A      )      ):
																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     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A      ):




											"""simple docstring"""



											for i in range(len(_A      )      ):
																weights[j][i] += alpha * (sample[i] - weights[j][i])
											return weights







def      _a				(						):
					# 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(SCREAMING_SNAKE_CASE_					):
										for j in range(len(SCREAMING_SNAKE_CASE_					)					):
															# training sample
															__lowerCAmelCase           =	training_samples[j]

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

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

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

					# 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()










import math







def      _a				(						SCREAMING_SNAKE_CASE_							:    int					):

					if 1 < number < 4:
										# 2 and 3 are primes
										return True
					elif number < 2 or number % 2 == 0 or number % 3 == 0:
										# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
										return False

					# All primes number are in format of 6k +/- 1
					for i in range(5				,				int(math.sqrt(SCREAMING_SNAKE_CASE_					) + 1					)				,				6					):
										if number % i == 0 or number % (i + 2) == 0:
															return False
					return True







def      _a				(						SCREAMING_SNAKE_CASE_							:    int = 1_00_01					):

					try:
										__lowerCAmelCase           =	int(SCREAMING_SNAKE_CASE_					)
					except (TypeError, ValueError):
										raise TypeError("Parameter nth must be int or castable to int."					) from None
					if nth <= 0:
										raise ValueError("Parameter nth must be greater than or equal to one."					)
					__lowerCAmelCase           =	[]
					__lowerCAmelCase           =	2
					while len(SCREAMING_SNAKE_CASE_					) < nth:
										if is_prime(SCREAMING_SNAKE_CASE_					):
															primes.append(SCREAMING_SNAKE_CASE_					)
															num += 1
										else:
															num += 1
					return primes[len(SCREAMING_SNAKE_CASE_					) - 1]


if __name__ == "__main__":
					print(f'''{solution() = }''')




