






"""simple docstring"""







import argparse
import datetime






def       _lowerCAmelCase       (      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			{
           """0""": """Sunday""",
           """1""": """Monday""",
           """2""": """Tuesday""",
           """3""": """Wednesday""",
           """4""": """Thursday""",
           """5""": """Friday""",
           """6""": """Saturday""",
       }

       UpperCAmelCase	    =			{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
       UpperCAmelCase	    =			int(date_input[0] + date_input[1]		)
       # Validate
       if not 0 < m < 13:
              raise ValueError("""Month must be between 1 - 12"""		)

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

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

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

       # Get year
       UpperCAmelCase	    =			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
       UpperCAmelCase	    =			datetime.date(int(_SCREAMING_SNAKE_CASE		)	,      int(_SCREAMING_SNAKE_CASE		)	,      int(_SCREAMING_SNAKE_CASE		)		)

       # Start math
       if m <= 2:
              UpperCAmelCase	    =			y - 1
              UpperCAmelCase	    =			m + 12
       # maths var
       UpperCAmelCase	    =			int(str(_SCREAMING_SNAKE_CASE		)[:2]		)
       UpperCAmelCase	    =			int(str(_SCREAMING_SNAKE_CASE		)[2:]		)
       UpperCAmelCase	    =			int(2.6 * m - 5.39		)
       UpperCAmelCase	    =			int(c / 4		)
       UpperCAmelCase	    =			int(k / 4		)
       UpperCAmelCase	    =			int(d + k		)
       UpperCAmelCase	    =			int(t + u + v + x		)
       UpperCAmelCase	    =			int(z - (2 * c)		)
       UpperCAmelCase	    =			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
       UpperCAmelCase	    =			F'''Your date {date_input}, is a {days[str(_SCREAMING_SNAKE_CASE		)]}!'''
       return response


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 lowerCAmelCase_	:    Any					     =      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)'''
 )
 lowerCAmelCase_	:    str					     =      parser.parse_args()
 zeller(args.date_input)








"""simple docstring"""







from __future__ import annotations

import pandas as pd






def       _lowerCAmelCase       (      lowerCAmelCase	,      lowerCAmelCase	,      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			[0] * no_of_processes
       UpperCAmelCase	    =			[0] * no_of_processes
       # Copy the burst time into remaining_time[]
       for i in range(lowerCAmelCase		):
              UpperCAmelCase	    =			burst_time[i]

       UpperCAmelCase	    =			0
       UpperCAmelCase	    =			0
       UpperCAmelCase	    =			999999999
       UpperCAmelCase	    =			0
       UpperCAmelCase	    =			False

       # Process until all processes are completed
       while complete != no_of_processes:
              for j in range(lowerCAmelCase		):
                     if arrival_time[j] <= increment_time and remaining_time[j] > 0:
                            if remaining_time[j] < minm:
                                   UpperCAmelCase	    =			remaining_time[j]
                                   UpperCAmelCase	    =			j
                                   UpperCAmelCase	    =			True

              if not check:
                     increment_time += 1
                     continue
              remaining_time[short] -= 1

              UpperCAmelCase	    =			remaining_time[short]
              if minm == 0:
                     UpperCAmelCase	    =			999999999

              if remaining_time[short] == 0:
                     complete += 1
                     UpperCAmelCase	    =			False

                     # Find finish time of current process
                     UpperCAmelCase	    =			increment_time + 1

                     # Calculate waiting time
                     UpperCAmelCase	    =			finish_time - arrival_time[short]
                     UpperCAmelCase	    =			finar - burst_time[short]

                     if waiting_time[short] < 0:
                            UpperCAmelCase	    =			0

        # Increment time
              increment_time += 1
       return waiting_time






def       _lowerCAmelCase       (      lowerCAmelCase	,      lowerCAmelCase	,      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			[0] * no_of_processes
       for i in range(lowerCAmelCase		):
              UpperCAmelCase	    =			burst_time[i] + waiting_time[i]
       return turn_around_time






def       _lowerCAmelCase       (      lowerCAmelCase	,      lowerCAmelCase	,      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			0
       UpperCAmelCase	    =			0
       for i in range(lowerCAmelCase		):
              UpperCAmelCase	    =			total_waiting_time + waiting_time[i]
              UpperCAmelCase	    =			total_turn_around_time + turn_around_time[i]
       print(F'''Average waiting time = {total_waiting_time / no_of_processes:.5f}'''		)
       print("""Average turn around time ="""	,      total_turn_around_time / no_of_processes		)


if __name__ == "__main__":
 print('''Enter how many process you want to analyze''')
 lowerCAmelCase_	:    Optional[Any]            =      int(input())
 lowerCAmelCase_	:    List[Any]            =      [0] * no_of_processes
 lowerCAmelCase_	:    Optional[Any]            =      [0] * no_of_processes
 lowerCAmelCase_	:    int            =      list(range(1, no_of_processes + 1))

 for i in range(no_of_processes):
  print('''Enter the arrival time and burst time for process:--''' + str(i + 1))
  lowerCAmelCase_     ,					lowerCAmelCase_	:    Optional[Any]            =      map(int, input().split())

 lowerCAmelCase_	:    str            =      calculate_waitingtime(arrival_time, burst_time, no_of_processes)

 lowerCAmelCase_	:    str            =      burst_time
 lowerCAmelCase_	:    List[Any]            =      no_of_processes
 lowerCAmelCase_	:    int            =      waiting_time
 lowerCAmelCase_	:    int            =      calculate_turnaroundtime(bt, n, wt)

 calculate_average_times(waiting_time, turn_around_time, no_of_processes)

 lowerCAmelCase_	:    List[Any]            =      pd.DataFrame(
     list(zip(processes, burst_time, arrival_time, waiting_time, turn_around_time)),
     columns=[
         '''Process''',
         '''BurstTime''',
         '''ArrivalTime''',
         '''WaitingTime''',
         '''TurnAroundTime''',
     ],
 )

 # Printing the dataFrame
 pd.set_option('''display.max_rows''', fcfs.shape[0] + 1)
 print(fcfs)
