

from statistics import mean

import numpy as np







def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE   ):
      '''simple docstring'''







      A_							       =		0
      # Number of processes finished
      A_							       =		0
      # Displays the finished process.
      # If it is 0, the performance is completed if it is 1, before the performance.
      A_							       =		[0] * no_of_process
      # List to include calculation results
      A_							       =		[0] * no_of_process

      # Sort by arrival time.
      A_							       =		[burst_time[i] for i in np.argsort(SCREAMING_SNAKE_CASE   )]
      A_							       =		[process_name[i] for i in np.argsort(SCREAMING_SNAKE_CASE   )]
      arrival_time.sort()

      while no_of_process > finished_process_count:
            A_							       =		0
            while finished_process[i] == 1:
                  i += 1
            if current_time < arrival_time[i]:
                  A_							       =		arrival_time[i]

            A_							       =		0
            # Index showing the location of the process being performed
            A_							       =		0
            # Saves the current response ratio.
            A_							       =		0
            for i in range(0		,				SCREAMING_SNAKE_CASE   ):
                  if finished_process[i] == 0 and arrival_time[i] <= current_time:
                        A_							       =		(burst_time[i] + (current_time - arrival_time[i])) / burst_time[
                            i
                        ]
                  if response_ratio < temp:
                        A_							       =		temp
                        A_							       =		i

        # Calculate the turn around time
            A_							       =		current_time + burst_time[loc] - arrival_time[loc]
            current_time += burst_time[loc]
            # Indicates that the process has been performed.
            A_							       =		1
            # Increase finished_process_count by 1
            finished_process_count += 1

      return turn_around_time







def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE   ):
      '''simple docstring'''







      A_							       =		[0] * no_of_process
      for i in range(0		,				SCREAMING_SNAKE_CASE   ):
            A_							       =		turn_around_time[i] - burst_time[i]
      return waiting_time


if __name__ == "__main__":
      __lowercase				      =						5
      __lowercase				      =						["""A""", """B""", """C""", """D""", """E"""]
      __lowercase				      =						[1, 2, 3, 4, 5]
      __lowercase				      =						[1, 2, 3, 4, 5]

      __lowercase				      =						calculate_turn_around_time(
          process_name, arrival_time, burst_time, no_of_process
      )
      __lowercase				      =						calculate_waiting_time(
          process_name, turn_around_time, burst_time, no_of_process
      )

      print("""Process name \tArrival time \tBurst time \tTurn around time \tWaiting time""")
      for i in range(0, no_of_process):
            print(
                f'{process_name[i]}\t\t{arrival_time[i]}\t\t{burst_time[i]}\t\t'
                f'{turn_around_time[i]}\t\t\t{waiting_time[i]}'
            )

      print(f'average waiting time : {mean(waiting_time):.5f}')
      print(f'average turn around time : {mean(turn_around_time):.5f}')








def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE   ):
      '''simple docstring'''







      return int((input_a, input_a).count(0   ) != 0   )







def 							_lowerCamelCase   (			):
      '''simple docstring'''







      assert nand_gate(0		,				0   ) == 1
      assert nand_gate(0		,				1   ) == 1
      assert nand_gate(1		,				0   ) == 1
      assert nand_gate(1		,				1   ) == 0


if __name__ == "__main__":
      print(nand_gate(0, 0))
      print(nand_gate(0, 1))
      print(nand_gate(1, 0))
      print(nand_gate(1, 1))





