





'''simple docstring'''



import math
import unittest




def    _lowerCAmelCase						(				lowerCamelCase_			:  int				):
			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						):







	'''simple docstring'''

	def 						_UpperCAmelCase     (self )							->							Dict:







				'''simple docstring'''





				self.assertTrue(is_prime(2 ) )
				self.assertTrue(is_prime(3 ) )
				self.assertTrue(is_prime(5 ) )
				self.assertTrue(is_prime(7 ) )
				self.assertTrue(is_prime(11 ) )
				self.assertTrue(is_prime(13 ) )
				self.assertTrue(is_prime(17 ) )
				self.assertTrue(is_prime(19 ) )
				self.assertTrue(is_prime(23 ) )
				self.assertTrue(is_prime(29 ) )


	def 						_UpperCAmelCase     (self )							->							int:







				'''simple docstring'''





				with self.assertRaises(_lowerCamelCase ):
							is_prime(-19 )
				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()












'''simple docstring'''



from __future__ import annotations

import time
from collections.abc import Sequence
from random import randint

from matplotlib import pyplot as plt




def    _lowerCAmelCase						(				lowerCamelCase_			:  Sequence[float]		,       lowerCamelCase_			:  int		,       lowerCamelCase_			:  int				):
			if not arr:
						return None, None, 0
			if low == high:
						return low, high, arr[low]

			__lowercase										=							(low + high) // 2
			__lowercase						,		__lowercase						,		__lowercase										=							max_subarray(lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_				)
			__lowercase						,		__lowercase						,		__lowercase										=							max_subarray(lowerCamelCase_		,       mid + 1		,       lowerCamelCase_				)
			__lowercase						,		__lowercase						,		__lowercase										=							max_cross_sum(lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_				)
			if left_sum >= right_sum and left_sum >= cross_sum:
						return left_low, left_high, left_sum
			elif right_sum >= left_sum and right_sum >= cross_sum:
						return right_low, right_high, right_sum
			return cross_left, cross_right, cross_sum




def    _lowerCAmelCase						(				lowerCamelCase_			:  Sequence[float]		,       lowerCamelCase_			:  int		,       lowerCamelCase_			:  int		,       lowerCamelCase_			:  int				):
			__lowercase						,		__lowercase										=							float('''-inf'''				), -1
			__lowercase						,		__lowercase										=							float('''-inf'''				), -1

			__lowercase										=							0
			for i in range(lowerCamelCase_		,       low - 1		,       -1				):
						summ += arr[i]
						if summ > left_sum:
									__lowercase										=							summ
									__lowercase										=							i

			__lowercase										=							0
			for i in range(mid + 1		,       high + 1				):
						summ += arr[i]
						if summ > right_sum:
									__lowercase										=							summ
									__lowercase										=							i

			return max_left, max_right, (left_sum + right_sum)




def    _lowerCAmelCase						(				lowerCamelCase_			:  int				):
			__lowercase										=							[randint(1		,       lowerCamelCase_				) for _ in range(lowerCamelCase_				)]
			__lowercase										=							time.time()
			max_subarray(lowerCamelCase_		,       0		,       input_size - 1				)
			__lowercase										=							time.time()
			return end - start




def    _lowerCAmelCase						(				):
			__lowercase										=							[1_0, 1_0_0, 1_0_0_0, 1_0_0_0_0, 5_0_0_0_0, 1_0_0_0_0_0, 2_0_0_0_0_0, 3_0_0_0_0_0, 4_0_0_0_0_0, 5_0_0_0_0_0]
			__lowercase										=							[time_max_subarray(lowerCamelCase_				) for input_size in input_sizes]
			print('''No of Inputs\t\tTime Taken'''				)
			for input_size, runtime in zip(lowerCamelCase_		,       lowerCamelCase_				):
						print(lowerCamelCase_		,       '''\t\t'''		,       lowerCamelCase_				)
			plt.plot(lowerCamelCase_		,       lowerCamelCase_				)
			plt.xlabel('''Number of Inputs'''				)
			plt.ylabel('''Time taken in seconds'''				)
			plt.show()


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

	testmod()





