import datasets


__lowercase							 =					'''\
@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",
}
'''

__lowercase							 =					'''\
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).
'''

__lowercase							 =					'''
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  (   SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE	):
    '''simple docstring'''







    return (preds == labels).mean()


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






    '''simple docstring'''






    def 			UpperCamelCase__   (	self)       ->	Optional[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 			UpperCamelCase__   (	self , __lowercase , __lowercase)       ->	Optional[Any]:
        return {"accuracy": simple_accuracy(__lowercase , __lowercase)}






def lowerCamelCase  (   SCREAMING_SNAKE_CASE	):
    '''simple docstring'''







    __UpperCamelCase     :Tuple			  =		[0 for i in range(len(SCREAMING_SNAKE_CASE	)	)]

    # initialize interval's left pointer and right pointer
    __UpperCamelCase  ,       __UpperCamelCase     :str			  =		0, 0

    for i in range(1  ,			len(SCREAMING_SNAKE_CASE	)	):
        # case when current index is inside the interval
        if i <= right_pointer:
            __UpperCamelCase     :Union[str, Any]			  =		min(right_pointer - i + 1  ,			z_result[i - left_pointer]	)
            __UpperCamelCase     :Tuple			  =		min_edge

        while go_next(SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE	):
            z_result[i] += 1

        # if new index's result gives us more right interval,
        # we've to update left_pointer and right_pointer
        if i + z_result[i] - 1 > right_pointer:
            __UpperCamelCase  ,       __UpperCamelCase     :Union[str, Any]			  =		i, i + z_result[i] - 1

    return z_result



def lowerCamelCase  (   SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE	):
    '''simple docstring'''







    return i + z_result[i] < len(SCREAMING_SNAKE_CASE	) and s[z_result[i]] == s[i + z_result[i]]



def lowerCamelCase  (   SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE	):
    '''simple docstring'''







    __UpperCamelCase     :List[Any]			  =		0
    # concatenate 'pattern' and 'input_str' and call z_function
    # with concatenated string
    __UpperCamelCase     :Tuple			  =		z_function(pattern + input_str	)

    for val in z_result:
        # if value is greater then length of the pattern string
        # that means this index is starting position of substring
        # which is equal to pattern string
        if val >= len(SCREAMING_SNAKE_CASE	):
            answer += 1

    return answer


if __name__ == "__main__":
    import doctest

    doctest.testmod()





