有解决任务分配问题的算法吗？

Question

给定审阅者列表和拉取请求列表。 需要设计一种算法以循环方式分配审阅者。 每次迭代后，都会存储评论历史（选择评论历史最少的评论者将不起作用。）。 需要确保新工程师（新聘用的）不会是即将到来的拉取请求的唯一审阅者，因为他们的审阅者数量最少。

目前，我没有任何代码只是试图找到一种方法来解决可能是零评论计数的新评论者的问题。 使用静态审阅者列表实现算法将是一个问题。

这是我要解决的特定用例：

review_history = [{'user_1': 10}, {'user_2': 8}, {'user_3': 9}, {'user_4': 0}] 

• 如果选择评论计数最少的用户，则将在接下来的 8 个拉取请求中选择 user_4。
• 如果随机选择一个用户，评论计数将不会平均分配。

任何想法，将不胜感激。 谢谢！

Answer 1

也许您应该根据优先级分阶段分配。 例如：

1. 首先将针对特定任务请求的任何审阅者分配给该任务，除非审阅者达到某个最大审阅数限制。

2. 带上所有非新审阅者，并开始将他们分散到任务中。 您应该跟踪哪些任务的审阅者数量最少，并且只为每个审阅者循环或从该子集中随机选择一个任务。 您也可以只从分配任务最少的一组审阅者中进行选择，这样您就可以保持工作量平衡。 一旦您将每个未充分利用的审阅者分配给分配最少的审阅任务，任务审阅者计数将增加一，因此它将不再是最少审阅的……除非当然没有更多审阅较少的任务。 继续遍历分配最少的审阅者，并继续仅将它们分配给审阅者数量最少的任务。 不要考虑任何历史评论，因为稍后添加的人员只需要为当前迭代获得均匀的工作量。

3. 由于新审阅者不应是主要审阅者，因此请最后分配他们。 同样，可能一次循环遍历每个新审阅者，并且只将它们分配给审阅者数量最少的任务集。

您可能可以使用字典在 Python 中跟踪所有这些。 例如，对于每个任务，您可以有一个子字典，其中包含所有分配的查看者的 ID。 您可以计算这些字典中有多少键，以确定哪个任务分配的审阅者数量最少，或者只是创建另一个数据结构来跟踪计数。 您还可以拥有一个审阅者 ID 字典来跟踪他们被分配了多少任务，以防他们可以分配多少评论。

如果有人有更好的想法会很好奇......我不认为这个问题需要一个超级复杂的算法来获得一个体面的解决方案。

Answer 2

也许您可以为此使用队列。

• 这个想法是直接有一个 ID 或审阅者实例队列，以某种随机或有组织的顺序（例如按字母顺序）开始。
• 然后，您首先通过从队列中删除审阅者并将他逐个附加到队列的后面来分配特定任务。
• 分配完所有特定任务后，您从队列中选择下一个审阅者，为他分配下一个任务并将他放在队列的后面。
• 新的审阅者可以被附加到队列的前面，这样他们就会得到下一个不具体的任务，但之后会进入队列的后面。

在最简单的形式中，您可以在 python 中将队列实现为双端队列，它具有您需要的所有功能（追加、追加、弹出和删除）。

from collections import deque


specific_tasks = [(3, "math"), (5, "english"), (2, "biology")]
print(f"{specific_tasks=}")
other_tasks = ["geography", "physiks", "chemistry", "sport", "history", "german"]
print(f"{other_tasks=}")
queue = deque([1, 2, 3, 4, 5, 6])
print(f"{queue=}")


print("\n--- assign specific tasks ---")
for reviewer_id, specific_task in specific_tasks:
    queue.remove(reviewer_id)
    queue.appendleft(reviewer_id)
    print(f"assign {specific_task=} to {reviewer_id=}")
    print(f"{queue=}")

print("\n--- assign other tasks ---")
for other_task in other_tasks:
    reviewer_id = queue.pop()
    queue.appendleft(reviewer_id)
    print(f"assign {other_task=} to {reviewer_id=}")
    print(f"{queue=}")

