# Algorithm for the pigeonhole sorting





def lowerCamelCase  (   SCREAMING_SNAKE_CASE	):
    '''simple docstring'''







    __UpperCamelCase     :Optional[Any]			  =		min(SCREAMING_SNAKE_CASE	)  # min() finds the minimum value
    __UpperCamelCase     :List[Any]			  =		max(SCREAMING_SNAKE_CASE	)  # max() finds the maximum value

    __UpperCamelCase     :List[Any]			  =		max_val - min_val + 1  # size is difference of max and min values plus one

    # list of pigeonholes of size equal to the variable size
    __UpperCamelCase     :List[Any]			  =		[0] * size

    # Populate the pigeonholes.
    for x in a:
        assert isinstance(SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE	), "integers only please"
        holes[x - min_val] += 1

    # Putting the elements back into the array in an order.
    __UpperCamelCase     :Optional[Any]			  =		0
    for count in range(SCREAMING_SNAKE_CASE	):
        while holes[count] > 0:
            holes[count] -= 1
            __UpperCamelCase     :int			  =		count + min_val
            i += 1



def lowerCamelCase  (   ):
    '''simple docstring'''







    __UpperCamelCase     :Optional[Any]			  =		[8, 3, 2, 7, 4, 6, 8]
    pigeonhole_sort(SCREAMING_SNAKE_CASE	)
    print('''Sorted order is:'''  ,			''' '''.join(SCREAMING_SNAKE_CASE	)	)


if __name__ == "__main__":
    main()







'''simple docstring'''







from __future__ import annotations

from collections.abc import Iterator
from typing import Generic, TypeVar

__lowerCAmelCase         =    TypeVar("""T""")







class UpperCAmelCase__	( Generic[T]	):





  """simple docstring"""

  def __init__(		self      :     Tuple							,_a      :     T       ):


     '''simple docstring'''






     _a				:	List[str]			=   data
     _a				:	Node[T] | None			=   None


  def __str__(		self      :     Dict       ):


     '''simple docstring'''






     return F"""{self.data}"""







class UpperCAmelCase__	( Generic[T]	):





  """simple docstring"""

  def __init__(		self      :     Optional[int]       ):


     '''simple docstring'''






     _a				:	Node[T] | None			=   None


  def __iter__(		self      :     str       ):


     '''simple docstring'''






     _a				:	Tuple			=   self.top
     while node:
        yield node.data
        _a				:	int			=   node.next


  def __str__(		self      :     str       ):


     '''simple docstring'''






     return "->".join([str(_a       ) for item in self]       )


  def __len__(		self      :     Optional[Any]       ):


     '''simple docstring'''






     return len(tuple(iter(self       )       )       )


  def   __lowercase		(		self      :     str       ):


     '''simple docstring'''






     return self.top is None


  def   __lowercase		(		self      :     List[Any]							,_a      :     T       ):


     '''simple docstring'''






     _a				:	int			=   Node(_a       )
     if not self.is_empty():
        _a				:	Optional[Any]			=   self.top
     _a				:	List[str]			=   node


  def   __lowercase		(		self      :     Tuple       ):


     '''simple docstring'''






     if self.is_empty():
        raise IndexError('pop from empty stack'       )
     assert isinstance(self.top							,_a       )
     _a				:	List[Any]			=   self.top
     _a				:	int			=   self.top.next
     return pop_node.data


  def   __lowercase		(		self      :     List[str]       ):


     '''simple docstring'''






     if self.is_empty():
        raise IndexError('peek from empty stack'       )

     assert self.top is not None
     return self.top.data


  def   __lowercase		(		self      :     List[str]       ):


     '''simple docstring'''






     _a				:	Optional[int]			=   None


if __name__ == "__main__":
  from doctest import testmod

  testmod()



