






'''simple docstring'''







import re
import string

import numpy as np

import datasets


_A	:			Union[str, Any]         ='''
Returns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.
'''

_A	:			Union[str, Any]         ='''
Args:
    predictions: List of predicted texts.
    references: List of reference texts.
    regexes_to_ignore: List, defaults to None. Regex expressions of characters to
        ignore when calculating the exact matches. Note: these regexes are removed
        from the input data before the changes based on the options below (e.g. ignore_case,
        ignore_punctuation, ignore_numbers) are applied.
    ignore_case: Boolean, defaults to False. If true, turns everything
        to lowercase so that capitalization differences are ignored.
    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
Returns:
    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.
Examples:
    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    25.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    50.0


    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    75.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
    >>> print(round(results["exact_match"], 1))
    100.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]
    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    33.3

'''

_A	:			Dict         ='''
'''

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




							def 		lowerCamelCase_				(							self:				List[str]     ):
														return datasets.MetricInfo(
														    description=_DESCRIPTION			,							citation=_CITATION			,							inputs_description=_KWARGS_DESCRIPTION			,							features=datasets.Features(
														        {
														            """predictions""": datasets.Value("""string"""			,							id="""sequence"""     ),
														            """references""": datasets.Value("""string"""			,							id="""sequence"""     ),
														        }     )			,							reference_urls=[]			,							)




							def 		lowerCamelCase_				(							self:				str			,							UpperCamelCase__:				List[Any]			,							UpperCamelCase__:				int			,							UpperCamelCase__:				Any=None			,							UpperCamelCase__:				Any=False			,							UpperCamelCase__:				Optional[Any]=False			,							UpperCamelCase__:				List[Any]=False			,							):
														if regexes_to_ignore is not None:
																					for s in regexes_to_ignore:
																												lowerCamelCase__					:	Dict         =       np.array([re.sub(UpperCamelCase__			,							""""""			,							UpperCamelCase__     ) for x in predictions]     )
																												lowerCamelCase__					:	Union[str, Any]         =       np.array([re.sub(UpperCamelCase__			,							""""""			,							UpperCamelCase__     ) for x in references]     )
														else:
																					lowerCamelCase__					:	int         =       np.asarray(UpperCamelCase__     )
																					lowerCamelCase__					:	Tuple         =       np.asarray(UpperCamelCase__     )

														if ignore_case:
																					lowerCamelCase__					:	Union[str, Any]         =       np.char.lower(UpperCamelCase__     )
																					lowerCamelCase__					:	Tuple         =       np.char.lower(UpperCamelCase__     )

														if ignore_punctuation:
																					lowerCamelCase__					:	Dict         =       string.punctuation.maketrans(""""""			,							""""""			,							string.punctuation     )
																					lowerCamelCase__					:	Union[str, Any]         =       np.char.translate(UpperCamelCase__			,							table=UpperCamelCase__     )
																					lowerCamelCase__					:	Any         =       np.char.translate(UpperCamelCase__			,							table=UpperCamelCase__     )

														if ignore_numbers:
																					lowerCamelCase__					:	int         =       string.digits.maketrans(""""""			,							""""""			,							string.digits     )
																					lowerCamelCase__					:	Optional[int]         =       np.char.translate(UpperCamelCase__			,							table=UpperCamelCase__     )
																					lowerCamelCase__					:	Dict         =       np.char.translate(UpperCamelCase__			,							table=UpperCamelCase__     )

														lowerCamelCase__					:	Optional[Any]         =       predictions == references

														return {"exact_match": np.mean(UpperCamelCase__     ) * 100}








from __future__ import annotations

from typing import Any


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     None:
    create_state_space_tree(_UpperCAmelCase						,	[]						,	0 )


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     None:

    if index == len(_UpperCAmelCase ):
        print(_UpperCAmelCase )
        return

    create_state_space_tree(_UpperCAmelCase						,	_UpperCAmelCase						,	index + 1 )
    current_subsequence.append(sequence[index] )
    create_state_space_tree(_UpperCAmelCase						,	_UpperCAmelCase						,	index + 1 )
    current_subsequence.pop()


if __name__ == "__main__":
    _UpperCAmelCase				:       list[Any]	   =				[3, 1, 2, 4]
    generate_all_subsequences(seq)

    seq.clear()
    seq.extend(["""A""", """B""", """C"""])
    generate_all_subsequences(seq)





