

def        __lowercase   (  _A    ,     _A      )  ->    int:






      for index, item in enumerate(__UpperCAmelCase      ):
            if item == target:
                  return index
      return -1






def        __lowercase   (  _A    ,     _A    ,     _A    ,     _A      )  ->    int:






      if not (0 <= high < len(__UpperCAmelCase      ) and 0 <= low < len(__UpperCAmelCase      )):
            raise Exception("""Invalid upper or lower bound!"""      )
      if high < low:
            return -1
      if sequence[low] == target:
            return low
      if sequence[high] == target:
            return high
      return rec_linear_search(__UpperCAmelCase    ,     low + 1    ,     high - 1    ,     __UpperCAmelCase      )


if __name__ == "__main__":
  UpperCAmelCase__			:  List[Any]					     =     input("""Enter numbers separated by comma:\n""").strip()
  UpperCAmelCase__			:  Optional[int]					     =     [int(item.strip()) for item in user_input.split(""",""")]

  UpperCAmelCase__			:  str					     =     int(input("""Enter a single number to be found in the list:\n""").strip())
  UpperCAmelCase__			:  Dict					     =     linear_search(sequence, target)
  if result != -1:
    print(F"""linear_search({sequence}, {target}) = {result}""")
  else:
    print(F"""{target} was not found in {sequence}""")









import random







class 				a_    :

						def __init__(       self      :Union[str, Any]  ,		_lowercase      :float  ,		_lowercase      :float)						->   None:
												UpperCAmelCase_					=	x
												UpperCAmelCase_					=	y

						def       __a			(       self      :str)						->   bool:
												return (self.x**2 + self.y**2) <= 1




						@classmethod
						def       __a			(       cls      :Optional[Any])						->   str:
												return cls(x=random.random()  ,		y=random.random())







def 							A     (						__UpperCAmelCase      )			->			float:



						'''simple docstring'''






						if number_of_simulations < 1:
												raise ValueError('''At least one simulation is necessary to estimate PI.'''      )

						UpperCAmelCase_					=	0
						for _ in range(__UpperCAmelCase      ):
												UpperCAmelCase_					=	Point.random_unit_square()

												if random_point.is_in_unit_circle():
																		number_in_unit_circle += 1

						return 4 * number_in_unit_circle / number_of_simulations


if __name__ == "__main__":
							# import doctest

							# doctest.testmod()
							from math import pi

							UpperCamelCase_      			=  "Please enter the desired number of Monte Carlo simulations: "
							UpperCamelCase_      			=  estimate_pi(int(input(prompt).strip()))
							print(f"An estimate of PI is {my_pi} with an error of {abs(my_pi - pi)}")





