
'''simple docstring'''
from __future__ import annotations

from statistics import mean






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE				):
							_snake_case       =  [0] * no_of_processes
							_snake_case       =  [0] * no_of_processes

							# Initialize remaining_time to waiting_time.

							for i in range(_SCREAMING_SNAKE_CASE				):
														_snake_case       =  burst_time[i]
							_snake_case       =  []

							_snake_case       =  0
							_snake_case       =  0

							# When processes are not completed,
							# A process whose arrival time has passed \
							# and has remaining execution time is put into the ready_process.
							# The shortest process in the ready_process, target_process is executed.

							while completed != no_of_processes:
														_snake_case       =  []
														_snake_case       =  -1

														for i in range(_SCREAMING_SNAKE_CASE				):
																					if (arrival_time[i] <= total_time) and (remaining_time[i] > 0):
																												ready_process.append(_SCREAMING_SNAKE_CASE				)

														if len(_SCREAMING_SNAKE_CASE				) > 0:
																					_snake_case       =  ready_process[0]
																					for i in ready_process:
																												if remaining_time[i] < remaining_time[target_process]:
																																			_snake_case       =  i
																					total_time += burst_time[target_process]
																					completed += 1
																					_snake_case       =  0
																					_snake_case       =  (
																					    total_time - arrival_time[target_process] - burst_time[target_process]
																					)
														else:
																					total_time += 1

							return waiting_time






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE				):
							_snake_case       =  [0] * no_of_processes
							for i in range(_SCREAMING_SNAKE_CASE				):
														_snake_case       =  burst_time[i] + waiting_time[i]
							return turn_around_time


if __name__ == "__main__":
				print('[TEST CASE 01]')

				__lowerCAmelCase												=	4
				__lowerCAmelCase												=	[2, 5, 3, 7]
				__lowerCAmelCase												=	[0, 0, 0, 0]
				__lowerCAmelCase												=	calculate_waitingtime(arrival_time, burst_time, no_of_processes)
				__lowerCAmelCase												=	calculate_turnaroundtime(
				    burst_time, no_of_processes, waiting_time
				)

				# Printing the Result
				print('PID\tBurst Time\tArrival Time\tWaiting Time\tTurnaround Time')
				for i, process_id in enumerate(list(range(1, 5))):
								print(
								    f'''{process_id}\t{burst_time[i]}\t\t\t{arrival_time[i]}\t\t\t\t'''
								    f'''{waiting_time[i]}\t\t\t\t{turn_around_time[i]}'''
								)
				print(f'''\nAverage waiting time = {mean(waiting_time):.5f}''')
				print(f'''Average turnaround time = {mean(turn_around_time):.5f}''')

'''simple docstring'''
import qiskit






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE				):
							_snake_case       =  qiskit.Aer.get_backend("""aer_simulator"""				)

							# Create a Quantum Circuit acting on the q register
							_snake_case       =  qiskit.QuantumCircuit(_SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE				)

							# Apply X (NOT) Gate to Qubits 0 & 1
							circuit.x(0				)
							circuit.x(1				)

							# Map the quantum measurement to the classical bits
							circuit.measure([0, 1]							, [0, 1]				)

							# Execute the circuit on the qasm simulator
							_snake_case       =  qiskit.execute(_SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE							, shots=1000				)

							# Return the histogram data of the results of the experiment.
							return job.result().get_counts(_SCREAMING_SNAKE_CASE				)


if __name__ == "__main__":
				__lowerCAmelCase												=	single_qubit_measure(2, 2)
				print(f'''Total count for various states are: {counts}''')