





def   __lowercase  ( _SCREAMING_SNAKE_CASE      )					->  int:


      '''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__":
      SCREAMING_SNAKE_CASE_		  =			input("""Enter the string: """).strip()
      SCREAMING_SNAKE_CASE_		  =			find_minimum_partitions(s)
      print(F'''Minimum number of partitions required for the \'{s}\' is {ans}''')









import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput

@dataclass
class 						UpperCamelCase__					( lowerCAmelCase_  ):



     '''simple docstring'''

     __snake_case       :      float
     __snake_case       :      Optional[float]						      =     None
     __snake_case       :      Optional[float]						      =     None

class 						UpperCamelCase__					( unittest.TestCase  ):



     '''simple docstring'''

     def 							SCREAMING_SNAKE_CASE__    (				self		:       Any			)	->						Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30			)
           self.assertEqual(x.a		,30			)
           self.assertIsNone(x.b			)
           self.assertIsNone(x.c			)
           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x.d






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[Any]			)	->						Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,b=10			)
           self.assertEqual(x[0]		,30			)
           self.assertEqual(x[1]		,10			)
           self.assertEqual(x[:2]		,(30, 10)			)
           self.assertEqual(x[:]		,(30, 10)			)

           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,c=10			)
           self.assertEqual(x[0]		,30			)
           self.assertEqual(x[1]		,10			)
           self.assertEqual(x[:2]		,(30, 10)			)
           self.assertEqual(x[:]		,(30, 10)			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       str			)	->						Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,b=10			)
           self.assertEqual(x["""a"""]		,30			)
           self.assertEqual(x["""b"""]		,10			)
           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x["""c"""]

           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,c=10			)
           self.assertEqual(x["""a"""]		,30			)
           self.assertEqual(x["""c"""]		,10			)
           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x["""b"""]






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[Any]			)	->						Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30			)
           self.assertEqual(list(x.keys()			)		,["""a"""]			)
           self.assertEqual(list(x.values()			)		,[30]			)
           self.assertEqual(list(x.items()			)		,[("""a""", 30)]			)
           self.assertEqual(list(lowerCamelCase__			)		,["""a"""]			)

           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,b=10			)
           self.assertEqual(list(x.keys()			)		,["""a""", """b"""]			)
           self.assertEqual(list(x.values()			)		,[30, 10]			)
           self.assertEqual(list(x.items()			)		,[("""a""", 30), ("""b""", 10)]			)
           self.assertEqual(list(lowerCamelCase__			)		,["""a""", """b"""]			)

           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,c=10			)
           self.assertEqual(list(x.keys()			)		,["""a""", """c"""]			)
           self.assertEqual(list(x.values()			)		,[30, 10]			)
           self.assertEqual(list(x.items()			)		,[("""a""", 30), ("""c""", 10)]			)
           self.assertEqual(list(lowerCamelCase__			)		,["""a""", """c"""]			)

           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x.update({"""d""": 20}			)
           with self.assertRaises(lowerCamelCase__			):
                 del x["a"]
           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x.pop("""a"""			)
           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x.setdefault("""d"""		,32			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       int			)	->						List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30			)
           SCREAMING_SNAKE_CASE						=		10
           self.assertEqual(x.a		,10			)
           self.assertEqual(x["""a"""]		,10			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[str]			)	->						Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30			)
           SCREAMING_SNAKE_CASE						=		10
           self.assertEqual(x.a		,10			)
           self.assertEqual(x["""a"""]		,10			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[Any]			)	->						Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest({"""a""": 30, """b""": 10}			)
           self.assertEqual(list(x.keys()			)		,["""a""", """b"""]			)
           self.assertEqual(x.a		,30			)
           self.assertEqual(x.b		,10			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[int]			)	->						Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest([("""a""", 30), ("""b""", 10)]			)
           self.assertEqual(list(x.keys()			)		,["""a""", """b"""]			)
           self.assertEqual(x.a		,30			)
           self.assertEqual(x.b		,10			)

           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		ModelOutputTest([("""a""", 30), (10, 10)]			)

           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=(30, 30)			)
           self.assertEqual(list(x.keys()			)		,["""a"""]			)
           self.assertEqual(x.a		,(30, 30)			)


