Inhalt
Die Fakten:
| Plattform: | codewars.com |
| Name: | Survive the attack |
| Level: | 7 kyu |
| Sprache: | TypeScript |
Beschreibung:
Given two Arrays in which values are the power of each soldier, return true if you survive the attack or false if you perish.
CONDITIONS
- Each soldier attacks the opposing soldier in the same index of the array. The survivor is the number with the highest value.
- If the value is the same they both perish
- If one of the values is empty(different array lengths) the non-empty value soldier survives.
- To survive the defending side must have more survivors than the attacking side.
- In case there are the same number of survivors in both sides, the winner is the team with the highest initial attack power. If the total attack power of both sides is the same return true.
- The initial attack power is the sum of all the values in each array.
EXAMPLES
attackers=[ 1, 3, 5, 7 ] defenders=[ 2, 4, 6, 8 ]
//0 survivors 4 survivors
//return true
attackers=[ 1, 3, 5, 7 ] defenders=[ 2, 4 ]
//2 survivors (16 damage) 2 survivors (6 damage)
//return false
attackers=[ 1, 3, 5, 7 ] defenders=[ 2, 4, 0, 8 ]
//1 survivors 3 survivors
//return true
Quelle: codewars.com
Lösung
Pseudo-Code
Wie immer gibt's reichlich Varianten, hier ist eine meiner.
Erst die Lösungsschritte in Pseudo-Code. Los geht’s:
Lösungsschritte
Schritt 1
Wir brauchen einen Loop, in dem wir die Zahlen beider Arrays vergleichen können.
Schritt 2
Da die Arrays unterschiedliche Längen haben können, müssen wir durchs längere Array loopen.
Schritt 3
Wenn die Zahl des Angreifer größer ist, erhöhen wir einen Zähler für die Überlebenden Angreifer.
Schritt 4
Wenn die Zahl des Verteidigers größer ist, erhöhen wir einen Zähler für die Überlebenden Verteidiger.
Schritt 5
Nach dem Loop prüfen wir, ob beide Zähler gleich sind.
Schritt 6
Wenn ja, vergleichen wir die Summen der ursprünglichen Arrays und geben aus, ob die Summe des Verteidiger-Arrays größer oder gleich dem Angreifer-Arrays ist.
Schritt 7
Wenn nicht, geben wir aus, ob mehr Verteidiger überlebt haben.
Code
Geil. Übersetzen wir unseren Pseudo-Code in TypeScript:
Lösungsschritte
Meine erste Zeile:
export function hasSurvived(attackers: number[], defenders: number[]): boolean {
Legen wir die Länge des Loops fest:
const loopLength = Math.max(attackers.length, defenders.length);
Jetzt der For-Loop:
for (let i = 0; i < loopLength; i++) {
Wenn ein Angreifer nicht existiert, legen wir seinen Wert auf 0 fest und speichern seinen Wert in einer Variablen. Gleiches für die Verteidiger:
const currAttacker = attackers[i] || 0;
const currDefender = defenders[i] || 0;
Jetzt ermitteln wir den aktuellen Überlebenden und speichern die Anzahl in einem Zähler (die Zähler oben noch initialisieren!):
if (currAttacker > currDefender) numAttackSurvivors++;
if (currDefender > currAttacker) numDefendSurvivors++;
}
Nach dem Loop prüfen wir, ob die Anzahl der Überlebenden gleich sind:
if (numAttackSurvivors === numDefendSurvivors) {
Wenn ja, bilden wir die Summen der Ursprungs-Arrays und geben aus, ob die Verteidiger-Power größer oder gleich der Angreifer-Power ist:
const attackersInitialPower = attackers.reduce((sum, num) => sum + num, 0);
const defendersInitialPower = defenders.reduce((sum, num) => sum + num, 0);
return defendersInitialPower >= attackersInitialPower;
}
Wenn nein, geben wir aus, ob die Anzahl der überlebenden Verteidiger größer als die Anzahl der überlebenden Angreifer ist:
return numDefendSurvivors > numAttackSurvivors;
Voilá! 💪
Komplettlösung
export function hasSurvived(attackers: number[], defenders: number[]): boolean {
let numAttackSurvivors = 0;
let numDefendSurvivors = 0;
const loopLength = Math.max(attackers.length, defenders.length);
for (let i = 0; i < loopLength; i++) {
const currAttacker = attackers[i] || 0;
const currDefender = defenders[i] || 0;
if (currAttacker > currDefender) numAttackSurvivors++;
if (currDefender > currAttacker) numDefendSurvivors++;
}
if (numAttackSurvivors === numDefendSurvivors) {
const attackersInitialPower = attackers.reduce((sum, num) => sum + num, 0);
const defendersInitialPower = defenders.reduce((sum, num) => sum + num, 0);
return defendersInitialPower >= attackersInitialPower;
}
return numDefendSurvivors > numAttackSurvivors;
}