'''simple docstring'''

def  _lowerCAmelCase				(				__a			,      __a			,      __a			,      __a      )  ->      int:
     '''simple docstring'''







     return len_board * len_board_column * row + column



def  _lowerCAmelCase				(				__a			,      __a			,      __a			,      __a			,      __a			,      __a			,      )  ->      bool:
     '''simple docstring'''







     if board[row][column] != word[word_index]:
          return False

     if word_index == len(__a      ) - 1:
          return True

     _UpperCamelCase  :Dict       =[(0, 1), (0, -1), (-1, 0), (1, 0)]
     _UpperCamelCase  :int       =len(__a      )
     _UpperCamelCase  :int       =len(board[0]      )
     for direction in traverts_directions:
          _UpperCamelCase  :int       =row + direction[0]
          _UpperCamelCase  :Dict       =column + direction[1]
          if not (0 <= next_i < len_board and 0 <= next_j < len_board_column):
               continue

          _UpperCamelCase  :int       =get_point_key(__a			,      __a			,      __a			,      __a      )
          if key in visited_points_set:
               continue

          visited_points_set.add(__a      )
          if exits_word(__a			,      __a			,      __a			,      __a			,      word_index + 1			,      __a      ):
               return True

          visited_points_set.remove(__a      )

     return False



def  _lowerCAmelCase				(				__a			,      __a      )  ->      bool:
     '''simple docstring'''







     _UpperCamelCase  :int       =(
         """The board should be a non empty matrix of single chars strings."""
     )

     _UpperCamelCase  :Any       =len(__a      )
     if not isinstance(__a			,      __a      ) or len(__a      ) == 0:
          raise ValueError(__a      )

     for row in board:
          if not isinstance(__a			,      __a      ) or len(__a      ) == 0:
               raise ValueError(__a      )

          for item in row:
               if not isinstance(__a			,      __a      ) or len(__a      ) != 1:
                    raise ValueError(__a      )

    # Validate word
     if not isinstance(__a			,      __a      ) or len(__a      ) == 0:
          raise ValueError(
              """The word parameter should be a string of length greater than 0."""      )

     _UpperCamelCase  :Dict       =len(board[0]      )
     for i in range(__a      ):
          for j in range(__a      ):
               if exits_word(
                   __a			,      __a			,      __a			,      __a			,      0			,      {get_point_key(__a			,      __a			,      __a			,      __a      )}      ):
                    return True

     return False


if __name__ == "__main__":
      import doctest

      doctest.testmod()
def  UpperCAmelCase__(    lowerCamelCase_	):



			"""simple docstring"""





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


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

