
'''simple docstring'''



from __future__ import annotations

import time

import numpy as np

_lowercase    =		[8, 5, 9, 7]
_lowercase    =		[
    [2, 0, 1, 1],
    [0, 1, 2, 1],
    [4, 0, 0, 3],
    [0, 2, 1, 0],
    [1, 0, 3, 0],
]
_lowercase    =		[
    [3, 2, 1, 4],
    [0, 2, 5, 2],
    [5, 1, 0, 5],
    [1, 5, 3, 0],
    [3, 0, 3, 3],
]




class   UpperCAmelCase_					:






						'''simple docstring'''






						def __init__( self   ,       _lowercase   ,       _lowercase   ,       _lowercase   ,       ):

												"""simple docstring"""



												_lowerCAmelCase  						=			claim_vector
												_lowerCAmelCase  						=			allocated_resources_table
												_lowerCAmelCase  						=			maximum_claim_table




						def  _lowercase     ( self				):

												"""simple docstring"""



												return [
												    sum(p_item[i] for p_item in self.__allocated_resources_table				)
												    for i in range(len(self.__allocated_resources_table[0]				)				)
												]




						def  _lowercase     ( self				):

												"""simple docstring"""



												return np.array(self.__claim_vector				) - np.array(
												    self.__processes_resource_summation()				)




						def  _lowercase     ( self				):

												"""simple docstring"""



												return [
												    list(np.array(self.__maximum_claim_table[i]				) - np.array(_lowercase				)				)
												    for i, allocated_resource in enumerate(self.__allocated_resources_table				)
												]




						def  _lowercase     ( self				):

												"""simple docstring"""



												return {self.__need().index(_lowercase				): i for i in self.__need()}




						def  _lowercase     ( self   ,       **_lowercase				):

												"""simple docstring"""



												_lowerCAmelCase  						=			self.__need()
												_lowerCAmelCase  						=			self.__allocated_resources_table
												_lowerCAmelCase  						=			self.__available_resources()
												_lowerCAmelCase  						=			self.__need_index_manager()
												for kw, val in kwargs.items():
																		if kw and val is True:
																								self.__pretty_data()
												print("""_""" * 50 + """\n"""				)
												while need_list:
																		_lowerCAmelCase  						=			False
																		for each_need in need_list:
																								_lowerCAmelCase  						=			True
																								for index, need in enumerate(_lowercase				):
																														if need > available_resources[index]:
																																				_lowerCAmelCase  						=			False
																																				break
																								if execution:
																														_lowerCAmelCase  						=			True
																														# get the original index of the process from ind_ctrl db
																														for original_need_index, need_clone in need_index_manager.items():
																																				if each_need == need_clone:
																																										_lowerCAmelCase  						=			original_need_index
																														print(F'Process {process_number + 1} is executing.'				)
																														# remove the process run from stack
																														need_list.remove(_lowercase				)
																														# update available/freed resources stack
																														_lowerCAmelCase  						=			np.array(_lowercase				) + np.array(
																														    alloc_resources_table[process_number]				)
																														print(
																														    """Updated available resource stack for processes: """
																														    + """ """.join([str(_lowercase				) for x in available_resources]				)				)
																														break
																		if safe:
																								print("""The process is in a safe state.\n"""				)
																		else:
																								print("""System in unsafe state. Aborting...\n"""				)
																								break




						def  _lowercase     ( self				):

												"""simple docstring"""



												print(""" """ * 9 + """Allocated Resource Table"""				)
												for item in self.__allocated_resources_table:
																		print(
																		    F'P{self.__allocated_resources_table.index(_lowercase				) + 1}'
																		    + """ """.join(F'{it:>8}' for it in item				)
																		    + """\n"""				)
												print(""" """ * 9 + """System Resource Table"""				)
												for item in self.__maximum_claim_table:
																		print(
																		    F'P{self.__maximum_claim_table.index(_lowercase				) + 1}'
																		    + """ """.join(F'{it:>8}' for it in item				)
																		    + """\n"""				)
												print(
												    """Current Usage by Active Processes: """
												    + """ """.join(str(_lowercase				) for x in self.__claim_vector				)				)
												print(
												    """Initial Available Resources:       """
												    + """ """.join(str(_lowercase				) for x in self.__available_resources()				)				)
												time.sleep(1				)


if __name__ == "__main__":
						import doctest

						doctest.testmod()


'''simple docstring'''



import numpy as np
import qiskit


def A				(__lowerCamelCase				:int = 8			,     __lowerCamelCase				:int | None = None		):
						_lowerCAmelCase  						=			np.random.default_rng(seed=__lowerCamelCase		)

						# Roughly 25% of the qubits will contribute to the key.
						# So we take more than we need.
						_lowerCAmelCase  						=			6 * key_len
						# Measurement basis for Alice's qubits.
						_lowerCAmelCase  						=			rng.integers(2			,     size=__lowerCamelCase		)
						# The set of states Alice will prepare.
						_lowerCAmelCase  						=			rng.integers(2			,     size=__lowerCamelCase		)
						# Measurement basis for Bob's qubits.
						_lowerCAmelCase  						=			rng.integers(2			,     size=__lowerCamelCase		)

						# Quantum Circuit to simulate BB84
						_lowerCAmelCase  						=			qiskit.QuantumCircuit(__lowerCamelCase			,     name="""BB84"""		)

						# Alice prepares her qubits according to rules above.
						for index, _ in enumerate(__lowerCamelCase		):
												if alice_state[index] == 1:
																		bbaa_circ.x(__lowerCamelCase		)
												if alice_basis[index] == 1:
																		bbaa_circ.h(__lowerCamelCase		)
						bbaa_circ.barrier()

						# Bob measures the received qubits according to rules above.
						for index, _ in enumerate(__lowerCamelCase		):
												if bob_basis[index] == 1:
																		bbaa_circ.h(__lowerCamelCase		)

						bbaa_circ.barrier()
						bbaa_circ.measure_all()

						# Simulate the quantum circuit.
						_lowerCAmelCase  						=			qiskit.Aer.get_backend("""aer_simulator"""		)
						# We only need to run one shot because the key is unique.
						# Multiple shots will produce the same key.
						_lowerCAmelCase  						=			qiskit.execute(__lowerCamelCase			,     __lowerCamelCase			,     shots=1			,     seed_simulator=__lowerCamelCase		)
						# Returns the result of measurement.
						_lowerCAmelCase  						=			job.result().get_counts(__lowerCamelCase		).most_frequent()

						# Extracting the generated key from the simulation results.
						# Only keep measurement results where Alice and Bob chose the same basis.
						_lowerCAmelCase  						=			"""""".join(
						    [
						        result_bit
						        for alice_basis_bit, bob_basis_bit, result_bit in zip(
						            __lowerCamelCase			,     __lowerCamelCase			,     __lowerCamelCase		)
						        if alice_basis_bit == bob_basis_bit
						    ]		)

						# Get final key. Pad with 0 if too short, otherwise truncate.
						_lowerCAmelCase  						=			gen_key[:key_len] if len(__lowerCamelCase		) >= key_len else gen_key.ljust(__lowerCamelCase			,     """0"""		)
						return key


if __name__ == "__main__":
						print(F"""The generated key is : {bbaa(8, seed=0)}""")
						from doctest import testmod

						testmod()