print("\n--- add reviewer ---")
new_reviewer = 9
queue.append(new_reviewer)
print(f"add reviewer {new_reviewer}")
print(f"{queue=}")

print("\n--- remove reviewer ---")
reviewer_to_remove = 4
queue.remove(reviewer_to_remove)
print(f"remove reviewer {reviewer_to_remove}")
print(f"{queue=}")

这给出了以下输出：

specific_tasks=[(3, 'math'), (5, 'english'), (2, 'biology')]
other_tasks=['geography', 'physiks', 'chemistry', 'sport', 'history', 'german']
queue=deque([1, 2, 3, 4, 5, 6])

--- assign specific tasks ---
assign specific_task='math' to reviewer_id=3
queue=deque([3, 1, 2, 4, 5, 6])
assign specific_task='english' to reviewer_id=5
queue=deque([5, 3, 1, 2, 4, 6])
assign specific_task='biology' to reviewer_id=2
queue=deque([2, 5, 3, 1, 4, 6])

--- assign other tasks ---
assign other_task='geography' to reviewer_id=6
queue=deque([6, 2, 5, 3, 1, 4])
assign other_task='physiks' to reviewer_id=4
queue=deque([4, 6, 2, 5, 3, 1])
assign other_task='chemistry' to reviewer_id=1
queue=deque([1, 4, 6, 2, 5, 3])
assign other_task='sport' to reviewer_id=3
queue=deque([3, 1, 4, 6, 2, 5])
assign other_task='history' to reviewer_id=5
queue=deque([5, 3, 1, 4, 6, 2])
assign other_task='german' to reviewer_id=2
queue=deque([2, 5, 3, 1, 4, 6])

--- add reviewer ---
add reviewer 9
queue=deque([2, 5, 3, 1, 4, 6, 9])

--- remove reviewer ---
remove reviewer 4
queue=deque([2, 5, 3, 1, 6, 9])

Answer 3

考虑使用指数衰减。 虽然它有一个花哨的名字，并且被用于许多科学领域，但这可以产生一个相对简单和健壮的解决方案。

这是使用此功能的简单方法：

每次完成新请求时（这里我们假设权重 lambda=.98，但这可以调整。对于较大的团队，您希望衰减接近 1，因此我建议您使用decay = 1-(1/len(review_history))

-首先对所有用户权重进行归一化。 这将有助于避免最终出现全零向量，并有助于早期用户赶上。 在此期间，我们将用户的平均权重设为 1.0

- 然后所有用户的权重乘以 lambda（例如 times.98）

- 这样做的用户得到+1，

要查看它的实际效果：

import numpy as np
review_history=np.array([ 10, 8, 9, 0])

decay = 1-1.0/len(review_history)
print ("review_history:  "+" ,".join([f'{x:<2.3f}' for x in review_history]))
for i in range(10):
    review_history = (review_history * len(review_history)) / review_history.sum()
    print ("normalized    :  "+" ,".join([f'{x:<2.3f}' for x in review_history]), end='')
    review_history = review_history * decay
    print ("times decay   :  "+" ,".join([f'{x:<2.3f}' for x in review_history]), end='')
    pick = np.argmin(review_history)
    print(f'==>pick user:{pick+1}')
    review_history[pick] += 1
    print("   ==> pick +1:  "+" ,".join([f'{x:>2.3f}' for x in review_history]))

请注意，衰减应<=1。 对于衰变 = 1，你基本上得到了你的初始算法。 对于非常小的衰减，在几轮之前发生的任何事情基本上都不重要。 您可以选择自己的余额:)

您可以继续运行算法，例如数字[ 10, 8, 9, 0]并看到它工作正常，但实际上它应该更好，因为您一开始就不会得到这样的结果：

import numpy as np
review_history=np.array([ 0, 0, 0])

