用Python、Ruby、Haskell（或其他任何工具）迭代列表

Question

更新：我意识到我提出的问题非常糟糕。再来一次。

考虑以下功能：

myList = []
optimumList = []

def findOptimumListItems():
    n = 5

    for i in range (n + 1):
        for j in range (n + 1 - i):
            myList.append((i, j, n-i-j))

    for i in myList:
        win = 0.0
        draw = 0.0
        for j in myList:
            score = 0
            if (i[0] > j[0]):
                score += 1
            if (i[0] == j[0]):
                score += 0.5
            if (i[1] > j[1]):
                score += 1
            if (i[1] == j[1]):
                score += 0.5
            if (i[2] > j[2]):
                score += 1
            if (i[2] == j[2]):
                score += 0.5  
            if (score == 2):
                win += 1
            if (score == 1.5):
                draw += 1
        if (win/(len(myList)-win-draw) > 1.0):
            optimumList.append(i)

    return optimumList

首先我列一张单子。对于n=5，生成的列表为：

^{pr2}$

然后，函数获取列表的每个元素并将其与列表本身进行比较。你是这样做的：假设我在比较[0，0，5]和[3，1，1]。0输给3（所以没分），0输给1，所以没分，5胜1（得1分）。平局得0.5分，获胜得1分。对于任何一个项目，如果赢的比输的多，那么这个项目被认为是最佳的，并被添加到最佳列表中。在

对于n=5，最佳列表为：

[(0, 2, 3), (0, 3, 2), (1, 1, 3), (1, 2, 2), (1, 3, 1), (2, 0, 3),
 (2, 1, 2), (2, 2, 1), (2, 3, 0), (3, 0, 2), (3, 1, 1), (3, 2, 0)]

我的问题是：如何以一种简洁的方式编写上述函数？我对函数算法特别感兴趣。Python，Ruby，Java，Haskell答案将不胜感激。（话虽如此，如果你能用任何语言找到一个简洁的解决方案，那没关系。）

很抱歉重复同样的问题。我同意最初的问题很混乱，很难理解。我希望现在是清楚的。在

更新（根据rampion的评论）：对于这个（或这种类型）问题，是否有一个有效的算法？在

Answer 1

在哈斯凯尔：

optimize :: Int -> [(Int,Int,Int)]
optimize n = filter optimal [ (a,b,c) | a <- [0..n], b <- [0..(n-a)], let c = n - a - b ]
  where optimal x = (>0) . sum $ map (comp x) xs
        comp (a,b,c) (a',b',c') = signum $ vs a a' + vs b b' + vs c c'
        vs x x' = case compare x x' of
                    GT -> 1
                    EQ -> 0
                    LT -> -1

虽然这相当简洁，但效率不高（我们将（0,3,2）与（0,2,3）进行比较，反之亦然，当我们只需要这样做一次时）。在

Answer 2

这还没有完成，但我认为这是一个好的开始。在

它是用红宝石写的。在

>> l = [1,2,3]
>> l.map {|n| l.map{|i| i > n ? 1 : 0.5 }}.flatten.inject(0){|start, n| start + n}
=> 6.0

Answer 3

第二次更新：太好了——现在我完全明白你想要什么了。这与您最近编辑的代码执行的操作相同：

def optimize(myList):
    score_tup = lambda tup_a, tup_b: sum(1.0 if a > b else 0.5 if a == b else 0 for a, b in zip(tup_a, tup_b))
    scores = ((tup_a, [score_tup(tup_a, tup_b) for tup_b in myList]) for tup_a in myList)
    scores = ((tup, score.count(2), score.count(1.5)) for tup, score in scores)
    return [tup for tup, win, draw in scores if (win * 1.0 / (len(myList) - win - draw)) > 1.0]

a = 5
myList = [(i, j, a-i-j) for i in range(a + 1) for j in range(a + 1 - i)]
print myList
print optimize(myList)

如果您想查看此答案的以前版本，请检查编辑；这太长了。在