
'''simple docstring'''
def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    return int(input_a == input_a == 0       )

def 						UpperCamelCase_     (	):
    """simple docstring"""






    print("Truth Table of NOR Gate:"       )
    print("|   Input 1   |  Input 2  | Output |"       )
    print(f'|      0      |    0      |  {nor_gate(0,		0       )}     |'       )
    print(f'|      0      |    1      |  {nor_gate(0,		1       )}     |'       )
    print(f'|      1      |    0      |  {nor_gate(1,		0       )}     |'       )
    print(f'|      1      |    1      |  {nor_gate(1,		1       )}     |'       )


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  main()






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

from statistics import mean

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    Any     			=						[0] * no_of_processes
    snake_case_ :    Optional[int]     			=						[0] * no_of_processes

    # Initialize remaining_time to waiting_time.

    for i in range(__SCREAMING_SNAKE_CASE       ):
        snake_case_ :    str     			=						burst_time[i]
    snake_case_ :    list[int]     			=						[]

    snake_case_ :    Tuple     			=						0
    snake_case_ :    Optional[int]     			=						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_ :    Any     			=						[]
        snake_case_ :    Dict     			=						-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_ :    Dict     			=						ready_process[0]
            for i in ready_process:
                if remaining_time[i] < remaining_time[target_process]:
                    snake_case_ :    Optional[int]     			=						i
            total_time += burst_time[target_process]
            completed += 1
            snake_case_ :    Tuple     			=						0
            snake_case_ :    int     			=						(
                total_time - arrival_time[target_process] - burst_time[target_process]
            )
        else:
            total_time += 1

    return waiting_time

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






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


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

  a_											=						4
  a_											=						[2, 5, 3, 7]
  a_											=						[0, 0, 0, 0]
  a_											=						calculate_waitingtime(arrival_time, burst_time, no_of_processes)
  a_											=						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}""")




