


'''simple docstring'''






def 							UpperCamelCase_     (       A__   :  str				,       A__   :  str   ):
  '''simple docstring'''





  lowerCAmelCase_     : List[str]     =  len(A__   ) + 1
  lowerCAmelCase_     : Tuple     =  len(A__   ) + 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_     : str     =  [[0 for i in range(A__   )] for j in range(A__   )]

  # since string of zero length match pattern of zero length
  lowerCAmelCase_     : str     =  1

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

  # since string of zero length will match with pattern where there
  # is at least one * alternatively
  for j in range(1				,       A__   ):
    lowerCAmelCase_     : Dict     =  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				,       A__   ):
    for j in range(1				,       A__   ):
      if input_string[i - 1] == pattern[j - 1] or pattern[j - 1] == ".":
        lowerCAmelCase_     : Tuple     =  dp[i - 1][j - 1]

      elif pattern[j - 1] == "*":
        if dp[i][j - 2] == 1:
          lowerCAmelCase_     : List[str]     =  1
        elif pattern[j - 2] in (input_string[i - 1], "."):
          lowerCAmelCase_     : List[str]     =  dp[i - 1][j]
        else:
          lowerCAmelCase_     : int     =  0
      else:
        lowerCAmelCase_     : Tuple     =  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 :")

  __A   :    int											= "aab"
  __A   :    Optional[Any]											= "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}''')







'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__A   :    str											= {
    "configuration_roc_bert": ["ROC_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "RoCBertConfig"],
    "tokenization_roc_bert": ["RoCBertTokenizer"],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  pass

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __A   :    Optional[int]											= [
      "ROC_BERT_PRETRAINED_MODEL_ARCHIVE_LIST",
      "RoCBertForCausalLM",
      "RoCBertForMaskedLM",
      "RoCBertForMultipleChoice",
      "RoCBertForPreTraining",
      "RoCBertForQuestionAnswering",
      "RoCBertForSequenceClassification",
      "RoCBertForTokenClassification",
      "RoCBertLayer",
      "RoCBertModel",
      "RoCBertPreTrainedModel",
      "load_tf_weights_in_roc_bert",
  ]

if TYPE_CHECKING:
  from .configuration_roc_bert import ROC_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, RoCBertConfig
  from .tokenization_roc_bert import RoCBertTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    raise OptionalDependencyNotAvailable()

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_roc_bert import (
        ROC_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        RoCBertForCausalLM,
        RoCBertForMaskedLM,
        RoCBertForMultipleChoice,
        RoCBertForPreTraining,
        RoCBertForQuestionAnswering,
        RoCBertForSequenceClassification,
        RoCBertForTokenClassification,
        RoCBertLayer,
        RoCBertModel,
        RoCBertPreTrainedModel,
        load_tf_weights_in_roc_bert,
    )


else:
  import sys

  __A   :    Optional[int]											= _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



