


def       a_ (       SCREAMING_SNAKE_CASE__   : str						,     SCREAMING_SNAKE_CASE__   : str	):
       '''simple docstring'''





       _lowerCamelCase			:						Dict            =len(SCREAMING_SNAKE_CASE__	) + 1
       _lowerCamelCase			:						Optional[int]            =len(SCREAMING_SNAKE_CASE__	) + 1

       # dp is a 2d matrix where dp[i][j] denotes whether prefix string of
       # length i of input_string matches with prefix string of length j of
       # given pattern.
       # "dp" stands for dynamic programming.
       _lowerCamelCase			:						Optional[int]            =[[0 for i in range(SCREAMING_SNAKE_CASE__	)] for j in range(SCREAMING_SNAKE_CASE__	)]

       # since string of zero length match pattern of zero length
       _lowerCamelCase			:						List[str]            =1

       # since pattern of zero length will never match with string of non-zero length
       for i in range(1						,     SCREAMING_SNAKE_CASE__	):
              _lowerCamelCase			:						Dict            =0

       # since string of zero length will match with pattern where there
       # is at least one * alternatively
       for j in range(1						,     SCREAMING_SNAKE_CASE__	):
              _lowerCamelCase			:						Tuple            =dp[0][j - 2] if pattern[j - 1] == '*' else 0

       # now using bottom-up approach to find for all remaining lengths
       for i in range(1						,     SCREAMING_SNAKE_CASE__	):
              for j in range(1						,     SCREAMING_SNAKE_CASE__	):
                     if input_string[i - 1] == pattern[j - 1] or pattern[j - 1] == ".":
                            _lowerCamelCase			:						Union[str, Any]            =dp[i - 1][j - 1]

                     elif pattern[j - 1] == "*":
                            if dp[i][j - 2] == 1:
                                   _lowerCamelCase			:						Union[str, Any]            =1
                            elif pattern[j - 2] in (input_string[i - 1], "."):
                                   _lowerCamelCase			:						int            =dp[i - 1][j]
                            else:
                                   _lowerCamelCase			:						Tuple            =0
                     else:
                            _lowerCamelCase			:						Any            =0

       return bool(dp[-1][-1]	)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 # inputing the strings
 # input_string = input("input a string :")
 # pattern = input("input a pattern :")

 lowerCamelCase		   =			'aab'
 lowerCamelCase		   =			'c*a*b'

 # using function to check whether given string matches the given pattern
 if match_pattern(input_string, pattern):
  print(F"""{input_string} matches the given pattern {pattern}""")
 else:
  print(F"""{input_string} does not match with the given pattern {pattern}""")






from typing import Optional

from .. import Features, NamedSplit
from ..packaged_modules.text.text import Text
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader




class A    (  UpperCamelCase_	):






      def __init__(   self		:	Union[str, Any]     ,  lowercase_		:	NestedDataStructureLike[PathLike]     ,  lowercase_		:	Optional[NamedSplit] = None     ,  lowercase_		:	Optional[Features] = None     ,  lowercase_		:	str = None     ,  lowercase_		:	bool = False     ,  lowercase_		:	bool = False     ,  lowercase_		:	Optional[int] = None     ,  **lowercase_		:	Optional[int]     ,  )   ->		Union[str, Any]:
             """simple docstring"""




             super().__init__(
                 lowercase_     ,  split=lowercase_     ,  features=lowercase_     ,  cache_dir=lowercase_     ,  keep_in_memory=lowercase_     ,  streaming=lowercase_     ,  num_proc=lowercase_     ,  **lowercase_     ,  )
             _lowerCamelCase			:						Optional[int]            =path_or_paths if isinstance(lowercase_     ,  lowercase_					) else {self.split: path_or_paths}
             _lowerCamelCase			:						int            =Text(
                 cache_dir=lowercase_     ,  data_files=lowercase_     ,  features=lowercase_     ,  **lowercase_     ,  )






      def 			lowerCamelCase			(   self		:	Optional[Any]					)   ->		Dict:
             """simple docstring"""




             if self.streaming:
                    _lowerCamelCase			:						Optional[Any]            =self.builder.as_streaming_dataset(split=self.split					)
             # Build regular (map-style) dataset
             else:
                    _lowerCamelCase			:						List[str]            =None
                    _lowerCamelCase			:						int            =None
                    _lowerCamelCase			:						Optional[Any]            =None
                    _lowerCamelCase			:						Any            =None

                    self.builder.download_and_prepare(
                        download_config=lowercase_     ,  download_mode=lowercase_     ,  verification_mode=lowercase_     ,  base_path=lowercase_     ,  num_proc=self.num_proc     ,  )
                    _lowerCamelCase			:						Tuple            =self.builder.as_dataset(
                        split=self.split     ,  verification_mode=lowercase_     ,  in_memory=self.keep_in_memory					)
             return dataset


