

from math import factorial

lowerCAmelCase__	   = {str(digit): factorial(digit) for digit in range(1_0)}



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							int      )			->      int:




				'''simple docstring'''





				if not isinstance(SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_      ):
								raise TypeError("Parameter number must be int"      )

				if number < 0:
								raise ValueError("Parameter number must be greater than or equal to 0"      )

				# Converts number in string to iterate on its digits and adds its factorial.
				return sum(DIGIT_FACTORIAL[digit] for digit in str(SCREAMING_SNAKE_CASE_      )      )



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							int = 6_0	,       SCREAMING_SNAKE_CASE_:							int = 1_0_0_0_0_0_0      )			->      int:




				'''simple docstring'''





				if not isinstance(SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_      ) or not isinstance(SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_      ):
								raise TypeError("Parameters chain_length and number_limit must be int"      )

				if chain_length <= 0 or number_limit <= 0:
								raise ValueError(
								    "Parameters chain_length and number_limit must be greater than 0"      )

				# the counter for the chains with the exact desired length
				A__        =			0
				# the cached sizes of the previous chains
				A__        =			{}

				for start_chain_element in range(1	,       SCREAMING_SNAKE_CASE_      ):
								# The temporary set will contain the elements of the chain
								A__        =			set()
								A__        =			0

								# Stop computing the chain when you find a cached size, a repeating item or the
								# length is greater then the desired one.
								A__        =			start_chain_element
								while (
								    chain_element not in chain_sets_lengths
								    and chain_element not in chain_set
								    and chain_set_length <= chain_length
								):
												chain_set.add(SCREAMING_SNAKE_CASE_      )
												chain_set_length += 1
												A__        =			digit_factorial_sum(SCREAMING_SNAKE_CASE_      )

								if chain_element in chain_sets_lengths:
												chain_set_length += chain_sets_lengths[chain_element]

								A__        =			chain_set_length

								# If chain contains the exact amount of elements increase the counter
								if chain_set_length == chain_length:
												chains_counter += 1

				return chains_counter


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	print(f"""{solution()}""")




import datasets

from .evaluate import evaluate


lowerCAmelCase__	   = """\
@inproceedings{Rajpurkar2016SQuAD10,
  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},
  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},
  booktitle={EMNLP},
  year={2016}
}
"""

lowerCAmelCase__	   = """
This metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).

Stanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by
crowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,
from the corresponding reading passage, or the question might be unanswerable.
"""

lowerCAmelCase__	   = """
Computes SQuAD scores (F1 and EM).
Args:
    predictions: List of question-answers dictionaries with the following key-values:
        - 'id': id of the question-answer pair as given in the references (see below)
        - 'prediction_text': the text of the answer
    references: List of question-answers dictionaries with the following key-values:
        - 'id': id of the question-answer pair (see above),
        - 'answers': a Dict in the SQuAD dataset format
            {
                'text': list of possible texts for the answer, as a list of strings
                'answer_start': list of start positions for the answer, as a list of ints
            }
            Note that answer_start values are not taken into account to compute the metric.
Returns:
    'exact_match': Exact match (the normalized answer exactly match the gold answer)
    'f1': The F-score of predicted tokens versus the gold answer
Examples:

    >>> predictions = [{'prediction_text': '1976', 'id': '56e10a3be3433e1400422b22'}]
    >>> references = [{'answers': {'answer_start': [97], 'text': ['1976']}, 'id': '56e10a3be3433e1400422b22'}]
    >>> squad_metric = datasets.load_metric(\"squad\")
    >>> results = squad_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'exact_match': 100.0, 'f1': 100.0}
"""

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,	_KWARGS_DESCRIPTION			)
class 					a__						(					datasets.Metric			):
			"""simple docstring"""







			def      UpperCamelCase		(    self       )  ->						Union[str, Any]:
							'''simple docstring'''






							return datasets.MetricInfo(
							    description=_DESCRIPTION      ,      citation=_CITATION      ,      inputs_description=_KWARGS_DESCRIPTION      ,      features=datasets.Features(
							        {
							            "predictions": {"id": datasets.Value("string"       ), "prediction_text": datasets.Value("string"       )},
							            "references": {
							                "id": datasets.Value("string"       ),
							                "answers": datasets.features.Sequence(
							                    {
							                        "text": datasets.Value("string"       ),
							                        "answer_start": datasets.Value("int32"       ),
							                    }       ),
							            },
							        }       )      ,      codebase_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]      ,      reference_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]      ,      )


			def      UpperCamelCase		(    self      ,      lowercase      ,      lowercase       )  ->						Union[str, Any]:
							'''simple docstring'''






							A__        =			{prediction["id"]: prediction["prediction_text"] for prediction in predictions}
							A__        =			[
							    {
							        "paragraphs": [
							            {
							                "qas": [
							                    {
							                        "answers": [{"text": answer_text} for answer_text in ref["answers"]["text"]],
							                        "id": ref["id"],
							                    }
							                    for ref in references
							                ]
							            }
							        ]
							    }
							]
							A__        =			evaluate(dataset=lowercase      ,      predictions=lowercase       )
							return score

