





'''simple docstring'''





def    A				(							UpperCAmelCase = "The quick brown fox jumps over the lazy dog"  ,  ):
					_snake_case       :					str				       =   set()

					# Replace all the whitespace in our sentence
					_snake_case       :					Dict				       =   input_str.replace(" "  ,  ""				)
					for alpha in input_str:
										if "a" <= alpha.lower() <= "z":
															frequency.add(alpha.lower()				)
					return len(UpperCAmelCase				) == 26







def    A				(							UpperCAmelCase = "The quick brown fox jumps over the lazy dog"  ,  ):
					_snake_case       :					Dict				       =   [False] * 26
					for char in input_str:
										if char.islower():
															_snake_case       :					List[Any]				       =   True
										elif char.isupper():
															_snake_case       :					Optional[Any]				       =   True
					return all(UpperCAmelCase				)







def    A				(							UpperCAmelCase = "The quick brown fox jumps over the lazy dog"  ,  ):
					return len({char for char in input_str.lower() if char.isalpha()}				) == 26







def    A				(							):
					from timeit import timeit

					_snake_case       :					Dict				       =   "from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest"
					print(timeit("is_pangram()"  ,  setup=UpperCAmelCase				)				)
					print(timeit("is_pangram_faster()"  ,  setup=UpperCAmelCase				)				)
					print(timeit("is_pangram_fastest()"  ,  setup=UpperCAmelCase				)				)
					# 5.348480500048026, 2.6477354579837993, 1.8470395830227062
					# 5.036091582966037, 2.644472333951853,  1.8869528750656173


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							benchmark()






from __future__ import annotations

import typing
from collections.abc import Iterable

import numpy as np

__lowerCAmelCase :Union[str, Any]     =    typing.Union[Iterable[float], Iterable[int], np.ndarray]  # noqa: UP007
__lowerCAmelCase :Optional[Any]     =    typing.Union[np.floataa, int, float]  # noqa: UP007







def    A				(							UpperCAmelCase  ,  UpperCAmelCase				):
					return np.sqrt(np.sum((np.asarray(UpperCAmelCase				) - np.asarray(UpperCAmelCase				)) ** 2				)				)







def    A				(							UpperCAmelCase  ,  UpperCAmelCase				):
					return sum((va - va) ** 2 for va, va in zip(UpperCAmelCase  ,  UpperCAmelCase				)				) ** (1 / 2)


if __name__ == "__main__":







							def    A				(							):
												from timeit import timeit

												print("Without Numpy"				)
												print(
												    timeit(
												        "euclidean_distance_no_np([1, 2, 3], [4, 5, 6])"  ,  number=10_000  ,  globals=globals()  ,  )				)
												print("With Numpy"				)
												print(
												    timeit(
												        "euclidean_distance([1, 2, 3], [4, 5, 6])"  ,  number=10_000  ,  globals=globals()  ,  )				)

							benchmark()