


from collections import defaultdict


class 	A_ :




      '''simple docstring'''


      def __init__(    self:	Tuple						,				a:	int						,				a:	Any    ):
       __lowerCamelCase		:							str		 =						total  # total no of tasks (N)

       # DP table will have a dimension of (2^M)*N
       # initially all values are set to -1
       __lowerCamelCase		:							Any		 =						[
           [-1 for i in range(total + 1    )] for j in range(2 ** len(a    )    )
       ]

       __lowerCamelCase		:							List[str]		 =						defaultdict(a    )  # stores the list of persons for each task

       # final_mask is used to check if all persons are included by setting all bits
       # to 1
       __lowerCamelCase		:							Any		 =						(1 << len(a    )) - 1




      def 					_snake_case     (    self:	Dict						,				a:	str						,				a:	Any    ):
       # if mask == self.finalmask all persons are distributed tasks, return 1
       if mask == self.final_mask:
        return 1

       # if not everyone gets the task and no more tasks are available, return 0
       if task_no > self.total_tasks:
        return 0

       # if case already considered
       if self.dp[mask][task_no] != -1:
        return self.dp[mask][task_no]

       # Number of ways when we don't this task in the arrangement
       __lowerCamelCase		:							str		 =						self.count_ways_until(a						,				task_no + 1    )

       # now assign the tasks one by one to all possible persons and recursively
       # assign for the remaining tasks.
       if task_no in self.task:
        for p in self.task[task_no]:
         # if p is already given a task
         if mask & (1 << p):
          continue

         # assign this task to p and change the mask value. And recursively
         # assign tasks with the new mask value.
         total_ways_util += self.count_ways_until(mask | (1 << p)						,				task_no + 1    )

        # save the value.
       __lowerCamelCase		:							Union[str, Any]		 =						total_ways_util

       return self.dp[mask][task_no]




      def 					_snake_case     (    self:	Tuple						,				a:	Any    ):
       # Store the list of persons for each task
       for i in range(len(a    )    ):
        for j in task_performed[i]:
         self.task[j].append(a    )

        # call the function to fill the DP table, final answer is stored in dp[0][1]
       return self.count_ways_until(0						,				1    )


if __name__ == "__main__":
       lowercase_	   =     5  # total no of tasks (the value of N)

       # the list of tasks that can be done by M persons.
       lowercase_	   =     [[1, 3, 4], [1, 2, 5], [3, 4]]
       print(
           AssignmentUsingBitmask(task_performed, total_tasks).count_no_of_ways(
               task_performed
           )
       )





import datasets


lowercase_	   =     '\\n@InProceedings{conneau2018xnli,\n  author = "Conneau, Alexis\n                 and Rinott, Ruty\n                 and Lample, Guillaume\n                 and Williams, Adina\n                 and Bowman, Samuel R.\n                 and Schwenk, Holger\n                 and Stoyanov, Veselin",\n  title = "XNLI: Evaluating Cross-lingual Sentence Representations",\n  booktitle = "Proceedings of the 2018 Conference on Empirical Methods\n               in Natural Language Processing",\n  year = "2018",\n  publisher = "Association for Computational Linguistics",\n  location = "Brussels, Belgium",\n}\n'

lowercase_	   =     '\\nXNLI is a subset of a few thousand examples from MNLI which has been translated\ninto a 14 different languages (some low-ish resource). As with MNLI, the goal is\nto predict textual entailment (does sentence A imply/contradict/neither sentence\nB) and is a classification task (given two sentences, predict one of three\nlabels).\n'

lowercase_	   =     '\nComputes XNLI score which is just simple accuracy.\nArgs:\n    predictions: Predicted labels.\n    references: Ground truth labels.\nReturns:\n    \'accuracy\': accuracy\nExamples:\n\n    >>> predictions = [0, 1]\n    >>> references = [0, 1]\n    >>> xnli_metric = datasets.load_metric("xnli")\n    >>> results = xnli_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0}\n'
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 return (preds == labels).mean()



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION ,				_KWARGS_DESCRIPTION   )
class 	A_ (	datasets.Metric   ):




      '''simple docstring'''


      def 					_snake_case     (    self:	Union[str, Any]    ):
       return datasets.MetricInfo(
           description=_DESCRIPTION						,				citation=_CITATION						,				inputs_description=_KWARGS_DESCRIPTION						,				features=datasets.Features(
               {
                   'predictions': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32'    ),
                   'references': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32'    ),
               }    )						,				codebase_urls=[]						,				reference_urls=[]						,				format='numpy'						,				)




      def 					_snake_case     (    self:	int						,				a:	Optional[Any]						,				a:	Optional[Any]    ):
       return {"accuracy": simple_accuracy(a						,				a    )}

