Python Liste Verständnis und Iterieren

Question

ich eine Datei mit einem ‚Raster‘ wie Design gegeben wurde, wie zum Beispiel:

5,20,13 
2,0,1,3,0 
1,2,1,2,1 
2,1,2,1,0 
0,2,0,2,2 
0,3,3,3,1 

Um einen Angriff Simulator zu machen. Und dass die erste Zeile n (Größe des Gitters), p (Prozent pro Quadrat verloren), k (Gesamtzahl, die es über die letzte Zeile zu gewinnen muss) darstellt.

Das Problem, das ich in lief habe, ist der Simulation Teil verstehe ich die Tatsache, wie die Code-Zeilen zu durchlaufen und die Mathematik zu tun, sie zu bearbeiten wie zB:

numAP = numAttackPokemon 
gridRules = gymData[0]  
gymGrid = gymData[1]  
n = gridRules[0]   
p = gridRules[1] 
k = gridRules[2]   
numPRC = float(numAP/n) 
numPRCR = [numPRC] * n  

for numRow in range(0, n): 
    gymGridNum = gymGrid[numRow] 
    aList = [] 
    for num in gymGridNum: 
     numDefSub = numPRCR[num] - gymGridNum[num] 

     if numDefSub <= 0: 
      print("You have failed, restart the program and try again!") 
      break 
     else: 
      aList.append(numDefSub) 

returns: 
    [18.0, 20.0, 19.0, 17.0, 20.0] 
    [19.0, 18.0, 19.0, 18.0, 19.0] 
    [18.0, 19.0, 18.0, 19.0, 20.0] 
    [20.0, 18.0, 20.0, 18.0, 18.0] 
    [20.0, 17.0, 17.0, 17.0, 19.0] 

, die in dem richtigen ist Sinn. Aber ich muss auch einen "zufälligen" Prozentverlust für jedes Rasterquadrat anwenden, was ich getan habe (nicht in dieser Codezeile, entfernt es, um dieses Problem vorher zu erkennen). Was ich versuche zu sagen ist, dass ich die erste Zeile dieses Codes editieren muss (mit dem Abzug der Anzahl und des prozentualen Verlustes), dann benutze diese Zeile für den Rest des Gitters, wiederhole die Mathematik noch einmal. Ich bin etwas verloren gegangen, wie ich eine Liste für jede Zeile im Raster behalten, bearbeiten und verwenden kann.

Eine korrekte Ausgabe wäre so etwas wie dieses, aber ohne den zufälligen prozentualen Verlust: (numPRC = 100)

[18.0, 20.0, 19.0, 17.0, 20.0] 
[17.0, 18.0, 18.0, 15.0, 19.0] 
[15.0, 17.0, 16.0, 14.0, 19.0] 
[15.0, 15.0, 16.0, 12.0, 17.0] 
[15.0, 12.0, 13.0, 9.0, 16.0] 

Ich habe wieder zu verwenden:

[18.0, 20.0, 19.0, 17.0, 20.0] 

Für den Rest die Zeilen, aber ich bin nicht sicher, wie man mit einer Aktualisierungsliste iteriert. Ich glaube, es ist einfach genug, aber mir fehlt ein kleines Detail.

Answer 1

Basierend auf den Kommentaren, ich glaube, was Sie brauchen so etwas wie diese:

attackers = [ numAttackPokemon/n ] * n 
lost_per_square = 1.00 - p/100.0 


for row in grid: 
    for col, cost in enumerate(row): 
     attackers[col] *= lost_per_square 
     attackers[col] -= cost 

Dies wird eine „Reihe“ von pokemon angreifen, mit der gleichen Anzahl in jeder Spalte bauen. Es wird dann über jede Zeile im Raster iterieren und für jede Zeile wird über jede Spalte iteriert, wobei die "Kosten" des Gitters von der entsprechenden Spalte in der Angreiferreihe abgezogen werden.

Zusätzlich subtrahiert es eine "Verluste pro Quadrat". Ich vermute, dass das damit gemeint ist, obwohl ich mir nicht sicher bin. Im Grunde, wenn p = 20, dann würden die Verluste pro Quadrat -20% sein, und so würde der Multiplikationsfaktor 1,0 - 0,20 = 0,80 sein.

Bitte beachten Sie: Dies gilt die Verluste pro Quadrat vor irgendwelchen Verlusten aufgrund von Gelände. Und es wendet jene Verluste sogar auf das erste Quadrat an. Sie können die Reihenfolge ändern und/oder die Verluste je nach Problemstellung auf das erste oder letzte Quadrat anwenden.

Answer 2

Darüber hinaus konnte Austin Hastings helfen, mein Problem zu lösen. Ich musste es für meine gewünschten Ausgaben bearbeiten. Der Code folgt unten:

numAP = numAttackPokemon # Number of Mutant Pokemon they wish to attack with 
gridRules = gymData[0] # Rules such as n,p,k 
gymGrid = gymData[1]  # Gym Array 
n = gridRules[0]   # Size of grid 
p = gridRules[1]   # Number of defending Pokemon 
k = gridRules[2]   # Number of War-Pokemon that must pass 

attPoke = [numAttackPokemon/n] * n # Number of Pokemon Per-Column-Row, Float value 
randPerc = np.random.randint(0, n) 
lossPerSquare = randPerc/100.0 

for row in gymGrid: 
    for col, cost in enumerate(row): 
     attPoke[col] -= cost 
     attPoke[col] = attPoke[col] - (attPoke[col] * lossPerSquare) 

Anmerkung: Die Variable 'p' fungiert als eine Zufallszahl zwischen 0 und n , war, die als Prozentsatz verwendet werden, lossPerSquare. Dann war das Endergebnis des gesamten angreifenden Pokémon (Angreifendes Pokémon - Kosten pro Quadrat) - (Angreifendes Pokémon * lossPerSquare). Auch die Kosten mussten vor dem Verlust des Prozentsatzes liegen, den ich vergessen hatte zu erwähnen.

Vielen Dank.