0

比如说我想给一些员工一些钱。每个员工必须得到 $a 和 $b 之间的美元。第一个员工得到 $a，每个后续员工比上一个员工多得到 $k，直到该金额超过 $b，在这种情况下，该员工得到 $b，之后每个后续员工得到 $k，直到该金额低于$a 在这种情况下，员工将获得 $a，并且所有 n 名员工的循环都将继续。我想将总支出退还给所有员工

到目前为止我所拥有的：

#!/bin/python3
import os
import sys

def payEmp(n, a, b, k):
    totalPayOut = 0
    currentPay = 0
    increase = True
    for i in range(n):
        if increase == True:
            if currentPay < a:
                currentPay += a
            else:
                currentPay += k
                if currentPay >= b:
                    totalPayOut += b
                    increase = False
                else:
                    totalPayOut += currentPay
        else:
            currentPay -= k
            if currentPay <= a:
                totalPayOut += a
                increase = True
            else:
                totalPayOut += currentPay

    return totalPayOut



if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')

    t = int(input())

    for t_itr in range(t):
        nabk = input().split()

        n = int(nabk[0])

        a = int(nabk[1])

        b = int(nabk[2])

        k = int(nabk[3])

        result = payEmp(n, a, b, k)

        fptr.write(str(result) + '\n')

    fptr.close()
4

2 回答 2

1

我可能会使用生成器函数来创建支出：

def pay(n,a,b,k):
    p = a # start with a
    c = 0
    while c < n: # loop until enough values generated
        # upcounting payments
        while p <= b and c < n:  # do this until enough or payment reached b
            yield p
            c += 1
            if p != b:
                p = min(b,p+k) # increase as long as not reached, prevent overshooting      
            else: # we reached and yielded b so we are done
                break # we just yielded b - less payment from now on
        p -= k  # we already yielded b - so we add k again
        # downcounting payments
        while p >= a and c < n:  # do this until enough or payment reached a again
            yield p
            c += 1
            if p != a:
                p = max(a,p-k) # decrease as long as not reached, prevent undershooting
            else: # we just yielded a, were done going down, back up from now on
                p = a+k
                break # we just printed a, more pay from here on

pays = list(pay(15,2,9,2))
print(pays,sum(pays))

输出：

[2, 4, 6, 8, 9, 7, 5, 3, 2, 4, 6, 8, 9, 7, 5] 85
于 2018-04-24T20:32:56.767 回答
0

基于我作为对该问题的评论发布的 Haskell 解决方案，这里是使用itertools使用无限值​​列表的库的解决方案。

import itertools

def pay(n, a, b, k):
    cyc = itertools.cycle([range(a, b+1, k), range(b, a-1, -k)])
    chained = itertools.chain.from_iterable(cyc)
    return sum(itertools.islice(chained, n))

这是有效的，因为我们用这个算法封装的模式是无限循环模式[range(a, b+1, k), range(b, a-1, -k)]（k从a到b走到，然后-k从b到走到a）。itertools.chain.from_iterable从各个range迭代器中提取，并islice确保我们只获取n结果。

cyc并且chained是无限的系列，并且islice正在做限制n学生的工作。

于 2018-04-24T23:08:54.970 回答