


import numpy as np
def     UpperCAmelCase    (					_lowercase   :      Optional[Any] ,      _lowercase   :      Optional[Any] ,      _lowercase   :      List[str]  )	->   int:


	"""simple docstring"""




	lowerCAmelCase_			       = n_draws * class_counts / class_counts.sum()
	# floored means we don't overshoot n_samples, but probably undershoot
	lowerCAmelCase_			       = np.floor(_lowercase  )
	# we add samples according to how much "left over" probability
	# they had, until we arrive at n_samples
	lowerCAmelCase_			       = int(n_draws - floored.sum()  )
	if need_to_add > 0:
		lowerCAmelCase_			       = continuous - floored
		lowerCAmelCase_			       = np.sort(np.unique(_lowercase  )  )[::-1]
		# add according to remainder, but break ties
		# randomly to avoid biases
		for value in values:
			((lowerCAmelCase_  )       ,    )			       = np.where(remainder == value  )
			# if we need_to_add less than what's in inds
			# we draw randomly from them.
			# if we need to add more, we add them all and
			# go to the next value
			lowerCAmelCase_			       = min(len(_lowercase  ) ,      _lowercase  )
			lowerCAmelCase_			       = rng.choice(_lowercase ,      size=_lowercase ,      replace=_lowercase  )
			floored[inds] += 1
			need_to_add -= add_now
			if need_to_add == 0:
				break
	return floored.astype(np.intaa  )





def     UpperCAmelCase    (					_lowercase   :      int ,      _lowercase   :      Optional[Any] ,      _lowercase   :      Union[str, Any] ,      _lowercase   :      int ,      _lowercase   :      Optional[Any]=1_0  )	->   Any:


	"""simple docstring"""




	lowerCAmelCase_       ,  lowerCAmelCase_			       = np.unique(_lowercase ,      return_inverse=_lowercase  )
	lowerCAmelCase_			       = classes.shape[0]
	lowerCAmelCase_			       = np.bincount(_lowercase  )
	if np.min(_lowercase  ) < 2:
		raise ValueError('''Minimum class count error'''  )
	if n_train < n_classes:
		raise ValueError(
		    '''The train_size = %d should be greater or ''' '''equal to the number of classes = %d''' % (n_train, n_classes)  )
	if n_test < n_classes:
		raise ValueError(
		    '''The test_size = %d should be greater or ''' '''equal to the number of classes = %d''' % (n_test, n_classes)  )
	lowerCAmelCase_			       = np.split(np.argsort(_lowercase ,      kind='''mergesort'''  ) ,      np.cumsum(_lowercase  )[:-1]  )
	for _ in range(_lowercase  ):
		lowerCAmelCase_			       = approximate_mode(_lowercase ,      _lowercase ,      _lowercase  )
		lowerCAmelCase_			       = class_counts - n_i
		lowerCAmelCase_			       = approximate_mode(_lowercase ,      _lowercase ,      _lowercase  )

		lowerCAmelCase_			       = []
		lowerCAmelCase_			       = []

		for i in range(_lowercase  ):
			lowerCAmelCase_			       = rng.permutation(class_counts[i]  )
			lowerCAmelCase_			       = class_indices[i].take(_lowercase ,      mode='''clip'''  )
			train.extend(perm_indices_class_i[: n_i[i]]  )
			test.extend(perm_indices_class_i[n_i[i] : n_i[i] + t_i[i]]  )
		lowerCAmelCase_			       = rng.permutation(_lowercase  )
		lowerCAmelCase_			       = rng.permutation(_lowercase  )

		yield train, test



"""simple docstring"""



import doctest

import projectq
from projectq.ops import H, Measure
def     UpperCAmelCase    (					_lowercase   :      projectq.cengines._main.MainEngine  )	->   int:


	"""simple docstring"""




	lowerCAmelCase_			       = quantum_engine.allocate_qubit()
	H | qubit
	Measure | qubit
	return int(_lowercase  )


if __name__ == "__main__":
		doctest.testmod()

		# initialises a new quantum backend
		lowercase_							 =       projectq.MainEngine()

		# Generate a list of 10 random numbers
		lowercase_							 =       [get_random_number(quantum_engine) for _ in range(10)]

		# Flushes the quantum engine from memory
		quantum_engine.flush()

		print('Random numbers', random_numbers_list)