






'''simple docstring'''
def  _a(  UpperCamelCase__				:						Optional[int],	UpperCamelCase__				:						int							):




      '''simple docstring'''






      SCREAMING_SNAKE_CASE__     :				Optional[int]									=0
      SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=len(UpperCamelCase__							) - 1

      while left <= right:
            # avoid divided by 0 during interpolation
            if sorted_collection[left] == sorted_collection[right]:
                  if sorted_collection[left] == item:
                        return left
                  else:
                        return None

            SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=left + ((item - sorted_collection[left]) * (right - left)) // (
                sorted_collection[right] - sorted_collection[left]
            )

            # out of range check
            if point < 0 or point >= len(UpperCamelCase__							):
                  return None

            SCREAMING_SNAKE_CASE__     :				Optional[int]									=sorted_collection[point]
            if current_item == item:
                  return point
            else:
                  if point < left:
                        SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=left
                        SCREAMING_SNAKE_CASE__     :				Optional[Any]									=point
                  elif point > right:
                        SCREAMING_SNAKE_CASE__     :				Optional[int]									=right
                        SCREAMING_SNAKE_CASE__     :				Tuple									=point
                  else:
                        if item < current_item:
                              SCREAMING_SNAKE_CASE__     :				str									=point - 1
                        else:
                              SCREAMING_SNAKE_CASE__     :				Tuple									=point + 1
      return None





def  _a(  UpperCamelCase__				:						List[str],	UpperCamelCase__				:						Optional[Any],	UpperCamelCase__				:						Union[str, Any],	UpperCamelCase__				:						Union[str, Any]							):




      '''simple docstring'''






      if sorted_collection[left] == sorted_collection[right]:
            if sorted_collection[left] == item:
                  return left
            else:
                  return None

      SCREAMING_SNAKE_CASE__     :				Dict									=left + ((item - sorted_collection[left]) * (right - left)) // (
          sorted_collection[right] - sorted_collection[left]
      )

      # out of range check
      if point < 0 or point >= len(UpperCamelCase__							):
            return None

      if sorted_collection[point] == item:
            return point
      elif point < left:
            return interpolation_search_by_recursion(UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__							)
      elif point > right:
            return interpolation_search_by_recursion(UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__							)
      else:
            if sorted_collection[point] > item:
                  return interpolation_search_by_recursion(
                      UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	point - 1							)
            else:
                  return interpolation_search_by_recursion(
                      UpperCamelCase__,	UpperCamelCase__,	point + 1,	UpperCamelCase__							)





def  _a(  UpperCamelCase__				:						Dict							):




      '''simple docstring'''






      if collection != sorted(UpperCamelCase__							):
            raise ValueError('''Collection must be ascending sorted'''							)
      return True


if __name__ == "__main__":
 import sys
 a_					= 0
 if debug == 1:
  a_					= [1_0, 3_0, 4_0, 4_5, 5_0, 6_6, 7_7, 9_3]
  try:
   __assert_sorted(collection)
  except ValueError:
   sys.exit('Sequence must be ascending sorted to apply interpolation search')
  a_					= 6_7

 a_					= interpolation_search(collection, target)
 if result is not None:
  print(F'''{target} found at positions: {result}''')
 else:
  print('Not found')







'''simple docstring'''
from __future__ import annotations

import sys
from collections import deque
from typing import Generic, TypeVar

a_					= TypeVar('T')






class      __SCREAMING_SNAKE_CASE      (			Generic[T]				):
 snake_case_  							=							42  # Cache store of keys
 snake_case_  							=							42  # References of the keys in cache
 snake_case_  							=							10  # Maximum capacity of cache




 def __init__(      self	:							Dict					,      __lowercase	:							int      )	->						None:
       SCREAMING_SNAKE_CASE__     :				Any									=deque()
       SCREAMING_SNAKE_CASE__     :				str									=set()
       if not n:
             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=sys.maxsize
       elif n < 0:
             raise ValueError('''n should be an integer greater than 0.'''      )
       else:
             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=n




 def      __magic_name__	(      self	:							List[str]					,      __lowercase	:							T      )	->						None:
       if x not in self.key_reference:
             if len(self.dq_store      ) == LRUCache._MAX_CAPACITY:
                   SCREAMING_SNAKE_CASE__     :				int									=self.dq_store.pop()
                   self.key_reference.remove(__lowercase      )
       else:
             self.dq_store.remove(__lowercase      )

       self.dq_store.appendleft(__lowercase      )
       self.key_reference.add(__lowercase      )




 def      __magic_name__	(      self	:							Union[str, Any]      )	->						None:
       for k in self.dq_store:
             print(__lowercase      )




 def __repr__(      self	:							List[Any]      )	->						str:
       return F"LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store      )}"


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  a_					= LRUCache(4)
  lru_cache.refer('A')
  lru_cache.refer(2)
  lru_cache.refer(3)
  lru_cache.refer('A')
  lru_cache.refer(4)
  lru_cache.refer(5)
  lru_cache.display()

  print(lru_cache)
  assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"