Question

假设您有开发人员A，B，C，D，E，F，他们会相互审核。工作。

如何开发一种算法来生成审核轮换，告诉每个开发人员他们每周必须审核的工作并满足以下条件：

您无法连续两周审核同一个人
不能有闭环（A评价B，B评价A）
如果您在开始重复之前对其他开发人员进行一次审核，那就太好了。

我认为我可以与奇数开发人员合作，但我正在努力争取一个偶数。

Answer 1

我会走向nieve路线并通过圆形阵列旋转。因此，第1周每个人都会评论他们的权利+ 0。第2周每个人都会评论他们的权利+ 1。第3周，右+ 2等。

Week 1:
  A -> B
  B -> C
  ...
  F -> A
Week 2:
  A -> C
  B -> D
  ...
  F -> B

Answer 2

这是Haskell的蛮力（大约需要10秒才能开始）。

代码：

import Control.Monad (guard, replicateM)

developers = ["A", "B", "C", "D", "E", "F"]

combinations = filter (\x -> head x /= last x) . replicateM 2 $ developers

makeWeek week =
  if length week == length developers
     then [week]
     else do
       review <- combinations
       guard (notElem (take 1 review) (map (take 1) week)
              && notElem (drop 1 review) (map (drop 1) week)
              && notElem (reverse review) week
              && notElem review week)
       makeWeek (review:week)

solve = solve' [] where
  solve' weeks =
    if length weeks == length developers - 1
       then [weeks]
       else do
         week' <- makeWeek []
         guard (all (\x -> notElem x (concat . take (length developers - 1) $ weeks)) week')
         solve' (week':weeks)

示例输出：

*Main> solve
[[[["F","B"],["E","A"],["D","C"],["C","E"],["B","D"],["A","F"]]
 ,[["F","C"],["E","B"],["D","A"],["C","D"],["B","F"],["A","E"]]
 ,[["F","A"],["E","C"],["D","B"],["C","F"],["B","E"],["A","D"]]
 ,[["F","E"],["E","D"],["D","F"],["C","B"],["B","A"],["A","C"]]
 ,[["F","D"],["E","F"],["D","E"],["C","A"],["B","C"],["A","B"]]],...etc

Answer 3

有简单的round-robin tournament algorithm来获得所有可能的对而不重复。

Arrange developers in two columns, left column reviews right one.
Fix A place
Move all others in cyclic way.

A->F
B->E 
C->D

A->B
C->F 
D->E

A->C
D->B 
E->F

A->D
E->C 
F->B

A->E
F->D 
B->C

Answer 4

我似乎找到了一个受Round Robin轮换启发的解决方案。

对于开发者A，B，C，D，E，F

您修复了开发人员，说A。然后顺时针旋转其余部分。

然后：

排在最前一行的每个人都会评论他们下面的人
排在最后一行的每个人都会审核他们上方和右边的人

第1周：

A B C
D E F

AD
BE
CF
DB
EC
FA

第2周：

A D B
E F C

AE
DF
BC
ED
FB
CA

第3周：

A E D
F C B

AF
EC
DB
FE
CD
BA

第4周：

A F E
C B D

AC
FB
ED
CF
BE
DA

第5周：

A C F
B D E

AB
CD
FE
BC
DF
EA

虽然它仍会显示不需要的属性，但某些人永远不会遇到其他人，例如B避免D。

Answer 5

我假设通过闭环，你引用长度恰好为2的周期。也就是说，允许A评论B，{{1} }评论B和C评论C。

让A成为人数，让n成为他们的名字。

第1周：人0, ..., n-1会审核人i的代码。

第2周：人(i + 1) % n审核人i的代码。

...

周(i + 2) % n：人n/2 无法审核人i的代码，因为这会导致闭环。因此，人(i + n/2) % n会审核人i的代码。

周(i + n/2 + 1) % n：人n/2 + 1会审核人i的代码。

...

周(i + n/2 + 2) % n：人n - 1再次审核人i的代码，一切都重新开始。

注意：违反了您的最后一个（可选）要求（每个人在周期重新开始之前审核其他所有人）。对于(i + 1) % n和n = 2，无论如何都不存在满足所有要求的解决方案。基本案例n = 4是微不足道的。考虑案例n = 2：如果您想避免闭环，至少有一个人必须连续两次审查同一个人。（只需列举所有可能的审核关系即可查看）。

如果你真的需要你的最后一项要求，你必须使用@ groovy的解决方案。我会离开我的，因为它很容易计算。

如何为开发人员审核队列轮换开发算法？

5 个答案: