from __future__ import annotations

from statistics import mean



def 			__SCREAMING_SNAKE_CASE						(      __UpperCamelCase					: list[int]				,  __UpperCamelCase					: list[int]				,  __UpperCamelCase					: int			)							->      list[int]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__    							=   [0] * no_of_processes
  SCREAMING_SNAKE_CASE__    							=   [0] * no_of_processes

  # Initialize remaining_time to waiting_time.

  for i in range(__UpperCamelCase			):
    SCREAMING_SNAKE_CASE__    							=   burst_time[i]
  SCREAMING_SNAKE_CASE__    							=   []

  SCREAMING_SNAKE_CASE__    							=   0
  SCREAMING_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:
    SCREAMING_SNAKE_CASE__    							=   []
    SCREAMING_SNAKE_CASE__    							=   -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:
      SCREAMING_SNAKE_CASE__    							=   ready_process[0]
      for i in ready_process:
        if remaining_time[i] < remaining_time[target_process]:
          SCREAMING_SNAKE_CASE__    							=   i
      total_time += burst_time[target_process]
      completed += 1
      SCREAMING_SNAKE_CASE__    							=   0
      SCREAMING_SNAKE_CASE__    							=   (
          total_time - arrival_time[target_process] - burst_time[target_process]
      )
    else:
      total_time += 1

  return waiting_time



def 			__SCREAMING_SNAKE_CASE						(      __UpperCamelCase					: list[int]				,  __UpperCamelCase					: int				,  __UpperCamelCase					: list[int]			)							->      list[int]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__    							=   [0] * no_of_processes
  for i in range(__UpperCamelCase			):
    SCREAMING_SNAKE_CASE__    							=   burst_time[i] + waiting_time[i]
  return turn_around_time


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

   __lowerCamelCase    :				List[Any]							     =	4
   __lowerCamelCase    :				Optional[Any]							     =	[2, 5, 3, 7]
   __lowerCamelCase    :				List[str]							     =	[0, 0, 0, 0]
   __lowerCamelCase    :				List[str]							     =	calculate_waitingtime(arrival_time, burst_time, no_of_processes)
   __lowerCamelCase    :				List[str]							     =	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}""")

from math import log

from scipy.constants import Boltzmann, physical_constants

__lowerCamelCase    :				int							     =	300  # TEMPERATURE (unit = K)



def 			__SCREAMING_SNAKE_CASE						(      __UpperCamelCase					: float				,  __UpperCamelCase					: float				,  __UpperCamelCase					: float				,  )							->      float:







  """simple docstring"""





  if donor_conc <= 0:
    raise ValueError("""Donor concentration should be positive"""			)
  elif acceptor_conc <= 0:
    raise ValueError("""Acceptor concentration should be positive"""			)
  elif intrinsic_conc <= 0:
    raise ValueError("""Intrinsic concentration should be positive"""			)
  elif donor_conc <= intrinsic_conc:
    raise ValueError(
        """Donor concentration should be greater than intrinsic concentration"""			)
  elif acceptor_conc <= intrinsic_conc:
    raise ValueError(
        """Acceptor concentration should be greater than intrinsic concentration"""			)
  else:
    return (
        Boltzmann
        * T
        * log((donor_conc * acceptor_conc) / intrinsic_conc**2			)
        / physical_constants["electron volt"][0]
    )


if __name__ == "__main__":
   import doctest

   doctest.testmod()
