Bamba hat geschrieben:ich habe das einfach in diese vier Listen aufgeteilt, warum weiß ich auch nicht. Eigentlich soll es ungefähr so ablaufen: Das Element a der 1. LIste wird um das Element a der 4. Liste verringert, genauso bei der 3. und 2. Liste.
Wenn ich die Funkltion das erste mal laufen lasse, erhalte ich folgende Ausgabe:
[2, 3, 3] [1, 1, 1] [3, 4, 4] [1, 1, 1]
[2, 2, 3] [1, 1, 1] [3, 3, 4] [1, 1, 1]
[2, 2, 2] [1, 1, 1] [3, 3, 3] [1, 1, 1]
Na dann habe ich schonmal die Kampfregeln falsch interpretiert.
Danach:
[1, 2, 2] [1, 1, 1] [2, 3, 3] [1, 1, 1]
[1, 1, 2] [1, 1, 1] [2, 2, 3] [1, 1, 1]
[1, 1, 1] [1, 1, 1] [2, 2, 2] [1, 1, 1] was auch noch richtig ist
aber danach:
[1, 1] [1, 1, 1] [1, 2, 2] [1, 1, 1]
[1] [1, 1, 1] [1, 1, 2] [1, 1, 1]
Hier sollte LIste 1 eigentlich komplett leer sein, während Liste 3 nur noch 1sen haben dürfte.
Und wenn ich dann noch laufen lasse, erhatle ich IndexError: list index out of range. WAs heißt, dass meine if-Abfrage vollkommen falsch ist, aber ich kapier das irgendwie nicht.
Das sie nicht leer ist liegt daran das Du das letzte Element mit -1 nicht erwischt:
Code: Alles auswählen
In [30]: a = range(5)
In [31]: a
Out[31]: [0, 1, 2, 3, 4]
In [32]: a[0:-1]
Out[32]: [0, 1, 2, 3]
In [33]: del a[0:-1]
In [34]: a
Out[34]: [4]
Wenn Du die Grenzen einfach weglässt, dann wird die gesamte Liste geleert:
Code: Alles auswählen
In [35]: a = range(5)
In [36]: a
Out[36]: [0, 1, 2, 3, 4]
In [37]: del a[:]
In [38]: a
Out[38]: []
Aber kommen wir nochmal auf den Anfang zurück: Was *soll* die ``while``-Bedingung prüfen und was prüft sie in Wirklichkeit?
Und nochmal: wenn Du ein Element in einer Liste löschst, dann rücken alle nachfolgenden eins nach vorne. Wenn Du `a` erhöhst, dann hast Du einen Kämpfer übersprungen, der ja jetzt an die Stelle des verstorbenen getreten ist.
Und was macht Deine Funktion wenn das zweite Team komplett tot ist? Das sieht auch nach `IndexError` aus.
Wenn Du immer den n. Kämpfer aus Team A gegen den n. Kämpfer aus Team B antreten lassen willst, dann ist die sauberste Methode wohl die jeweiligen Partner mit der `zip()` Funktion zu paaren. Diesmal getestet:
Code: Alles auswählen
class Fighter(object):
def __init__(self, life, damage):
self.life = life
self.damage = damage
def __repr__(self):
return 'Fighter(%r, %r)' % (self.life, self.damage)
def is_dead(self):
return self.life <= 0
def filter_dead_fighters(fighters):
return [fighter for fighter in fighters if not fighter.is_dead()]
def fight(team_a, team_b):
for fighter_a, fighter_b in zip(team_a, team_b):
fighter_a.life -= fighter_b.damage
fighter_b.life -= fighter_a.damage
return map(filter_dead_fighters, (team_a, team_b))
def main():
team_a = [Fighter(life, damage)
for (life, damage) in ((2,1), (3, 1), (3, 1))]
team_b = [Fighter(life, damage)
for (life, damage) in ((3,1), (4, 1), (4, 1))]
while team_a and team_b:
print 'A:', team_a
print 'B:', team_b
print '-' * 20
team_a, team_b = fight(team_a, team_b)
if team_a:
winner_name = 'A'
winner_team = team_a
else:
winner_name = 'B'
winner_team = team_b
print 'Winner is %s: %r' % (winner_name, winner_team)
if __name__ == '__main__':
main()
Ausgabe ist:
Code: Alles auswählen
A: [Fighter(2, 1), Fighter(3, 1), Fighter(3, 1)]
B: [Fighter(3, 1), Fighter(4, 1), Fighter(4, 1)]
--------------------
A: [Fighter(1, 1), Fighter(2, 1), Fighter(2, 1)]
B: [Fighter(2, 1), Fighter(3, 1), Fighter(3, 1)]
--------------------
A: [Fighter(1, 1), Fighter(1, 1)]
B: [Fighter(1, 1), Fighter(2, 1), Fighter(2, 1)]
--------------------
Winner is B: [Fighter(1, 1), Fighter(2, 1)]