




import numpy as np







def 		lowercase__ (		__A:						str					):





					'''simple docstring'''






					__magic_name__				,     __magic_name__				:						Optional[Any]     				=				a.shape
					__magic_name__				:						Dict     				=				min(__A				,__A					)
					__magic_name__				:						List[Any]     				=				np.eye(__A					)
					__magic_name__				:						Any     				=				a.copy()

					for k in range(t - 1					):
										# select a column of modified matrix A':
										__magic_name__				:						List[Any]     				=				r[k:, [k]]
										# construct first basis vector
										__magic_name__				:						Optional[Any]     				=				np.zeros_like(__A					)
										__magic_name__				:						Union[str, Any]     				=				1.0
										# determine scaling factor
										__magic_name__				:						Any     				=				np.linalg.norm(__A					)
										# construct vector v for Householder reflection
										__magic_name__				:						Optional[Any]     				=				x + np.sign(x[0]					) * alpha * ea
										v /= np.linalg.norm(__A					)

										# construct the Householder matrix
										__magic_name__				:						Dict     				=				np.eye(m - k					) - 2.0 * v @ v.T
										# pad with ones and zeros as necessary
										__magic_name__				:						Dict     				=				np.block([[np.eye(__A					), np.zeros((k, m - k)					)], [np.zeros((m - k, k)					), q_k]]					)

										__magic_name__				:						Optional[int]     				=				q @ q_k.T
										__magic_name__				:						str     				=				q_k @ r

					return q, r


if __name__ == "__main__":
	import doctest

	doctest.testmod()









def        lowerCamelCase_     (     SCREAMING_SNAKE_CASE ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE     =       len(SCREAMING_SNAKE_CASE )
			SCREAMING_SNAKE_CASE     =       [0] * length
			SCREAMING_SNAKE_CASE     =       [[False for i in range(SCREAMING_SNAKE_CASE )] for j in range(SCREAMING_SNAKE_CASE )]
			for i, c in enumerate(SCREAMING_SNAKE_CASE ):
						SCREAMING_SNAKE_CASE     =       i
						for j in range(i + 1 ):
									if c == string[j] and (i - j < 2 or is_palindromic[j + 1][i - 1]):
												SCREAMING_SNAKE_CASE     =       True
												SCREAMING_SNAKE_CASE     =       min(SCREAMING_SNAKE_CASE       ,						0 if j == 0 else (cut[j - 1] + 1) )
						SCREAMING_SNAKE_CASE     =       mincut
			return cut[length - 1]


if __name__ == "__main__":
		__A    :				Optional[int]    						=	input("""Enter the string: """).strip()
		__A    :				List[Any]    						=	find_minimum_partitions(s)
		print(f'''Minimum number of partitions required for the \'{s}\' is {ans}''')






