





import datasets


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

UpperCAmelCase_					:   int 							=						"""\
XNLI is a subset of a few thousand examples from MNLI which has been translated
into a 14 different languages (some low-ish resource). As with MNLI, the goal is
to predict textual entailment (does sentence A imply/contradict/neither sentence
B) and is a classification task (given two sentences, predict one of three
labels).
"""

UpperCAmelCase_					:   Tuple 							=						"""
Computes XNLI score which is just simple accuracy.
Args:
    predictions: Predicted labels.
    references: Ground truth labels.
Returns:
    'accuracy': accuracy
Examples:

    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> xnli_metric = datasets.load_metric(\"xnli\")
    >>> results = xnli_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}
"""






def 							_lowerCAmelCase (  _a   :					Union[str, Any]					,   _a   :					Optional[int]			)	->			List[str]:
     return (preds == labels).mean()







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







  def 	UpperCAmelCase__		(	self						):
       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 	UpperCAmelCase__		(	self    ,						_lowercase    ,						_lowercase						):
       return {"accuracy": simple_accuracy(_lowercase    ,						_lowercase						)}







from __future__ import annotations






def 							_lowerCAmelCase (  _a   :					list[int]			)	->			list[int]:  # This function is recursive
     lowerCAmelCase_					:       List[Any]    =		len(_a			)
     # If the array contains only one element, we return it (it's the stop condition of
     # recursion)
     if array_length <= 1:
          return array
          # Else
     lowerCAmelCase_					:       Union[str, Any]    =		array[0]
     lowerCAmelCase_					:       str    =		False
     lowerCAmelCase_					:       Optional[int]    =		1
     lowerCAmelCase_					:       list[int]    =		[]
     while not is_found and i < array_length:
          if array[i] < pivot:
               lowerCAmelCase_					:       Optional[Any]    =		True
               lowerCAmelCase_					:       Tuple    =		[element for element in array[i:] if element >= array[i]]
               lowerCAmelCase_					:       Any    =		longest_subsequence(_a			)
               if len(_a			) > len(_a			):
                    lowerCAmelCase_					:       List[Any]    =		temp_array
          else:
               i += 1

     lowerCAmelCase_					:       Tuple    =		[element for element in array[1:] if element >= pivot]
     lowerCAmelCase_					:       List[Any]    =		[pivot, *longest_subsequence(_a			)]
     if len(_a			) > len(_a			):
          return temp_array
     else:
          return longest_subseq


if __name__ == "__main__":
      import doctest

      doctest.testmod()
