Equilibrium Index in Python 2.7

Question

Ich bekam eine Demo-Aufgabe in Codility zu tun, und ich habe einige Schwierigkeiten, herauszufinden, was ich falsch mache. Die Aufgabe:

Arbeiten in Python 2.7 Environment

Ein Null-indiziertes Array A, bestehend aus N ganzen Zahlen angegeben. Ein Gleichgewichtsindex dieses Arrays ist eine beliebige ganze Zahl P, so dass 0 ≤ P < N und die Summe der Elemente niedrigerer Indizes gleich der Summe der Elemente höherer Indizes ist, dh

A [0] + A [1] + ... + A [P-1] = A [P + 1] + ... + A [N-2] + A [N-1].

Die Summe der Nullelemente wird als gleich 0 angenommen. Dies kann passieren, wenn P = 0 oder wenn P = N-1 ist.

Betrachten wir beispielsweise die folgende Matrix A bestehend aus N = 8 Elementen:

A[0] = -1 
A[1] = 3 
A[2] = -4 
A[3] = 5 
A[4] = 1 
A[5] = -6 
A[6] = 2 
A[7] = 1 

P = 1 ist, ein Gleichgewichtsindex dieser Anordnung, weil:

A[0] = −1 = A[2] + A[3] + A[4] + A[5] + A[6] + A[7] 

p = 3 ist, ein Gleichgewichtsindex dieses Feldes, weil:

A[0] + A[1] + A[2] = −2 = A[4] + A[5] + A[6] + A[7] 

P = 7 ist auch ein Gleichgewichtsindex, weil:

A[0] + A[1] + A[2] + A[3] + A[4] + A[5] + A[6] = 0 

und es sind keine Elemente mit den Indizes größer als 7

P = 8 ist kein Gleichgewichtsindex, da es nicht die Bedingung 0 ≤ P < N.

Write a nicht erfüllt, Funktion:

def-Lösung (A)

dass bei einer Null-indiziertes Array A, bestehend aus N ganze Zahlen sind, einer ihrer Gleichgewichtsindizes zurückgibt. Die Funktion sollte -1 zurückgeben, wenn kein Gleichgewichtsindex existiert.

Als Antwort schrieb ich folgendes:

def solution(A): 
    if len(A) == 0: #If we're working with an empty list, the method should give us an empty list message and terminate there 
     return "Empty list, no integers to work with" 
    else: 
     equi = [] 
     x = 0 
     length = len(A) 
     rightSum = [] 
     leftSum = [] 
     while x < length: 
      for i in A: 
       rightSum = A[1:i-1] 
       leftSum = A[i+1:length-2] 
       if sum(rightSum) == sum(leftSum): 
        equi.append(i) 
        return equi 
       else: 
        return -1 
      x += 1 
    pass 

solution([-1,3,-4,5,1,-6,2,1]) 

Wenn ich den Code eingehalten, hielt ich -1 für die Testliste bekommen, obwohl ich immer equi werden sollte [1,3,7].

Eine andere Frage, warum brauche ich das Schlüsselwort "pass" am Ende der Methode?

Ich sollte hinzufügen, ich bin extrem neu in Python-Codierung und Codierung im Allgemeinen. Jede Hilfe, die Sie zur Verfügung stellen können, wäre willkommen.

Answer 1

Denken Sie an die Art der Daten, die Ihre Funktion zurückgeben muss. Es ist eine Liste von Gleichgewichtsindizes.

Dies bedeutet, dass jede return Anweisung in Ihrer Funktion eine Liste zurückgeben muss. Niemals eine Nummer, niemals eine Zeichenfolge.

Für eine leere Liste gibt es keine möglichen Gleichgewichtsindizes; return [].

Wenn Sie einen Gleichgewichtsindex finden, fügen Sie ihn an Ihre equi Liste an, wie Sie richtig tun, und gehen Sie auf. Do not return aus der while Schleife. Die erste return-Anweisung beendet die Ausführung der Funktion.

Wenn Ihre Schleife endet, weil Sie alle Indizes durchsucht haben, enthält die Liste equi alle Gleichgewichtsindizes, die der Loop gefunden hat. Jetzt, nach der Schleife, ist es Zeit return equi statt der unbrauchbaren pass.

(Für Bonuspunkte können Sie die Summe der Liste einmal berechnen und beachten, dass das Verschieben eines Index nach rechts ein Element zur linken Summe addiert und dasselbe Element von der rechten Summe subtrahiert. Auf diese Weise haben Sie gewonnen muss sum jede Unterliste jedes Mal, die Leistung des Algorithmus wird linear statt quadratisch sein.)

Answer 2

Ihre Logik ist gesund, aber Sie stolpern über einige der Sprache Syntax.

Ich habe mein Bestes versucht, den Code zu helfen, während es zu kommentieren:

def solution(A): 
    if len(A) == 0: #If we're working with an empty list, the method should give us an empty list message and terminate there 
     return "Empty list, no integers to work with" 
    else: 
     equi = [] 
     x = 0 
     length = len(A) 
     rightSum = [] 
     leftSum = [] 
     # while x < length: (removed) 
     # When we do for i in A, we're already iterating over each element i of the list A. 
     # As such, there's no need for the while loop. 
     for i in A: 
      # You switched right and left sum; elements at the 'left' are at the beginning of the list 
      # I also switched the name of the lists to leftList and rightList, to be more descriptive 
      # (a list and a sum are different things) 
      # I switched the i that was in the indexes to x. i is the integer on the list we're iterating over; 
      # its position on the list, on the other hand, is being counted with x. 
      leftList = A[0:x] # Go from 0, since you want to count the first element. 
      # We could also ommit the first index and it would begin from the first element 
      rightList = A[x+1:] # If we ommit the second index, it'll go until the last element 
      if sum(leftList) == sum(rightList): 
       # I changed equi.append(i) to equi.append(x), because i is the value we're iterating over, while 
       # x is the counter (index) of the number being currently evaluated 
       equi.append(x) 
       # return equi (removed) 
       # We don't want to return here. When we call return, the function exits! 

      # What this would do is exit the function if the sum of the left list wasn't equal to the sum of the right. 
      # This isn't what we want, so we'll just remove this 
      # else: (removed) 
      #  return -1 (removed) 
      x += 1 

     # No pass needed; that's another thing entirely, just a nil instruction 

     # Now the loop is done, we have appended to equi all the equilibrium values. 
     # It's time to exit the function by returning the list of equi values. 
     # Since we must return -1 if no equilibrium indices exist, then we have to check for that as well 
     if len(equi) == 0: 
      return -1 
     else: 
      return equi 

sol = solution([-1, 3, -4, 5, 1, -6, 2, 1]) 
print(sol) # [1, 3, 7] 

Es gibt ein paar andere kleinere Dinge, die für die Lesbarkeit verbessert werden könnte (variable Namenskonventionen, mit enumerate), aber für die Aus Gründen der Kürze und Einfachheit habe ich nur hinzugefügt, was es funktioniert.