





'''simple docstring'''






from statistics import mean

import numpy as np
def    UpperCamelCase__      (		lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase  ):





      """simple docstring"""


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

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

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

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

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

      return turn_around_time
def    UpperCamelCase__      (		lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase  ):





      """simple docstring"""


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


if __name__ == "__main__":
      A__				:   str      =5
      A__				:   List[Any]      =['''A''', '''B''', '''C''', '''D''', '''E''']
      A__				:   Optional[Any]      =[1, 2, 3, 4, 5]
      A__				:   List[str]      =[1, 2, 3, 4, 5]

      A__				:   int      =calculate_turn_around_time(
          process_name, arrival_time, burst_time, no_of_process
      )
      A__				:   Optional[int]      =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}""")











"""simple docstring"""







def      __UpperCAmelCase      (    __lowerCamelCase						,     __lowerCamelCase	)							->      List[Any]:
		print('''\nThe shortest path matrix using Floyd Warshall algorithm\n'''	)
		for i in range(__lowerCamelCase	):
				for j in range(__lowerCamelCase	):
						if dist[i][j] != float('''inf'''	):
								print(int(dist[i][j]	)						,     end='''\t'''	)
						else:
								print('''INF'''						,     end='''\t'''	)
				print()



def      __UpperCAmelCase      (    __lowerCamelCase						,     __lowerCamelCase	)							->      Optional[Any]:
		lowercase__   :    str				=			[[float('''inf'''	) for _ in range(__lowerCamelCase	)] for _ in range(__lowerCamelCase	)]

		for i in range(__lowerCamelCase	):
				for j in range(__lowerCamelCase	):
						lowercase__   :    List[str]				=			graph[i][j]

						# check vertex k against all other vertices (i, j)
		for k in range(__lowerCamelCase	):
				# looping through rows of graph array
				for i in range(__lowerCamelCase	):
						# looping through columns of graph array
						for j in range(__lowerCamelCase	):
								if (
								    dist[i][k] != float('''inf'''	)
								    and dist[k][j] != float('''inf'''	)
								    and dist[i][k] + dist[k][j] < dist[i][j]
								):
										lowercase__   :    str				=			dist[i][k] + dist[k][j]

		_print_dist(__lowerCamelCase						,     __lowerCamelCase	)
		return dist, v


if __name__ == "__main__":
							lowerCAmelCase_   						=   int(input('Enter number of vertices: '))
							lowerCAmelCase_   						=   int(input('Enter number of edges: '))

							lowerCAmelCase_   						=   [[float('inf') for i in range(v)] for j in range(v)]

							for i in range(v):
														lowerCAmelCase_   						=   0.0

														# src and dst are indices that must be within the array size graph[e][v]
														# failure to follow this will result in an error
							for i in range(e):
														print('\nEdge ', i + 1)
														lowerCAmelCase_   						=   int(input('Enter source:'))
														lowerCAmelCase_   						=   int(input('Enter destination:'))
														lowerCAmelCase_   						=   float(input('Enter weight:'))
														lowerCAmelCase_   						=   weight

							floyd_warshall(graph, v)

							# Example Input
							# Enter number of vertices: 3
							# Enter number of edges: 2

							# # generated graph from vertex and edge inputs
							# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
							# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

							# specify source, destination and weight for edge #1
							# Edge  1
							# Enter source:1
							# Enter destination:2
							# Enter weight:2

							# specify source, destination and weight for edge #2
							# Edge  2
							# Enter source:2
							# Enter destination:1
							# Enter weight:1

							# # Expected Output from the vertice, edge and src, dst, weight inputs!!
							# 0		INF	INF
							# INF	0	2
							# INF	1	0
