





def 		lowerCAmelCase_    (  __UpperCAmelCase:			Dict		,   __UpperCAmelCase:			Any		,   __UpperCAmelCase:			Any      )      ->	Tuple:
    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__							:				Optional[int]          =      sorted(__UpperCAmelCase      )

    # declaring useful variables
    UpperCamelCase__							:				Tuple          =      len(__UpperCAmelCase      )
    UpperCamelCase__							:				int          =      0
    UpperCamelCase__							:				List[Any]          =      0
    UpperCamelCase__							:				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[int]          =      sorted_profit_by_weight[length - i - 1]
        UpperCamelCase__							:				Optional[Any]          =      profit_by_weight.index(__UpperCAmelCase      )
        UpperCamelCase__							:				Any          =      -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'''

import unittest

from knapsack import knapsack as k



class 			UpperCAmelCase  (						unittest.TestCase					):





       '''simple docstring'''



       def _lowerCAmelCase(						self )  ->  Tuple:
        lowercase__				:    Optional[Any]  =					0
        lowercase__				:    Any  =					[0]
        lowercase__				:    List[Any]  =					[0]
        lowercase__				:    Optional[Any]  =					len(__lowerCAmelCase )
        self.assertEqual(k.knapsack(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )	,   0 )

        lowercase__				:    List[str]  =					[60]
        lowercase__				:    List[str]  =					[10]
        lowercase__				:    List[str]  =					len(__lowerCAmelCase )
        self.assertEqual(k.knapsack(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )	,   0 )

       def _lowerCAmelCase(						self )  ->  Optional[Any]:
        lowercase__				:    Optional[Any]  =					3
        lowercase__				:    List[Any]  =					[1, 2, 3]
        lowercase__				:    Union[str, Any]  =					[3, 2, 1]
        lowercase__				:    List[Any]  =					len(__lowerCAmelCase )
        self.assertEqual(k.knapsack(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )	,   5 )


       def _lowerCAmelCase(						self )  ->  Optional[Any]:
        lowercase__				:    int  =					50
        lowercase__				:    Any  =					[60, 100, 120]
        lowercase__				:    int  =					[10, 20, 30]
        lowercase__				:    Optional[Any]  =					len(__lowerCAmelCase )
        self.assertEqual(k.knapsack(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )	,   220 )


if __name__ == "__main__":
  unittest.main()

