Wert zuweisen durch Vergleich verschiedener Listen mit unterschiedlichen Mitgliedszahlen

Question

Ich bin ein absoluter Anfänger auf Programmiersprache einschließlich Python und dieses Problem Art von schwierig für mich. Schätzen Sie, wenn Sie mir helfen können.

So habe ich diese beide Liste der Liste:

S = [[D, 0.67, 0.05], [A, 0.68, 0.06], [C, 2.00, 0.13], [B, 0.68, 0.39], [E, 1.28, 0.97], [F, 0.72, 1.05], [I, 0.58, 1.05], [G, 1.25, 2.03], [H, 1.10, 3.59], [J, 0.98, 4.14]] 
R = [[D, 0.67, 0.05], [A, 0.68, 0.06], [C, 2.00, 0.13]] 

jede Liste auf beiden Listen bestehen aus [point name, x value, y value]

Also, ich habe Punktzahl für jeden Punkt in S Liste zuzuordnen R Liste beziehen, durch den Vergleich y-Wertes von Listen in Liste S zum nächsten und kleineren y-Wert in der Liste R. die Partitur wäre:

(1/y value of list S) over (1/closest and smaller y value of list R) 

Beispiel: Punkt [B, 0.68, 0.39] auf S Liste am nächsten [C, 2.00, 0.13] in R Liste zu zeigen, so wird die Partitur (1/0.39)/(1/0.13)

ich so sein muß, um das Ergebnis sein:

S_score = [[D,1],[A,1],[C,1],[B,0.33],[E,0.13],[F,0.12],[I,0.12],[G,0.06],[H,0.04],[J,0.03]] 

Dies ist, was ich bisher getan habe, aber ich weiß nicht wissen, wie S_score-Liste den Punktnamen enthalten. Neben diesem Code scheint nicht effizient, da, wenn es viel mehr Mitglied der Liste R als Referenz, muß ich Zustand so viel machen wie die

S_score = [] 
for i in xrange(len(S)): 
    if S[i][2] >= R[0][2] and S[i][2] <= R[1][2]: 
     value = (1/S[i][2])/(1/R[0][2]) 
     score.append(value) 
    else: 
     if S[i][2] >= R[1][2] and S[i][2] <= R[2][2]: 
      value = (1/S[i][2])/(1/R[1][2]) 
      score.append(value) 
     if S[i][2] >= R[2][2]: 
      value = (1/S[i][2])/(1/R[2][2]) 
      score.append(value) 

print "Score: ", S_score 

Danke im Voraus

Answer 1

Dies funktioniert:

def maximum(arr): 
    x = arr[0] 
    for x1 in arr: 
     x = x1 if x1[2] > x[2] else x 
    return x 

def foo(x, arr): 
    x1 = maximum(filter(lambda x2: x2[2] <= x[2], arr)) 
    return (1/x[2])/(1/x1[2]) 

result = [[x[0], foo(x, R)] for x in S] 

Die Idee hier ist, dass die Funktion foo nur die Werte von R an die maximale Funktion senden wird, die y kleiner oder gleich dem aktuellen y sind, und dass die eine mit dem größten y zurückgibt.

Danach ist es nur die Berechnung, die Sie zur Verfügung gestellt haben.

Der Code mit dem Ergebnis ist ein einfaches Listenverständnis.