Python 支付员工工资

比如说，我想给一些员工一些钱，每个员工必须拿到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()

#/垃圾桶/蟒蛇3
导入操作系统
导入系统
def PAYMP（n、a、b、k）：
总支出=0
当前工资=0
增加=真
对于范围（n）中的i：
如果增加==真：
如果currentPay=b：
总支出+=b
增加=错误
其他：
总支付额+=当前支付额
其他：
当前工资-=k
如果currentPay我可能会使用生成器函数来创建支出：

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))

基于我作为问题注释发布的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))

这是因为我们用这个算法封装的模式是无限循环模式
[范围（a，b+1，k），范围（b，a-1，-k）]
（遍历
k
从
a
到
b
，然后遍历
-k
从
b
到
a
）
itertools.chain.from_iterable
从单个
range
迭代器中提取，并且
islice
确保我们只获取
n
的结果

cyc
和
chained
是无限系列，而
islice
的任务是限制学生人数。
您应该描述一个实际问题。此外，请检查此如何正确提问。我编辑了您的描述-链接只有在它们是“装饰者”时才受欢迎-所述问题应该是可以理解的，没有链接-只有通过阅读您的问题。这有一个可爱的答案，使用Haskell中的无限列表<代码>f n a b k=总和。以n为例。康卡特。循环$[[a，a+k..b]，[b，b-k..a]

这给了我一个n，a，b，k=7 1 3的错误结果1@TheMan结果是

[1,2,3,2,1,2,3]14

-为什么这是错误的？它有7个结果，你在1和3之间波动，回来，inc/dec乘以1…这给了我一个不正确的结果，n，a，b，k=713。我应该得到13分，但我得到14分。为什么？请注意，由于每个人增加1（因为k=1），第4人本来会收到4，但因为这超过了b=3，第4人收到的正好是b=3。类似地，第7个人收到的是1而不是0，如果有第8个人，他会收到2。所以我们有1+2+3+3+2+1+1，给出的总数是13。@TheMan在第一次中断后删除

p-=k

，在第二次中断前删除

p=a+k

。我读了你的描述，所以你只给出了一个b（和a）-而不是a和b的两倍。itertools的例子是有效的，我在做了一些研究后理解了它。非常感谢。但是有点慢though@TheMan我不确定它是否比Python中的任何其他方法都慢，是吗？它比我的快

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))