decay = 1-1.0/len(review_history)
print ("review_history:  "+" ,".join([f'{x:<2.3f}' for xin review_history]))
for i in range(100):
    review_history = review_history * decay
    pick = np.argmin(review_history)
    review_history[pick] += 1
    
print ("review_history after 100:  "+" ,".join([f'{x:<2.3f}' for x in review_history]))

现在添加一个用户：

review_history = np.array(list(review_history)+[0])
decay = 1-1.0/len(review_history)

下一个选择：

==>pick user:4
==>pick user:2
==>pick user:3
==>pick user:4
==>pick user:1
==>pick user:2
==>pick user:3
==>pick user:4
==>pick user:1
==>pick user:2

如果您认为这对新用户来说太公平了，请考虑跳过标准化部分和/或通过在得分最低的最后 x 个中随机选择来添加一些随机性...根据需要 Tweek...

Answer 4

import random
import json

with open("review_history.json", "r") as jsonFile:
    review_history = json.load(jsonFile)
total_pl = 0
user_count = 0
new_list = []
for i in review_history:
    user_count += 1
    for k in i: 
        total_pl += review_history[review_history.index(i)][k]
        new_list.append(review_history[review_history.index(i)][k])
print('total user count: ', user_count, '\n')       
print('total pull requests so far: ',total_pl,'\n')
print(new_list)

copy_list = new_list.copy()
for i in new_list:
    difference = max(new_list) - new_list[new_list.index(i)]
    print(difference)
    if difference >=5:
        copy_list[new_list.index(i)] = random.randint(42,50) 
    if difference >=3 and difference<5:
        copy_list[new_list.index(i)] = random.randint(30,50)    
    if difference >=0 and difference<3:
        copy_list[new_list.index(i)] = random.randint(5,50)

least = copy_list.index(max(copy_list))
print(review_history[least])
for i in review_history:
    for k in i:
        if review_history.index(i) == least:
            review_history[review_history.index(i)][k] += 1
with open("review_history.json", "w") as jsonFile:
    json.dump(review_history,jsonFile)
print(review_history)

# def reset_json1():
#     review_history = [{"user_1": 10}, {"user_2": 8}, {"user_3": 9}, {"user_4": 0}]
#     print(review_history)
#     with open("review_history.json", "w") as jsonFile:
#       json.dump(review_history,jsonFile)
# reset_json1()

User4 在大约 20 个拉取请求中赶上，一旦他赶上了，用户之间的差距永远不会超过 3。但是您可以使用值 42 并将其设置在 35 到 45 之间，具体取决于您希望该用户多快跟上来：

if difference >=5:
   copy_list[new_list.index(i)] = random.randint(42,50)

输出：

total user count:  4 

total pull requests so far:  81

[21, 21, 20, 19]
{'user_4': 19}
[{'user_1': 21}, {'user_2': 21}, {'user_3': 20}, {'user_4': 20}]
PS C:\Users\HP\Desktop\python> 

Answer 5

如果我正确理解您的请求，您愿意将评论发送给系统中的 X 个用户，而 X 计数将发生变化。 在您拥有的同一时间点标准不允许您一一选择用户。

有很多方法可以让这个工作，但我认为最简单的方法如下（它需要在执行之前获取有关先前选择的数据）。 为简单起见，您可以分配每个用户编号。

on init
      declare %last_round_robin[128]
      declare $total_round_robin
      declare polyphonic $current_round_robin
end on

on note
      if ($total_round_robin > 1)
            $current_round_robin := (%last_round_robin[$EVENT_NOTE] - 1 + random(1, $total_round_robin - 1)) mod $total_round_robin + 1
            %last_round_robin[$EVENT_NOTE] := $current_round_robin
      else
            $current_round_robin := 1
      end if
end on

如您所见，代码利用模运算符来包含除最后播放的循环之外的所有值，而不使用循环。 该代码将当前循环变量设置为介于 1 和最大可用循环之间的数字。 如果轮询值需要基于 0-index，这是一个简单的调整。

原帖： https ://www.orangetreesamples.com/blog/scripting-nonrepeating-roundrobin