


'''simple docstring'''


from __future__ import annotations

from statistics import mean







def      snake_case_  (    SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__	):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE					:			Tuple							= [0] * no_of_processes
				_SCREAMING_SNAKE_CASE					:			Tuple							= [0] * no_of_processes

				# Initialize remaining_time to waiting_time.

				for i in range(SCREAMING_SNAKE_CASE__	):
								_SCREAMING_SNAKE_CASE					:			Any							= burst_time[i]
				_SCREAMING_SNAKE_CASE					:			list[int]							= []

				_SCREAMING_SNAKE_CASE					:			Optional[int]							= 0
				_SCREAMING_SNAKE_CASE					:			Any							= 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					:			List[Any]							= []
								_SCREAMING_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:
												_SCREAMING_SNAKE_CASE					:			Optional[int]							= ready_process[0]
												for i in ready_process:
																if remaining_time[i] < remaining_time[target_process]:
																				_SCREAMING_SNAKE_CASE					:			Optional[int]							= i
												total_time += burst_time[target_process]
												completed += 1
												_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= 0
												_SCREAMING_SNAKE_CASE					:			Tuple							= (
												    total_time - arrival_time[target_process] - burst_time[target_process]
												)
								else:
												total_time += 1

				return waiting_time







def      snake_case_  (    SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__	):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE					:			str							= [0] * no_of_processes
				for i in range(SCREAMING_SNAKE_CASE__	):
								_SCREAMING_SNAKE_CASE					:			Optional[int]							= burst_time[i] + waiting_time[i]
				return turn_around_time


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

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








'''simple docstring'''


import argparse
import datetime







def      snake_case_  (    SCREAMING_SNAKE_CASE__	):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE					:			Optional[int]							= {
				    """0""": """Sunday""",
				    """1""": """Monday""",
				    """2""": """Tuesday""",
				    """3""": """Wednesday""",
				    """4""": """Thursday""",
				    """5""": """Friday""",
				    """6""": """Saturday""",
				}

				_SCREAMING_SNAKE_CASE					:			Optional[int]							= {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

				# Validate
				if not 0 < len(SCREAMING_SNAKE_CASE__	) < 11:
								raise ValueError("""Must be 10 characters long"""	)

				# Get month
				_SCREAMING_SNAKE_CASE					:			int							= int(date_input[0] + date_input[1]	)
				# Validate
				if not 0 < m < 13:
								raise ValueError("""Month must be between 1 - 12"""	)

				_SCREAMING_SNAKE_CASE					:			str							= date_input[2]
				# Validate
				if sep_a not in ["-", "/"]:
								raise ValueError("""Date separator must be '-' or '/'"""	)

				# Get day
				_SCREAMING_SNAKE_CASE					:			int							= int(date_input[3] + date_input[4]	)
				# Validate
				if not 0 < d < 32:
								raise ValueError("""Date must be between 1 - 31"""	)

				# Get second separator
				_SCREAMING_SNAKE_CASE					:			str							= date_input[5]
				# Validate
				if sep_a not in ["-", "/"]:
								raise ValueError("""Date separator must be '-' or '/'"""	)

				# Get year
				_SCREAMING_SNAKE_CASE					:			int							= int(date_input[6] + date_input[7] + date_input[8] + date_input[9]	)
				# Arbitrary year range
				if not 45 < y < 8500:
								raise ValueError(
								    """Year out of range. There has to be some sort of limit...right?"""	)

				# Get datetime obj for validation
				_SCREAMING_SNAKE_CASE					:			Optional[int]							= datetime.date(int(SCREAMING_SNAKE_CASE__	)				, int(SCREAMING_SNAKE_CASE__	)				, int(SCREAMING_SNAKE_CASE__	)	)

				# Start math
				if m <= 2:
								_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= y - 1
								_SCREAMING_SNAKE_CASE					:			Optional[int]							= m + 12
				# maths var
				_SCREAMING_SNAKE_CASE					:			int							= int(str(SCREAMING_SNAKE_CASE__	)[:2]	)
				_SCREAMING_SNAKE_CASE					:			int							= int(str(SCREAMING_SNAKE_CASE__	)[2:]	)
				_SCREAMING_SNAKE_CASE					:			int							= int(2.6 * m - 5.3_9	)
				_SCREAMING_SNAKE_CASE					:			int							= int(c / 4	)
				_SCREAMING_SNAKE_CASE					:			int							= int(k / 4	)
				_SCREAMING_SNAKE_CASE					:			int							= int(d + k	)
				_SCREAMING_SNAKE_CASE					:			int							= int(t + u + v + x	)
				_SCREAMING_SNAKE_CASE					:			int							= int(z - (2 * c)	)
				_SCREAMING_SNAKE_CASE					:			int							= round(w % 7	)
				# End math

				# Validate math
				if f != convert_datetime_days[dt_ck.weekday()]:
								raise AssertionError("""The date was evaluated incorrectly. Contact developer."""	)

				# Response
				_SCREAMING_SNAKE_CASE					:			str							= f"""Your date {date_input}, is a {days[str(SCREAMING_SNAKE_CASE__	)]}!"""
				return response


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				UpperCAmelCase_						:  Tuple				  =						argparse.ArgumentParser(
				    description=(
				        'Find out what day of the week nearly any date is or was. Enter '
				        'date as a string in the mm-dd-yyyy or mm/dd/yyyy format'
				    )
				)
				parser.add_argument(
				    'date_input', type=str, help='Date as a string (mm-dd-yyyy or mm/dd/yyyy)'
				)
				UpperCAmelCase_						:  List[Any]				  =						parser.parse_args()
				zeller(args.date_input)




