



from __future__ import annotations

from statistics import mean






def 			__lowercase     (				a__     )       ->				list[int]:
							__SCREAMING_SNAKE_CASE								=      2
							__SCREAMING_SNAKE_CASE								=      list(__a     )
							__SCREAMING_SNAKE_CASE								=      [0] * len(__a     )
							__SCREAMING_SNAKE_CASE								=      0
							while True:
														__SCREAMING_SNAKE_CASE								=      True
														for i, burst_time in enumerate(__a     ):
																					if rem_burst_times[i] > 0:
																												__SCREAMING_SNAKE_CASE								=      False
																												if rem_burst_times[i] > quantum:
																																			t += quantum
																																			rem_burst_times[i] -= quantum
																												else:
																																			t += rem_burst_times[i]
																																			__SCREAMING_SNAKE_CASE								=      t - burst_time
																																			__SCREAMING_SNAKE_CASE								=      0
														if done is True:
																					return waiting_times






def 			__lowercase     (				a__							,     a__     )       ->				list[int]:
							return [burst + waiting for burst, waiting in zip(__a							,     __a     )]


if __name__ == "__main__":
			lowerCAmelCase__	:  Optional[Any] 		=[3, 5, 7]
			lowerCAmelCase__	:  str 		=calculate_waiting_times(burst_times)
			lowerCAmelCase__	:  Union[str, Any] 		=calculate_turn_around_times(burst_times, waiting_times)
			print('''Process ID \tBurst Time \tWaiting Time \tTurnaround Time''')
			for i, burst_time in enumerate(burst_times):
						print(
						    F'''  {i + 1}\t\t  {burst_time}\t\t  {waiting_times[i]}\t\t  '''
						    F'''{turn_around_times[i]}'''
						)
			print(F'''\nAverage waiting time = {mean(waiting_times):.5f}''')
			print(F'''Average turn around time = {mean(turn_around_times):.5f}''')











import unittest

from cer import CER


lowerCAmelCase__	:  Dict 		=CER()

class      UpperCAmelCase_						(     unittest.TestCase ):

						'''simple docstring'''




						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['White House']
													__SCREAMING_SNAKE_CASE								=      ['white house']
													# S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.1_8_1_8_1_8_1_8_1_8	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['were wolf']
													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													# S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.1_1_1_1_1_1_1	) < 1e-6	)

													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													__SCREAMING_SNAKE_CASE								=      ['weae     wolf']
													# S = 1, D = 1, I = 0, N = 8, CER = 0.25
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.2_5	) < 1e-6	)

													# consecutive whitespaces case 1
													__SCREAMING_SNAKE_CASE								=      ['were wolf']
													__SCREAMING_SNAKE_CASE								=      ['were               wolf']
													# S = 0, D = 0, I = 0, N = 9, CER = 0
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.0	) < 1e-6	)

													# consecutive whitespaces case 2
													__SCREAMING_SNAKE_CASE								=      ['were   wolf']
													__SCREAMING_SNAKE_CASE								=      ['were               wolf']
													# S = 0, D = 0, I = 0, N = 9, CER = 0
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.0	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													__SCREAMING_SNAKE_CASE								=      ['weaewolf']
													# S = 1, D = 0, I = 0, N = 8, CER = 0.125
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.1_2_5	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													__SCREAMING_SNAKE_CASE								=      ['wereawolf']
													# S = 0, D = 1, I = 0, N = 8, CER = 0.125
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.1_2_5	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													__SCREAMING_SNAKE_CASE								=      ['wereolf']
													# S = 0, D = 0, I = 1, N = 8, CER = 0.125
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.1_2_5	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertEqual(_A   ,							0.0	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['werewolf', 'I am your father']
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertEqual(_A   ,							0.0	)

													__SCREAMING_SNAKE_CASE								=      ['werewolf', 'I am your father', 'doge']
													__SCREAMING_SNAKE_CASE								=      ['werxwolf', 'I       am your father', 'doge']
													# S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.0_3_5_7_1_4_2_8	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['My hovercraft', 'is full of eels']
													__SCREAMING_SNAKE_CASE								=      ['My hovercraft is full', ' of eels']
													# S = 0, D = 0, I = 2, N = 28, CER = 2 / 28
													# whitespace at the front of " of eels" will be strip during preporcessing
													# so need to insert 2 whitespaces
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A   ,							concatenate_texts=_A	)
													self.assertTrue(abs(char_error_rate - 0.0_7_1_4_2_8	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['我能吞下玻璃而不伤身体']
													__SCREAMING_SNAKE_CASE								=      [' 能吞虾玻璃而 不霜身体啦']
													# S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.4_5_4_5_4_5_4_5_4_5	) < 1e-6	)

													__SCREAMING_SNAKE_CASE								=      ['我能吞下玻璃', '而不伤身体']
													__SCREAMING_SNAKE_CASE								=      ['我    能 吞 下 玻 璃', '而不伤身体']
													# S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.4_5_4_5_4_5_4_5_4_5_4_5	) < 1e-6	)

													__SCREAMING_SNAKE_CASE								=      ['我能吞下玻璃而不伤身体']
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertFalse(_A   ,							0.0	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['']
													__SCREAMING_SNAKE_CASE								=      ['Hypothesis']
													with self.assertRaises(_A	):
																				cer.compute(predictions=_A   ,							references=_A	)


if __name__ == "__main__":
			unittest.main()






