






from string import ascii_uppercase







def 						a_      (__A							,					__A							,					__A = False							,					__A = ascii_uppercase			)							->	str:



					"""simple docstring"""
					__a				:	List[Any]			=				keyword.upper()
					__a				:	Dict			=				plaintext.upper()
					__a				:	Optional[Any]			=				set(__A			)

					# create a list of unique characters in the keyword - their order matters
					# it determines how we will map plaintext characters to the ciphertext
					__a				:	Optional[int]			=				[]
					for char in keyword:
										if char in alphabet_set and char not in unique_chars:
															unique_chars.append(__A			)
    # the number of those unique characters will determine the number of rows
					__a				:	Any			=				len(__A			)

					# create a shifted version of the alphabet
					__a				:	Union[str, Any]			=				unique_chars + [
					    char for char in alphabet if char not in unique_chars
					]

					# create a modified alphabet by splitting the shifted alphabet into rows
					__a				:	List[Any]			=				[
					    shifted_alphabet[k : k + num_unique_chars_in_keyword]
					    for k in range(0							,					26							,					__A			)
					]

					# map the alphabet characters to the modified alphabet characters
					# going 'vertically' through the modified alphabet - consider columns first
					__a				:	Optional[Any]			=				{}
					__a				:	Dict			=				0
					for column in range(__A			):
										for row in modified_alphabet:
															# if current row (the last one) is too short, break out of loop
															if len(__A			) <= column:
																				break

															# map current letter to letter in modified alphabet
															__a				:	int			=				row[column]
															letter_index += 1

					if verbose:
										print(__A			)
					# create the encrypted text by mapping the plaintext to the modified alphabet
					return "".join(mapping[char] if char in mapping else char for char in plaintext			)


if __name__ == "__main__":
			# example use
			print(mixed_keyword('''college''', '''UNIVERSITY'''))













import argparse
import json
import re
import string
import sys
from collections import Counter







def 						a_      (__A			)							->	Optional[Any]:



					"""simple docstring"""

					def remove_articles(__A			):
										return re.sub(r"\b(a|an|the)\b"							,					" "							,					__A			)

					def white_space_fix(__A			):
										return " ".join(text.split()			)

					def remove_punc(__A			):
										__a				:	Union[str, Any]			=				set(string.punctuation			)
										return "".join(ch for ch in text if ch not in exclude			)

					def lower(__A			):
										return text.lower()

					return white_space_fix(remove_articles(remove_punc(lower(__A			)			)			)			)







def 						a_      (__A							,					__A			)							->	Union[str, Any]:



					"""simple docstring"""
					__a				:	str			=				normalize_answer(__A			).split()
					__a				:	Dict			=				normalize_answer(__A			).split()
					__a				:	List[Any]			=				Counter(__A			) & Counter(__A			)
					__a				:	List[Any]			=				sum(common.values()			)
					if num_same == 0:
										return 0
					__a				:	Optional[Any]			=				1.0 * num_same / len(__A			)
					__a				:	int			=				1.0 * num_same / len(__A			)
					__a				:	List[str]			=				(2 * precision * recall) / (precision + recall)
					return fa







def 						a_      (__A							,					__A			)							->	Dict:



					"""simple docstring"""
					return normalize_answer(__A			) == normalize_answer(__A			)







def 						a_      (__A							,					__A							,					__A			)							->	Optional[Any]:



					"""simple docstring"""
					__a				:	str			=				[]
					for ground_truth in ground_truths:
										__a				:	Tuple			=				metric_fn(__A							,					__A			)
										scores_for_ground_truths.append(__A			)
					return max(__A			)







def 						a_      (__A							,					__A			)							->	Union[str, Any]:



					"""simple docstring"""
					__a				:	str			=				0
					for article in dataset:
										for paragraph in article["paragraphs"]:
															for qa in paragraph["qas"]:
																				total += 1
																				if qa["id"] not in predictions:
																									__a				:	str			=				"Unanswered question " + qa["id"] + " will receive score 0."
																									print(__A							,					file=sys.stderr			)
																									continue
																				__a				:	Any			=				[x["text"] for x in qa["answers"]]
																				__a				:	List[Any]			=				predictions[qa["id"]]
																				exact_match += metric_max_over_ground_truths(__A							,					__A							,					__A			)
																				fa += metric_max_over_ground_truths(__A							,					__A							,					__A			)

					__a				:	Any			=				100.0 * exact_match / total
					__a				:	List[Any]			=				100.0 * fa / total

					return {"exact_match": exact_match, "f1": fa}


if __name__ == "__main__":
			UpperCAmelCase__			 =	'''1.1'''
			UpperCAmelCase__			 =	argparse.ArgumentParser(description='''Evaluation for SQuAD ''' + expected_version)
			parser.add_argument('''dataset_file''', help='''Dataset file''')
			parser.add_argument('''prediction_file''', help='''Prediction File''')
			UpperCAmelCase__			 =	parser.parse_args()
			with open(args.dataset_file) as dataset_file:
						UpperCAmelCase__			 =	json.load(dataset_file)
						if dataset_json["version"] != expected_version:
									print(
									    '''Evaluation expects v-''' + expected_version + ''', but got dataset with v-''' + dataset_json['''version'''],
									    file=sys.stderr,
									)
						UpperCAmelCase__			 =	dataset_json['''data''']
			with open(args.prediction_file) as prediction_file:
						UpperCAmelCase__			 =	json.load(prediction_file)
			print(json.dumps(evaluate(dataset, predictions)))





