
"""simple docstring"""





from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar

_a		       =							TypeVar('KEY')
_a		       =							TypeVar('VAL')


@dataclass(frozen=lowercase__				,slots=lowercase__      )
class A_	(Generic[KEY, VAL]      ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__			:						KEY
  SCREAMING_SNAKE_CASE__			:						VAL




class A_	(_Item      ):




  '''simple docstring'''







  def __init__(		self  ):

     """simple docstring"""
     super().__init__(lowercase_				,   lowercase_  )







  def __bool__(		self  ):

     """simple docstring"""
     return False




_a		       =							_DeletedItem()


class A_	(MutableMapping[KEY, VAL]      ):




  '''simple docstring'''







  def __init__(		self				,   lowercase_ = 8				,   lowercase_ = 0.75  ):

     """simple docstring"""
     UpperCAmelCase_					:					Tuple			     =    initial_block_size
     UpperCAmelCase_					:					list[_Item | None]			     =    [None] * initial_block_size
     assert 0.0 < capacity_factor < 1.0
     UpperCAmelCase_					:					Optional[Any]			     =    capacity_factor
     UpperCAmelCase_					:					int			     =    0







  def        UpperCamelCase__					(		self				,   lowercase_  ):

     """simple docstring"""
     return hash(lowercase_  ) % len(self._buckets  )







  def        UpperCamelCase__					(		self				,   lowercase_  ):

     """simple docstring"""
     return (ind + 1) % len(self._buckets  )







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					str			     =    self._buckets[ind]
     if not stored:
        UpperCAmelCase_					:					List[Any]			     =    _Item(lowercase_				,   lowercase_  )
        self._len += 1
        return True
     elif stored.key == key:
        UpperCAmelCase_					:					Tuple			     =    _Item(lowercase_				,   lowercase_  )
        return True
     else:
        return False







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Tuple			     =    len(self._buckets  ) * self._capacity_factor
     return len(self  ) >= int(lowercase_  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     if len(self._buckets  ) <= self._initial_block_size:
        return False
     UpperCAmelCase_					:					List[str]			     =    len(self._buckets  ) * self._capacity_factor / 2
     return len(self  ) < limit







  def        UpperCamelCase__					(		self				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[Any]			     =    self._buckets
     UpperCAmelCase_					:					Any			     =    [None] * new_size
     UpperCAmelCase_					:					Any			     =    0
     for item in old_buckets:
        if item:
           self._add_item(item.key				,   item.val  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     self._resize(len(self._buckets  ) * 2  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     self._resize(len(self._buckets  ) // 2  )







  def        UpperCamelCase__					(		self				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					str			     =    self._get_bucket_index(lowercase_  )
     for _ in range(len(self._buckets  )  ):
        yield ind
        UpperCAmelCase_					:					Tuple			     =    self._get_next_ind(lowercase_  )







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     for ind in self._iterate_buckets(lowercase_  ):
        if self._try_set(lowercase_				,   lowercase_				,   lowercase_  ):
           break







  def __setitem__(		self				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     if self._is_full():
        self._size_up()

     self._add_item(lowercase_				,   lowercase_  )







  def __delitem__(		self				,   lowercase_  ):

     """simple docstring"""
     for ind in self._iterate_buckets(lowercase_  ):
        UpperCAmelCase_					:					Optional[Any]			     =    self._buckets[ind]
        if item is None:
           raise KeyError(lowercase_  )
        if item is _deleted:
           continue
        if item.key == key:
           UpperCAmelCase_					:					Optional[Any]			     =    _deleted
           self._len -= 1
           break
     if self._is_sparse():
        self._size_down()







  def __getitem__(		self				,   lowercase_  ):

     """simple docstring"""
     for ind in self._iterate_buckets(lowercase_  ):
        UpperCAmelCase_					:					Dict			     =    self._buckets[ind]
        if item is None:
           break
        if item is _deleted:
           continue
        if item.key == key:
           return item.val
     raise KeyError(lowercase_  )







  def __len__(		self  ):

     """simple docstring"""
     return self._len







  def __iter__(		self  ):

     """simple docstring"""
     yield from (item.key for item in self._buckets if item)







  def __repr__(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    " ,".join(
         F"""{item.key}: {item.val}""" for item in self._buckets if item  )
     return F"""HashMap({val_string})"""




"""simple docstring"""





def 	__a     (		__lowerCamelCase  ):
   UpperCAmelCase_					:					List[str]			     =    int(__lowerCamelCase  )
   if n_element < 1:
      UpperCAmelCase_					:					List[Any]			     =    ValueError("a should be a positive number"  )
      raise my_error

   UpperCAmelCase_					:					List[Any]			     =    [1]
   UpperCAmelCase_     ,   UpperCAmelCase_     ,   UpperCAmelCase_					:					Optional[int]			     =    (0, 0, 0)
   UpperCAmelCase_					:					Dict			     =    1
   while index < n_element:
      while hamming_list[i] * 2 <= hamming_list[-1]:
         i += 1
      while hamming_list[j] * 3 <= hamming_list[-1]:
         j += 1
      while hamming_list[k] * 5 <= hamming_list[-1]:
         k += 1
      hamming_list.append(
          min(hamming_list[i] * 2,		hamming_list[j] * 3,		hamming_list[k] * 5  )  )
      index += 1
   return hamming_list


if __name__ == "__main__":
    _a		       =							input('Enter the last number (nth term) of the Hamming Number Series: ')
    print('Formula of Hamming Number Series => 2^i * 3^j * 5^k')
    _a		       =							hamming(int(n))
    print('-----------------------------------------------------')
    print(f"""The list with nth numbers is: {hamming_numbers}""")
    print('-----------------------------------------------------')


