


'''simple docstring'''



def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Tuple						,      _SCREAMING_SNAKE_CASE      :   List[str]						,      _SCREAMING_SNAKE_CASE      :   List[Any]						,      _SCREAMING_SNAKE_CASE      :   Tuple   ):
					global f  # a global dp table for knapsack
					if f[i][j] < 0:
										if j < wt[i - 1]:
															__a			:       List[Any]					    =  mf_knapsack(i - 1						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
										else:
															__a			:       str					    =  max(
															    mf_knapsack(i - 1						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )						,      mf_knapsack(i - 1						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      j - wt[i - 1]   ) + val[i - 1]						,      )
										__a			:       Optional[int]					    =  val
					return f[i][j]






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Any						,      _SCREAMING_SNAKE_CASE      :   List[str]						,      _SCREAMING_SNAKE_CASE      :   Any						,      _SCREAMING_SNAKE_CASE      :   List[str]   ):
					__a			:       Union[str, Any]					    =  [[0] * (w + 1) for _ in range(n + 1   )]

					for i in range(1						,      n + 1   ):
										for w_ in range(1						,      w + 1   ):
															if wt[i - 1] <= w_:
																				__a			:       str					    =  max(val[i - 1] + dp[i - 1][w_ - wt[i - 1]]						,      dp[i - 1][w_]   )
															else:
																				__a			:       List[Any]					    =  dp[i - 1][w_]

					return dp[n][w_], dp






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   list						,      _SCREAMING_SNAKE_CASE      :   list   ):
					if not (isinstance(_SCREAMING_SNAKE_CASE						,      (list, tuple)   ) and isinstance(_SCREAMING_SNAKE_CASE						,      (list, tuple)   )):
										raise ValueError(
										    'Both the weights and values vectors must be either lists or tuples'   )

					__a			:       Optional[Any]					    =  len(_SCREAMING_SNAKE_CASE   )
					if num_items != len(_SCREAMING_SNAKE_CASE   ):
										__a			:       Tuple					    =  (
										    'The number of weights must be the same as the number of values.\n'
										    F"""But got {num_items} weights and {len(_SCREAMING_SNAKE_CASE   )} values"""
										)
										raise ValueError(_SCREAMING_SNAKE_CASE   )
					for i in range(_SCREAMING_SNAKE_CASE   ):
										if not isinstance(wt[i]						,      _SCREAMING_SNAKE_CASE   ):
															__a			:       List[Any]					    =  (
															    'All weights must be integers but got weight of '
															    F"""type {type(wt[i]   )} at index {i}"""
															)
															raise TypeError(_SCREAMING_SNAKE_CASE   )

					__a    ,				__a			:       int					    =  knapsack(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
					__a			:       set					    =  set()
					_construct_solution(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )

					return optimal_val, example_optional_set






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   list						,      _SCREAMING_SNAKE_CASE      :   list						,      _SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   set   ):
					# for the current item i at a maximum weight j to be part of an optimal subset,
					# the optimal value at (i, j) must be greater than the optimal value at (i-1, j).
					# where i - 1 means considering only the previous items at the given maximum weight
					if i > 0 and j > 0:
										if dp[i - 1][j] == dp[i][j]:
															_construct_solution(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      i - 1						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
										else:
															optimal_set.add(_SCREAMING_SNAKE_CASE   )
															_construct_solution(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      i - 1						,      j - wt[i - 1]						,      _SCREAMING_SNAKE_CASE   )


if __name__ == "__main__":
	__lowercase	:						Union[str, Any]       =	[3, 2, 4, 4]
	__lowercase	:						Optional[int]       =	[4, 3, 2, 3]
	__lowercase	:						List[str]       =	4
	__lowercase	:						List[Any]       =	6
	__lowercase	:						str       =	[[0] * (w + 1)] + [[0] + [-1] * (w + 1) for _ in range(n + 1)]
	__lowercase       ,      __lowercase	:						Dict       =	knapsack(w, wt, val, n)
	print(optimal_solution)
	print(mf_knapsack(n, wt, val, w))  # switched the n and w

	# testing the dynamic programming problem with example
	# the optimal subset for the above example are items 3 and 4
	__lowercase       ,      __lowercase	:						List[Any]       =	knapsack_with_example_solution(w, wt, val)
	assert optimal_solution == 8
	assert optimal_subset == {3, 4}
	print('optimal_value = ', optimal_solution)
	print('An optimal subset corresponding to the optimal value', optimal_subset)







'''simple docstring'''



import re
import string

import numpy as np

import datasets


__lowercase	:						Tuple       =	'\nReturns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.\n'

__lowercase	:						List[str]       =	'\nArgs:\n    predictions: List of predicted texts.\n    references: List of reference texts.\n    regexes_to_ignore: List, defaults to None. Regex expressions of characters to\n        ignore when calculating the exact matches. Note: these regexes are removed\n        from the input data before the changes based on the options below (e.g. ignore_case,\n        ignore_punctuation, ignore_numbers) are applied.\n    ignore_case: Boolean, defaults to False. If true, turns everything\n        to lowercase so that capitalization differences are ignored.\n    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\n    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\nReturns:\n    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.\nExamples:\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    25.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    50.0\n\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    75.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)\n    >>> print(round(results["exact_match"], 1))\n    100.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]\n    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    33.3\n\n'

__lowercase	:						Any       =	'\n'





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




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						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       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a=None						,				__a=False						,				__a=False						,				__a=False						,				):

						'''simple docstring'''





						if regexes_to_ignore is not None:
											for s in regexes_to_ignore:
																__a			:       Tuple					    =  np.array([re.sub(__a						,				''						,				__a							) for x in predictions]							)
																__a			:       List[Any]					    =  np.array([re.sub(__a						,				''						,				__a							) for x in references]							)
						else:
											__a			:       int					    =  np.asarray(__a							)
											__a			:       str					    =  np.asarray(__a							)

						if ignore_case:
											__a			:       Dict					    =  np.char.lower(__a							)
											__a			:       List[str]					    =  np.char.lower(__a							)

						if ignore_punctuation:
											__a			:       Dict					    =  string.punctuation.maketrans(''						,				''						,				string.punctuation							)
											__a			:       Tuple					    =  np.char.translate(__a						,				table=__a							)
											__a			:       Dict					    =  np.char.translate(__a						,				table=__a							)

						if ignore_numbers:
											__a			:       Optional[int]					    =  string.digits.maketrans(''						,				''						,				string.digits							)
											__a			:       Tuple					    =  np.char.translate(__a						,				table=__a							)
											__a			:       Optional[int]					    =  np.char.translate(__a						,				table=__a							)

						__a			:       Any					    =  predictions == references

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



