




from __future__ import annotations




def 					SCREAMING_SNAKE_CASE	(       __UpperCamelCase			:						list[int]      )  ->							list[int]:
    UpperCAmelCase_							 =     [0] * len(__UpperCamelCase      )
    for i in range(1       ,     len(__UpperCamelCase      )      ):
        UpperCAmelCase_							 =     duration_times[i - 1] + waiting_times[i - 1]
    return waiting_times




def 					SCREAMING_SNAKE_CASE	(       __UpperCamelCase			:						list[int]       ,     __UpperCamelCase			:						list[int]      )  ->							list[int]:
    return [
        duration_time + waiting_times[i]
        for i, duration_time in enumerate(__UpperCamelCase      )
    ]




def 					SCREAMING_SNAKE_CASE	(       __UpperCamelCase			:						list[int]      )  ->							float:
    return sum(__UpperCamelCase      ) / len(__UpperCamelCase      )




def 					SCREAMING_SNAKE_CASE	(       __UpperCamelCase			:						list[int]      )  ->							float:
    return sum(__UpperCamelCase      ) / len(__UpperCamelCase      )


if __name__ == "__main__":
 # process id's
 _lowerCamelCase			 =						[1, 2, 3]

 # ensure that we actually have processes
 if len(processes) == 0:
  print('Zero amount of processes')
  raise SystemExit(0)

 # duration time of all processes
 _lowerCamelCase			 =						[19, 8, 9]

 # ensure we can match each id to a duration time
 if len(duration_times) != len(processes):
  print('Unable to match all id\'s with their duration time')
  raise SystemExit(0)

 # get the waiting times and the turnaround times
 _lowerCamelCase			 =						calculate_waiting_times(duration_times)
 _lowerCamelCase			 =						calculate_turnaround_times(duration_times, waiting_times)

 # get the average times
 _lowerCamelCase			 =						calculate_average_waiting_time(waiting_times)
 _lowerCamelCase			 =						calculate_average_turnaround_time(turnaround_times)

 # print all the results
 print('Process ID\tDuration Time\tWaiting Time\tTurnaround Time')
 for i, process in enumerate(processes):
  print(
      F"{process}\t\t{duration_times[i]}\t\t{waiting_times[i]}\t\t"
      F"{turnaround_times[i]}"
  )
 print(F"Average waiting time = {average_waiting_time}")
 print(F"Average turn around time = {average_turnaround_time}")











import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute




def 					SCREAMING_SNAKE_CASE	(       __UpperCamelCase			:						int = 1       ,     __UpperCamelCase			:						int = 1      )  ->							qiskit.result.counts.Counts:
    if isinstance(__UpperCamelCase       ,     __UpperCamelCase      ) or isinstance(__UpperCamelCase       ,     __UpperCamelCase      ):
        raise TypeError('''inputs must be integers.'''      )
    if (bit_a < 0) or (bit_a < 0):
        raise ValueError('''inputs must be positive.'''      )
    if (math.floor(__UpperCamelCase      ) != bit_a) or (math.floor(__UpperCamelCase      ) != bit_a):
        raise ValueError('''inputs must be exact integers.'''      )
    if (bit_a > 1) or (bit_a > 1):
        raise ValueError('''inputs must be less or equal to 1.'''      )

    # build registers
    UpperCAmelCase_							 =     QuantumRegister(2       ,     '''qr'''      )
    UpperCAmelCase_							 =     ClassicalRegister(2       ,     '''cr'''      )

    UpperCAmelCase_							 =     QuantumCircuit(__UpperCamelCase       ,     __UpperCamelCase      )

    # entanglement the qubits
    quantum_circuit.h(1      )
    quantum_circuit.cx(1       ,     0      )

    # send the information
    UpperCAmelCase_							 =     str(__UpperCamelCase      ) + str(__UpperCamelCase      )

    if c_information == "11":
        quantum_circuit.x(1      )
        quantum_circuit.z(1      )
    elif c_information == "10":
        quantum_circuit.z(1      )
    elif c_information == "01":
        quantum_circuit.x(1      )
    else:
        quantum_circuit.i(1      )

    # unentangled the circuit
    quantum_circuit.cx(1       ,     0      )
    quantum_circuit.h(1      )

    # measure the circuit
    quantum_circuit.measure(__UpperCamelCase       ,     __UpperCamelCase      )

    UpperCAmelCase_							 =     Aer.get_backend('''aer_simulator'''      )
    UpperCAmelCase_							 =     execute(__UpperCamelCase       ,     __UpperCamelCase       ,     shots=1000      )

    return job.result().get_counts(__UpperCamelCase      )


if __name__ == "__main__":
 print(F"Counts for classical state send: {superdense_coding(1,1)}")





