code: 
  
  
  from __future__ import annotations
  
  from collections import Counter
  
  
  
  def 	SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							List[str]:
  				A__     :							Optional[Any]   				=[True] * n
  				A__     :							Any   				=False
  				A__     :							Tuple   				=False
  				A__     :							Optional[Any]   				=True
  
  				for i in range(3,	int(n**0.5 + 1	),	2	):
  								A__     :							Any   				=i * 2
  								while index < n:
  												A__     :							Optional[int]   				=False
  												A__     :							Tuple   				=index + i
  
  				A__     :							int   				=[2]
  
  				for i in range(3,	snake_case_,	2	):
  								if is_prime[i]:
  												primes.append(snake_case_	)
  
  				return primes
  
  
  
  def 	SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							Union[str, Any]:
  				A__     :							List[Any]   				=str(snake_case_	)
  				A__     :							Tuple   				=[]
  				A__     :							Optional[int]   				=["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
  
  				for duplicate in Counter(snake_case_	) - Counter(set(snake_case_	)	):
  								A__     :							Optional[Any]   				=[int(number_str.replace(snake_case_,	snake_case_	)	) for digit in digits]
  								replacements.append(snake_case_	)
  
  				return replacements
  
  
  
  def 	SCREAMING_SNAKE_CASE__						(							snake_case_ = 8	)			->							List[Any]:
  				A__     :							Union[str, Any]   				=set()
  
  				# Filter primes with less than 3 replaceable digits
  				A__     :							Optional[Any]   				={
  				    x for x in set(prime_sieve(1_0_0_0_0_0_0	)	) if len(str(snake_case_	)	) - len(set(str(snake_case_	)	)	) >= 3
  				}
  
  				for prime in primes:
  								if prime in numbers_checked:
  												continue
  
  								A__     :							Optional[int]   				=digit_replacements(snake_case_	)
  
  								for family in replacements:
  												numbers_checked.update(snake_case_	)
  												A__     :							Dict   				=primes.intersection(snake_case_	)
  
  												if len(snake_case_	) != family_length:
  																continue
  
  												return min(snake_case_	)
  
  				return -1
  
  
  if __name__ == "__main__":
  						print(solution())
  
  
  
  
style_context: 
  
  
  from __future__ import annotations
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							list[int]:
  				A__     :							Optional[int]   				=[0] * len(snake_case_	)
  				for i in range(1,	len(snake_case_	)	):
  								A__     :							List[Any]   				=duration_times[i - 1] + waiting_times[i - 1]
  				return waiting_times
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_,	snake_case_	)			->							list[int]:
  				return [
  				    duration_time + waiting_times[i]
  				    for i, duration_time in enumerate(snake_case_	)
  				]
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							float:
  				return sum(snake_case_	) / len(snake_case_	)
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							float:
  				return sum(snake_case_	) / len(snake_case_	)
  
  
  if __name__ == "__main__":
  						# process id's
  						__lowerCamelCase       :       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
  						__lowerCamelCase       :       Dict				   =			[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
  						__lowerCamelCase       :       int				   =			calculate_waiting_times(duration_times)
  						__lowerCamelCase       :       Optional[int]				   =			calculate_turnaround_times(duration_times, waiting_times)
  
  						# get the average times
  						__lowerCamelCase       :       List[str]				   =			calculate_average_waiting_time(waiting_times)
  						__lowerCamelCase       :       Dict				   =			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}")
  
  
  
  