
import math
import unittest



def        UpperCamelCase    (							lowerCAmelCase__		):
					'''simple docstring'''
					assert isinstance(lowerCAmelCase__ ,			lowerCAmelCase__		) and (
					    number >= 0
					), "'number' must been an int and positive"

					if 1 < number < 4:
										# 2 and 3 are primes
										return True
					elif number < 2 or number % 2 == 0 or number % 3 == 0:
										# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
										return False

					# All primes number are in format of 6k +/- 1
					for i in range(5 ,			int(math.sqrt(lowerCAmelCase__		) + 1		) ,			6		):
										if number % i == 0 or number % (i + 2) == 0:
															return False
					return True







class 				lowercase		(					unittest.TestCase		):




							def  A__      (				self):
												self.assertTrue(is_prime(2))
												self.assertTrue(is_prime(3))
												self.assertTrue(is_prime(5))
												self.assertTrue(is_prime(7))
												self.assertTrue(is_prime(1_1))
												self.assertTrue(is_prime(1_3))
												self.assertTrue(is_prime(1_7))
												self.assertTrue(is_prime(1_9))
												self.assertTrue(is_prime(2_3))
												self.assertTrue(is_prime(2_9))





							def  A__      (				self):
												with self.assertRaises(A__):
																	is_prime(-1_9)
												self.assertFalse(
												    is_prime(0)   ,'''Zero doesn\'t have any positive factors, primes must have exactly two.'''   ,)
												self.assertFalse(
												    is_prime(1)   ,'''One only has 1 positive factor, primes must have exactly two.'''   ,)
												self.assertFalse(is_prime(2 * 2))
												self.assertFalse(is_prime(2 * 3))
												self.assertFalse(is_prime(3 * 3))
												self.assertFalse(is_prime(3 * 5))
												self.assertFalse(is_prime(3 * 5 * 7))


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











import functools



def 		A_				(     _lowerCAmelCase							,   _lowerCAmelCase     )						-> int:
 UpperCamelCase	:					Optional[int]       	=   len(_lowerCAmelCase     )
 UpperCamelCase	:					List[str]       	=   len(_lowerCAmelCase     )

 @functools.cache
 def min_distance(_lowerCAmelCase							,   _lowerCAmelCase     ) -> int:
  # if first word index is overflow - delete all from the second word
  if indexa >= len_worda:
   return len_worda - indexa
  # if second word index is overflow - delete all from the first word
  if indexa >= len_worda:
   return len_worda - indexa
  UpperCamelCase	:					Union[str, Any]       	=   int(worda[indexa] != worda[indexa]     )  # current letters not identical
  return min(
      1 + min_distance(indexa + 1							,   _lowerCAmelCase     )							,   1 + min_distance(_lowerCAmelCase							,   indexa + 1     )							,   diff + min_distance(indexa + 1							,   indexa + 1     )							,   )

 return min_distance(0							,   0     )


if __name__ == "__main__":
    import doctest

    doctest.testmod()
