






def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   global f  # a global dp table for knapsack
   if f[i][j] < 0:
      if j < wt[i - 1]:
         lowercase_	:    List[str]           =     mf_knapsack(i - 1						,		lowerCamelCase_						,		lowerCamelCase_						,		lowerCamelCase_							)
      else:
         lowercase_	:    Dict           =     max(
             mf_knapsack(i - 1						,		lowerCamelCase_						,		lowerCamelCase_						,		lowerCamelCase_							)						,		mf_knapsack(i - 1						,		lowerCamelCase_						,		lowerCamelCase_						,		j - wt[i - 1]							) + val[i - 1]						,		)
      lowercase_	:    str           =     val
   return f[i][j]




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   lowercase_	:    Any           =     [[0] * (w + 1) for _ in range(n + 1							)]

   for i in range(1						,		n + 1							):
      for w_ in range(1						,		w + 1							):
         if wt[i - 1] <= w_:
            lowercase_	:    Any           =     max(val[i - 1] + dp[i - 1][w_ - wt[i - 1]]						,		dp[i - 1][w_]							)
         else:
            lowercase_	:    Union[str, Any]           =     dp[i - 1][w_]

   return dp[n][w_], dp




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   if not (isinstance(lowerCamelCase_						,		(list, tuple)							) and isinstance(lowerCamelCase_						,		(list, tuple)							)):
      raise ValueError(
          "Both the weights and values vectors must be either lists or tuples"							)

   lowercase_	:    str           =     len(lowerCamelCase_							)
   if num_items != len(lowerCamelCase_							):
      lowercase_	:    str           =     (
          """The number of weights must be the same as the number of values.\n"""
          F"""But got {num_items} weights and {len(lowerCamelCase_							)} values"""
      )
      raise ValueError(lowerCamelCase_							)
   for i in range(lowerCamelCase_							):
      if not isinstance(wt[i]						,		lowerCamelCase_							):
         lowercase_	:    Tuple           =     (
             """All weights must be integers but got weight of """
             F"""type {type(wt[i]							)} at index {i}"""
         )
         raise TypeError(lowerCamelCase_							)

   lowercase_	:    List[str]           =     knapsack(lowerCamelCase_						,		lowerCamelCase_						,		lowerCamelCase_						,		lowerCamelCase_							)
   lowercase_	:    set           =     set()
   _construct_solution(lowerCamelCase_						,		lowerCamelCase_						,		lowerCamelCase_						,		lowerCamelCase_						,		lowerCamelCase_							)

   return optimal_val, example_optional_set




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   if i > 0 and j > 0:
      if dp[i - 1][j] == dp[i][j]:
         _construct_solution(lowerCamelCase_						,		lowerCamelCase_						,		i - 1						,		lowerCamelCase_						,		lowerCamelCase_							)
      else:
         optimal_set.add(lowerCamelCase_							)
         _construct_solution(lowerCamelCase_						,		lowerCamelCase_						,		i - 1						,		j - wt[i - 1]						,		lowerCamelCase_							)


if __name__ == "__main__":
 UpperCamelCase__ =			[3, 2, 4, 4]
 UpperCamelCase__ =			[4, 3, 2, 3]
 UpperCamelCase__ =			4
 UpperCamelCase__ =			6
 UpperCamelCase__ =			[[0] * (w + 1)] + [[0] + [-1] * (w + 1) for _ in range(n + 1)]
 UpperCamelCase__,     UpperCamelCase__ =			knapsack(w, wt, val, n)
 print(optimal_solution)
 print(mf_knapsack(n, wt, val, w))  # switched the n and w

 # testing the dynamic programming problem with example
 # the optimal subset for the above example are items 3 and 4
 UpperCamelCase__,     UpperCamelCase__ =			knapsack_with_example_solution(w, wt, val)
 assert optimal_solution == 8
 assert optimal_subset == {3, 4}
 print('optimal_value = ', optimal_solution)
 print('An optimal subset corresponding to the optimal value', optimal_subset)












'''simple docstring'''
def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase							):


   """simple docstring"""




   lowercase_	:    Any           =     False
   while is_sorted is False:  # Until all the indices are traversed keep looping
      lowercase_	:    List[str]           =     True
      for i in range(0						,		len(_UpperCamelCase							) - 1						,		2							):  # iterating over all even indices
         if input_list[i] > input_list[i + 1]:
            lowercase_    ,		lowercase_	:    Union[str, Any]           =     input_list[i + 1], input_list[i]
            # swapping if elements not in order
            lowercase_	:    Any           =     False

      for i in range(1						,		len(_UpperCamelCase							) - 1						,		2							):  # iterating over all odd indices
         if input_list[i] > input_list[i + 1]:
            lowercase_    ,		lowercase_	:    Tuple           =     input_list[i + 1], input_list[i]
            # swapping if elements not in order
            lowercase_	:    List[Any]           =     False
   return input_list


if __name__ == "__main__":
 print('Enter list to be sorted')
 UpperCamelCase__ =			[int(x) for x in input().split()]
 # inputing elements of the list in one line
 UpperCamelCase__ =			odd_even_sort(input_list)
 print('The sorted list is')
 print(sorted_list)




