
"""simple docstring"""


def      lowerCAmelCase_     (	snake_case_	:    Any    )     ->str:

			'''simple docstring'''





			if len(lowercase__    ) == 0 or not all(len(lowercase__    ) == 2 for pair in coordinates    ):
						raise ValueError('The program cannot work out a fitting polynomial.'    )

			if len({tuple(lowercase__    ) for pair in coordinates}    ) != len(lowercase__    ):
						raise ValueError('The program cannot work out a fitting polynomial.'    )

			lowerCamelCase__			:  List[Any]  ={x for x, _ in coordinates}
			if len(lowercase__    ) == 1:
						return f"""x={coordinates[0][0]}"""

			if len(lowercase__    ) != len(lowercase__    ):
						raise ValueError('The program cannot work out a fitting polynomial.'    )

			lowerCamelCase__			:  Union[str, Any]  =len(lowercase__    )

			lowerCamelCase__			:  Optional[Any]  =0
			lowerCamelCase__			:  Union[str, Any]  =[]
			# put the x and x to the power values in a matrix
			while count_of_line < x:
						lowerCamelCase__			:  List[Any]  =0
						lowerCamelCase__			:  Optional[Any]  =coordinates[count_of_line][0]
						lowerCamelCase__			:  str  =[]
						while count_in_line < x:
									count_line.append(a ** (x - (count_in_line + 1))    )
									count_in_line += 1
						matrix.append(lowercase__    )
						count_of_line += 1

			lowerCamelCase__			:  Union[str, Any]  =0
			# put the y values into a vector
			lowerCamelCase__			:  Dict  =[]
			while count_of_line < x:
						vector.append(coordinates[count_of_line][1]    )
						count_of_line += 1

			lowerCamelCase__			:  Any  =0

			while count < x:
						lowerCamelCase__			:  Tuple  =0
						while zahlen < x:
									if count == zahlen:
												zahlen += 1
									if zahlen == x:
												break
									lowerCamelCase__			:  Optional[int]  =matrix[zahlen][count] / matrix[count][count]
									for counting_columns, item in enumerate(matrix[count]    ):
												# manipulating all the values in the matrix
												matrix[zahlen][counting_columns] -= item * bruch
									# manipulating the values in the vector
									vector[zahlen] -= vector[count] * bruch
									zahlen += 1
						count += 1

			lowerCamelCase__			:  Optional[Any]  =0
			# make solutions
			lowerCamelCase__			:  Dict  =[]
			while count < x:
						solution.append(str(vector[count] / matrix[count][count]    )    )
						count += 1

			lowerCamelCase__			:  Any  =0
			lowerCamelCase__			:  List[Any]  ='f(x)='

			while count < x:
						lowerCamelCase__			:  Union[str, Any]  =solution[count].split('E'    )
						if len(lowercase__    ) > 1:
									lowerCamelCase__			:  Any  =f"""{remove_e[0]}*10^{remove_e[1]}"""
						solved += f"""x^{x - (count + 1)}*{solution[count]}"""
						if count + 1 != x:
									solved += "+"
						count += 1

			return solved


if __name__ == "__main__":
							print(points_to_polynomial([]))
							print(points_to_polynomial([[]]))
							print(points_to_polynomial([[1, 0], [2, 0], [3, 0]]))
							print(points_to_polynomial([[1, 1], [2, 1], [3, 1]]))
							print(points_to_polynomial([[1, 3], [2, 3], [3, 3]]))
							print(points_to_polynomial([[1, 1], [2, 2], [3, 3]]))
							print(points_to_polynomial([[1, 1], [2, 4], [3, 9]]))
							print(points_to_polynomial([[1, 3], [2, 6], [3, 11]]))
							print(points_to_polynomial([[1, -3], [2, -6], [3, -11]]))
							print(points_to_polynomial([[1, 5], [2, 2], [3, 9]]))

"""simple docstring"""


def      lowerCAmelCase_     (	snake_case_	:    str    )     ->int:
			lowerCamelCase__			:  Optional[Any]  =len(snake_case_    )
			lowerCamelCase__			:  Any  =[0] * length
			lowerCamelCase__			:  str  =[[False for i in range(snake_case_    )] for j in range(snake_case_    )]
			for i, c in enumerate(snake_case_    ):
						lowerCamelCase__			:  Optional[Any]  =i
						for j in range(i + 1    ):
									if c == string[j] and (i - j < 2 or is_palindromic[j + 1][i - 1]):
												lowerCamelCase__			:  int  =True
												lowerCamelCase__			:  Tuple  =min(snake_case_							,					0 if j == 0 else (cut[j - 1] + 1)    )
						lowerCamelCase__			:  Any  =mincut
			return cut[length - 1]


if __name__ == "__main__":
							lowerCAmelCase			=		input("""Enter the string: """).strip()
							lowerCAmelCase			=		find_minimum_partitions(s)
							print(f"""Minimum number of partitions required for the '{s}' is {ans}""")