'''simple docstring'''

from math import pow







def __UpperCamelCase(   _A					:				int  ,			_A					:				int  ,			_A					:				int  ,			_A					:				int  ,			_A					:				int  ,			):
   '''simple docstring'''
   if current_sum == needed_sum:
      # If the sum of the powers is equal to needed_sum, then we have a solution.
      solutions_count += 1
      return current_sum, solutions_count

   UpperCAmelCase__							:				str   				=  int(pow(_A  ,			_A    )    )
   if current_sum + i_to_n <= needed_sum:
      # If the sum of the powers is less than needed_sum, then continue adding powers.
      current_sum += i_to_n
      UpperCAmelCase__				,      UpperCAmelCase__							:				Tuple   				=  backtrack(
          _A  ,			_A  ,			current_number + 1  ,			_A  ,			_A    )
      current_sum -= i_to_n
   if i_to_n < needed_sum:
      # If the power of i is less than needed_sum, then try with the next power.
      UpperCAmelCase__				,      UpperCAmelCase__							:				Dict   				=  backtrack(
          _A  ,			_A  ,			current_number + 1  ,			_A  ,			_A    )
   return current_sum, solutions_count







def __UpperCamelCase(   _A					:				int  ,			_A					:				int    ):
   '''simple docstring'''
   if not (1 <= needed_sum <= 10_00 and 2 <= power <= 10):
      raise ValueError(
          '''Invalid input\n'''
          '''needed_sum must be between 1 and 1000, power between 2 and 10.'''    )

   return backtrack(_A  ,			_A  ,			1  ,			0  ,			0    )[1]  # Return the solutions_count


if __name__ == "__main__":
  import doctest

  doctest.testmod()





'''simple docstring'''

# Logistic Regression from scratch

# In[62]:

# In[63]:

# importing all the required libraries

import numpy as np
from matplotlib import pyplot as plt
from sklearn import datasets







def __UpperCamelCase(   _A					:				str    ):
   '''simple docstring'''
   return 1 / (1 + np.exp(-z    ))







def __UpperCamelCase(   _A					:				int  ,			_A					:				str    ):
   '''simple docstring'''
   return (-y * np.log(_A    ) - (1 - y) * np.log(1 - h    )).mean()







def __UpperCamelCase(   _A					:				Optional[Any]  ,			_A					:				Tuple  ,			_A					:				Any    ):
   '''simple docstring'''
   UpperCAmelCase__							:				Union[str, Any]   				=  np.dot(_A  ,			_A    )
   return np.sum(y * scores - np.log(1 + np.exp(_A    )    )    )







def __UpperCamelCase(   _A					:				Dict  ,			_A					:				Optional[int]  ,			_A					:				List[Any]  ,			_A					:				str=7_00_00    ):
   '''simple docstring'''
   UpperCAmelCase__							:				List[Any]   				=  np.zeros(x.shape[1]    )

   for iterations in range(_A    ):
      UpperCAmelCase__							:				Tuple   				=  np.dot(_A  ,			_A    )
      UpperCAmelCase__							:				Optional[Any]   				=  sigmoid_function(_A    )
      UpperCAmelCase__							:				Optional[int]   				=  np.dot(x.T  ,			h - y    ) / y.size
      UpperCAmelCase__							:				List[Any]   				=  theta - alpha * gradient  # updating the weights
      UpperCAmelCase__							:				Tuple   				=  np.dot(_A  ,			_A    )
      UpperCAmelCase__							:				Tuple   				=  sigmoid_function(_A    )
      UpperCAmelCase__							:				Optional[int]   				=  cost_function(_A  ,			_A    )
      if iterations % 1_00 == 0:
         print(F'''loss: {j} \t'''    )  # printing the loss after every 100 iterations
   return theta


# In[68]:

if __name__ == "__main__":
  UpperCamelCase__     :	str				=			datasets.load_iris()
  UpperCamelCase__     :	Tuple				=			iris.data[:, :2]
  UpperCamelCase__     :	str				=			(iris.target != 0) * 1

  UpperCamelCase__     :	Any				=			0.1
  UpperCamelCase__     :	List[str]				=			logistic_reg(alpha, x, y, max_iterations=70_000)
  print('theta: ', theta)  # printing the theta i.e our weights vector







  def __UpperCamelCase(   _A					:				Any    ):
     '''simple docstring'''
     return sigmoid_function(
         np.dot(_A  ,			_A    )    )  # predicting the value of probability from the logistic regression algorithm

  plt.figure(figsize=(10, 6))
  plt.scatter(x[y == 0][:, 0], x[y == 0][:, 1], color='b', label='0')
  plt.scatter(x[y == 1][:, 0], x[y == 1][:, 1], color='r', label='1')
  ((UpperCamelCase__)				,     (UpperCamelCase__))     :	Any				=			(x[:, 0].min(), x[:, 0].max())
  ((UpperCamelCase__)				,     (UpperCamelCase__))     :	Optional[Any]				=			(x[:, 1].min(), x[:, 1].max())
  ((UpperCamelCase__)				,     (UpperCamelCase__))     :	Any				=			np.meshgrid(np.linspace(xa_min, xa_max), np.linspace(xa_min, xa_max))
  UpperCamelCase__     :	str				=			np.c_[xxa.ravel(), xxa.ravel()]
  UpperCamelCase__     :	Union[str, Any]				=			predict_prob(grid).reshape(xxa.shape)
  plt.contour(xxa, xxa, probs, [0.5], linewidths=1, colors='black')

  plt.legend()
  plt.show()




