
"""simple docstring"""




from __future__ import annotations

from statistics import mean




def  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase ,				_UpperCamelCase						):






  """simple docstring"""



  _lowercase:			Optional[int]       =     [0] * no_of_processes
  _lowercase:			str       =     [0] * no_of_processes

  # Initialize remaining_time to waiting_time.

  for i in range(_UpperCamelCase						):
    _lowercase:			Optional[int]       =     burst_time[i]
  _lowercase:			list[int]       =     []

  _lowercase:			Tuple       =     0
  _lowercase:			Optional[Any]       =     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:
    _lowercase:			Any       =     []
    _lowercase:			Optional[Any]       =     -1

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

    if len(_UpperCamelCase						) > 0:
      _lowercase:			Dict       =     ready_process[0]
      for i in ready_process:
        if remaining_time[i] < remaining_time[target_process]:
          _lowercase:			List[str]       =     i
      total_time += burst_time[target_process]
      completed += 1
      _lowercase:			str       =     0
      _lowercase:			Optional[int]       =     (
          total_time - arrival_time[target_process] - burst_time[target_process]
      )
    else:
      total_time += 1

  return waiting_time




def  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase ,				_UpperCamelCase						):






  """simple docstring"""



  _lowercase:			int       =     [0] * no_of_processes
  for i in range(_UpperCamelCase						):
    _lowercase:			Optional[int]       =     burst_time[i] + waiting_time[i]
  return turn_around_time


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

  A__   :					Tuple							=   4
  A__   :					Union[str, Any]							=   [2, 5, 3, 7]
  A__   :					Optional[int]							=   [0, 0, 0, 0]
  A__   :					List[str]							=   calculate_waitingtime(arrival_time, burst_time, no_of_processes)
  A__   :					Dict							=   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  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase						):






  """simple docstring"""



  _lowercase:			Dict       =     qiskit.Aer.get_backend('''aer_simulator'''						)

  # Create a Quantum Circuit acting on the q register
  _lowercase:			str       =     qiskit.QuantumCircuit(_UpperCamelCase ,				_UpperCamelCase						)

  # 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
  _lowercase:			Tuple       =     qiskit.execute(_UpperCamelCase ,				_UpperCamelCase ,				shots=1_000						)

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


if __name__ == "__main__":
  A__   :					Optional[int]							=   single_qubit_measure(2, 2)
  print(f"""Total count for various states are: {counts}""")
