

"""simple docstring"""




def   lowerCAmelCase						(					__UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase      ):
 '''simple docstring'''





 if len(__UpperCamelCase      ) != len(__UpperCamelCase      ):
  raise ValueError("""The length of profit and weight must be same."""      )
 if max_weight <= 0:
  raise ValueError("""max_weight must greater than zero."""      )
 if any(p < 0 for p in profit      ):
  raise ValueError("""Profit can not be negative."""      )
 if any(w < 0 for w in weight      ):
  raise ValueError("""Weight can not be negative."""      )

 # List created to store profit gained for the 1kg in case of each weight
 # respectively.  Calculate and append profit/weight for each element.
 UpperCAmelCase__					:  str					   =					[p / w for p, w in zip(__UpperCamelCase							,    __UpperCamelCase      )]

 # Creating a copy of the list and sorting profit/weight in ascending order
 UpperCAmelCase__					:  List[str]					   =					sorted(__UpperCamelCase      )

 # declaring useful variables
 UpperCAmelCase__					:  str					   =					len(__UpperCamelCase      )
 UpperCAmelCase__					:  List[str]					   =					0
 UpperCAmelCase__					:  Optional[int]					   =					0
 UpperCAmelCase__					:  Optional[int]					   =					0

 # loop till the total weight do not reach max limit e.g. 15 kg and till i<length
 while limit <= max_weight and i < length:
  # flag value for encountered greatest element in sorted_profit_by_weight
  UpperCAmelCase__					:  Optional[Any]					   =					sorted_profit_by_weight[length - i - 1]
  UpperCAmelCase__					:  Optional[Any]					   =					profit_by_weight.index(__UpperCamelCase      )
  UpperCAmelCase__					:  Tuple					   =					-1

  # check if the weight encountered is less than the total weight
  # encountered before.
  if max_weight - limit >= weight[index]:
   limit += weight[index]
   # Adding profit gained for the given weight 1 ===
   # weight[index]/weight[index]
   gain += 1 * profit[index]
  else:
   # Since the weight encountered is greater than limit, therefore take the
   # required number of remaining kgs and calculate profit for it.
   # weight remaining / weight[index]
   gain += (max_weight - limit) / weight[index] * profit[index]
   break
  i += 1
 return gain


if __name__ == "__main__":
      print(
          'Input profits, weights, and then max_weight (all positive ints) separated by '
          'spaces.'
      )

      __UpperCAmelCase =				[int(x) for x in input('Input profits separated by spaces: ').split()]
      __UpperCAmelCase =				[int(x) for x in input('Input weights separated by spaces: ').split()]
      __UpperCAmelCase =				int(input('Max weight allowed: '))

      # Function Call
      calc_profit(profit, weight, max_weight)








"""simple docstring"""




from __future__ import annotations
def   lowerCAmelCase						(					__UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase      ):
 '''simple docstring'''





 UpperCAmelCase__					:  Dict					   =					list(range(len(__UpperCamelCase      )      )      )
 UpperCAmelCase__					:  Union[str, Any]					   =					[v / w for v, w in zip(__UpperCamelCase							,    __UpperCamelCase      )]
 index.sort(key=lambda __UpperCamelCase      : ratio[i]							,    reverse=__UpperCamelCase      )

 UpperCAmelCase__					:  float					   =					0
 UpperCAmelCase__					:  list[float]					   =					[0] * len(__UpperCamelCase      )
 for i in index:
  if weight[i] <= capacity:
   UpperCAmelCase__					:  Optional[Any]					   =					1
   max_value += value[i]
   capacity -= weight[i]
  else:
   UpperCAmelCase__					:  Union[str, Any]					   =					capacity / weight[i]
   max_value += value[i] * capacity / weight[i]
   break

 return max_value, fractions


if __name__ == "__main__":
      import doctest

      doctest.testmod()





