





from collections import Counter

import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split

snake_case 				=       datasets.load_iris()

snake_case 				=       np.array(data["""data"""])
snake_case 				=       np.array(data["""target"""])
snake_case 				=       data['''target_names''']

snake_case 				=       train_test_split(X, y)

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :Tuple			,							snake_case__  :int     )      ->						Optional[Any]:
  return np.linalg.norm(np.array(lowerCAmelCase__     ) - np.array(lowerCAmelCase__     )     )

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :List[Any]			,							snake_case__  :Optional[int]			,							snake_case__  :Optional[Any]			,							snake_case__  :List[Any]			,							snake_case__  :int=5     )      ->						Tuple:
  _lowercase							= zip(lowerCAmelCase__			,							lowerCAmelCase__     )
  # List of distances of all points from the point to be classified
  _lowercase							= []
  for data_point in data:
    _lowercase							= euclidean_distance(data_point[0]			,							lowerCAmelCase__     )
    distances.append((distance, data_point[1])     )
  # Choosing 'k' points with the least distances.
  _lowercase							= [i[1] for i in sorted(lowerCAmelCase__     )[:k]]
  # Most commonly occurring class among them
  # is the class into which the point is classified
  _lowercase							= Counter(lowerCAmelCase__     ).most_common(1     )[0][0]
  return classes[result]


if __name__ == "__main__":
      print(classifier(X_train, y_train, classes, [4.4, 3.1, 1.3, 1.4]))












from __future__ import annotations

from collections.abc import Generator

def 							SCREAMING_SNAKE_CASE__       (  )      ->						Generator[int, None, None]:
  _lowercase							= {}
  _lowercase							= 2
  while True:
    _lowercase							= factor_map.pop(snake_case__			,							snake_case__     )
    if factor:
      _lowercase							= factor + prime
      while x in factor_map:
        x += factor
      _lowercase							= factor
    else:
      _lowercase							= prime
      yield prime
    prime += 1

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :float = 1E10     )      ->						int:
  _lowercase							= sieve()

  _lowercase							= 1
  while True:
    _lowercase							= next(snake_case__     )
    if (2 * prime * n) > limit:
      return n
    # Ignore the next prime as the reminder will be 2.
    next(snake_case__     )
    n += 2


if __name__ == "__main__":
      print(solution())