






from __future__ import annotations
def 							UpperCAmelCase   ( _lowercase,   _lowercase,   _lowercase   ):


    '''simple docstring'''



    assert (
        c % greatest_common_divisor(_SCREAMING_SNAKE_CASE,   _SCREAMING_SNAKE_CASE   ) == 0
    )  # greatest_common_divisor(a,b) function implemented below
    ((_lowercase)			,     (_lowercase)			,     (_lowercase))     			=						extended_gcd(_SCREAMING_SNAKE_CASE,   _SCREAMING_SNAKE_CASE   )  # extended_gcd(a,b) function implemented below
    _lowercase     			=						c / d
    return (r * x, r * y)
def 							UpperCAmelCase   ( _lowercase,   _lowercase,   _lowercase,   _lowercase = 2   ):


    '''simple docstring'''



    ((_lowercase)			,     (_lowercase))     			=						diophantine(_SCREAMING_SNAKE_CASE,   _SCREAMING_SNAKE_CASE,   _SCREAMING_SNAKE_CASE   )  # Initial value
    _lowercase     			=						greatest_common_divisor(_SCREAMING_SNAKE_CASE,   _SCREAMING_SNAKE_CASE   )
    _lowercase     			=						a // d
    _lowercase     			=						b // d

    for i in range(_SCREAMING_SNAKE_CASE   ):
        _lowercase     			=						xa + i * q
        _lowercase     			=						ya - i * p
        print(_SCREAMING_SNAKE_CASE,   _SCREAMING_SNAKE_CASE   )
def 							UpperCAmelCase   ( _lowercase,   _lowercase   ):


    '''simple docstring'''



    if a < b:
        _lowercase			,     _lowercase     			=						b, a

    while a % b != 0:
        _lowercase			,     _lowercase     			=						b, a % b

    return b
def 							UpperCAmelCase   ( _lowercase,   _lowercase   ):


    '''simple docstring'''



    assert a >= 0 and b >= 0

    if b == 0:
        _lowercase			,     _lowercase			,     _lowercase     			=						a, 1, 0
    else:
        ((_lowercase)			,     (_lowercase)			,     (_lowercase))     			=						extended_gcd(_SCREAMING_SNAKE_CASE,   a % b   )
        _lowercase     			=						q
        _lowercase     			=						p - q * (a // b)

    assert a % d == 0 and b % d == 0
    assert d == a * x + b * y

    return (d, x, y)


if __name__ == "__main__":
   from doctest import testmod

   testmod(name='''diophantine''', verbose=True)
   testmod(name='''diophantine_all_soln''', verbose=True)
   testmod(name='''extended_gcd''', verbose=True)
   testmod(name='''greatest_common_divisor''', verbose=True)



from __future__ import annotations


def        _UpperCAmelCase							(	_SCREAMING_SNAKE_CASE       :		list[int]							):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_						=    [0] * len(_SCREAMING_SNAKE_CASE							)
    for i in range(1			, len(_SCREAMING_SNAKE_CASE							)							):
        SCREAMING_SNAKE_CASE_						=    duration_times[i - 1] + waiting_times[i - 1]
    return waiting_times


def        _UpperCAmelCase							(	_SCREAMING_SNAKE_CASE       :		list[int]			, _SCREAMING_SNAKE_CASE       :		list[int]							):





    """simple docstring"""


    return [
        duration_time + waiting_times[i]
        for i, duration_time in enumerate(_SCREAMING_SNAKE_CASE							)
    ]


def        _UpperCAmelCase							(	_SCREAMING_SNAKE_CASE       :		list[int]							):





    """simple docstring"""


    return sum(_SCREAMING_SNAKE_CASE							) / len(_SCREAMING_SNAKE_CASE							)


def        _UpperCAmelCase							(	_SCREAMING_SNAKE_CASE       :		list[int]							):





    """simple docstring"""


    return sum(_SCREAMING_SNAKE_CASE							) / len(_SCREAMING_SNAKE_CASE							)


if __name__ == "__main__":
       # process id's
       UpperCamelCase__	:   List[str]								=     [1, 2, 3]

       # ensure that we actually have processes
       if len(processes) == 0:
              print("Zero amount of processes")
              raise SystemExit(0)

       # duration time of all processes
       UpperCamelCase__	:   Any								=     [19, 8, 9]

       # ensure we can match each id to a duration time
       if len(duration_times) != len(processes):
              print("Unable to match all id's with their duration time")
              raise SystemExit(0)

       # get the waiting times and the turnaround times
       UpperCamelCase__	:   List[str]								=     calculate_waiting_times(duration_times)
       UpperCamelCase__	:   Union[str, Any]								=     calculate_turnaround_times(duration_times, waiting_times)

       # get the average times
       UpperCamelCase__	:   str								=     calculate_average_waiting_time(waiting_times)
       UpperCamelCase__	:   List[Any]								=     calculate_average_turnaround_time(turnaround_times)

       # print all the results
       print("Process ID\tDuration Time\tWaiting Time\tTurnaround Time")
       for i, process in enumerate(processes):
              print(
                  F'{process}\t\t{duration_times[i]}\t\t{waiting_times[i]}\t\t'
                  F'{turnaround_times[i]}'
              )
       print(F'Average waiting time = {average_waiting_time}')
       print(F'Average turn around time = {average_turnaround_time}')


