


from __future__ import annotations


def 		lowercase_	(  _UpperCamelCase							,      _UpperCamelCase	):


			'''simple docstring'''







			if nth_term == "":
						return [""]
			__lowercase			       = int(_snake_case	)
			__lowercase			       = int(_snake_case	)
			__lowercase			       = []
			for temp in range(int(_snake_case	)	):
						series.append(F'1 / {pow(temp + 1							,      int(_snake_case	)	)}' if series else '''1'''	)
			return series


if __name__ == "__main__":
	import doctest

	doctest.testmod()

	a			:			Any												=					int(input('''Enter the last number (nth term) of the P-Series'''))
	a			:			Dict												=					int(input('''Enter the power for  P-Series'''))
	print('''Formula of P-Series => 1+1/2^p+1/3^p ..... 1/n^p''')
	print(p_series(nth_term, power))




"""simple docstring"""



def 					lowerCamelCase   (     _snake_case    ,_snake_case    ,_snake_case ):
    if len(_snake_case ) != len(_snake_case ):
        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__	:      Any     							=					[p / w for p, w in zip(_snake_case    ,_snake_case )]

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

    # declaring useful variables
    UpperCAmelCase__	:      Tuple     							=					len(_snake_case )
    UpperCAmelCase__	:      List[Any]     							=					0
    UpperCAmelCase__	:      Union[str, Any]     							=					0
    UpperCAmelCase__	:      Any     							=					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__	:      Tuple     							=					sorted_profit_by_weight[length - i - 1]
        UpperCAmelCase__	:      int     							=					profit_by_weight.index(_snake_case )
        UpperCAmelCase__	:      str     							=					-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)

