



import re
import string

import numpy as np

import datasets


_lowercase     							=						'''
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.
'''

_lowercase     							=						'''
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

'''

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





			def        _snake_case    (self				):
						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        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__=None							,    __magic_name__=False							,    __magic_name__=False							,    __magic_name__=False							,    ):
						if regexes_to_ignore is not None:
									for s in regexes_to_ignore:
												lowerCamelCase__ :      int								=		np.array([re.sub(__magic_name__							,    """"""							,    __magic_name__				) for x in predictions]				)
												lowerCamelCase__ :      Optional[int]								=		np.array([re.sub(__magic_name__							,    """"""							,    __magic_name__				) for x in references]				)
						else:
									lowerCamelCase__ :      str								=		np.asarray(__magic_name__				)
									lowerCamelCase__ :      List[str]								=		np.asarray(__magic_name__				)

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

						if ignore_punctuation:
									lowerCamelCase__ :      Any								=		string.punctuation.maketrans(""""""							,    """"""							,    string.punctuation				)
									lowerCamelCase__ :      int								=		np.char.translate(__magic_name__							,    table=__magic_name__				)
									lowerCamelCase__ :      str								=		np.char.translate(__magic_name__							,    table=__magic_name__				)

						if ignore_numbers:
									lowerCamelCase__ :      Tuple								=		string.digits.maketrans(""""""							,    """"""							,    string.digits				)
									lowerCamelCase__ :      int								=		np.char.translate(__magic_name__							,    table=__magic_name__				)
									lowerCamelCase__ :      List[Any]								=		np.char.translate(__magic_name__							,    table=__magic_name__				)

						lowerCamelCase__ :      Dict								=		predictions == references

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








from __future__ import annotations

import string
from itertools import cycle, product
from pathlib import Path

_lowercase     							=						(
    string.ascii_letters + string.digits + string.punctuation + string.whitespace
)
_lowercase     							=						[ord(letter) for letter in string.ascii_lowercase]
_lowercase     							=						{ord(char) for char in VALID_CHARS}

_lowercase     							=						["the", "be", "to", "of", "and", "in", "that", "have"]






def      _A				(UpperCamelCase		:      list[int]      ,			UpperCamelCase		:      tuple[int, ...] )  ->str | None:



			'''simple docstring'''







			lowerCamelCase__ :      str								=		""
			lowerCamelCase__ :      int
			lowerCamelCase__ :      int
			lowerCamelCase__ :      int

			for keychar, cipherchar in zip(cycle(UpperCamelCase )      ,			UpperCamelCase ):
						lowerCamelCase__ :      str								=		cipherchar ^ keychar
						if decodedchar not in VALID_INTS:
									return None
						decoded += chr(UpperCamelCase )

			return decoded






def      _A				(UpperCamelCase		:      list[int] )  ->list[str]:



			'''simple docstring'''







			lowerCamelCase__ :      list[str]								=		[]
			for key in product(UpperCamelCase      ,			repeat=3 ):
						lowerCamelCase__ :      Union[str, Any]								=		try_key(UpperCamelCase      ,			UpperCamelCase )
						if encoded is not None:
									possibles.append(UpperCamelCase )
			return possibles






def      _A				(UpperCamelCase		:      list[str]      ,			UpperCamelCase		:      str )  ->list[str]:



			'''simple docstring'''







			return [possible for possible in possibles if common_word in possible.lower()]






def      _A				(UpperCamelCase		:      str = "p059_cipher.txt" )  ->int:



			'''simple docstring'''







			lowerCamelCase__ :      list[int]
			lowerCamelCase__ :      list[str]
			lowerCamelCase__ :      str
			lowerCamelCase__ :      str
			lowerCamelCase__ :      str								=		Path(UpperCamelCase ).parent.joinpath(UpperCamelCase ).read_text(encoding="""utf-8""" )

			lowerCamelCase__ :      str								=		[int(UpperCamelCase ) for number in data.strip().split(""",""" )]

			lowerCamelCase__ :      Optional[Any]								=		filter_valid_chars(UpperCamelCase )
			for common_word in COMMON_WORDS:
						lowerCamelCase__ :      Optional[int]								=		filter_common_word(UpperCamelCase      ,			UpperCamelCase )
						if len(UpperCamelCase ) == 1:
									break

			lowerCamelCase__ :      Union[str, Any]								=		possibles[0]
			return sum(ord(UpperCamelCase ) for char in decoded_text )


if __name__ == "__main__":
				print(F'''{solution() = }''')



