# Mastering JavaScript: Comparing Array Elements in a Game Scenario

Written on

## Chapter 1: Introduction to Array Comparisons

In this chapter, we will explore an intriguing problem involving the comparison of elements from two arrays. Picture yourself developing a game where two teams engage in battle. Each participant from one team faces off against a corresponding member of the opposing team. To determine the outcome of these duels, a JavaScript function is essential.

This function will help us analyze whether our team can withstand the onslaught based on the power levels of the soldiers represented in the arrays.

### Section 1.1: The Challenge: Surviving the Assault

To illustrate, we have two arrays that represent the power of each soldier. The goal is to return true if the defending team survives the attack, and false if they do not. Here are the conditions to consider:

- Each soldier assaults the opponent at the same index in their respective arrays.
- The one with the higher power value prevails.
- If both soldiers have equal power, they both fall.
- If one array is shorter, the soldier from the longer array automatically survives.
- The defending side must have more survivors than the attackers to win.
- If both sides have equal survivors, the team with the greater initial attack power wins. If both attack powers are equal, return true.

**Example Scenarios:**

attackers = [1, 3, 5, 7]; defenders = [2, 4, 6, 8];

// 0 survivors vs 4 survivors

// return true

attackers = [1, 3, 5, 7]; defenders = [2, 4];

// 2 survivors (16 damage) vs 2 survivors (6 damage)

// return false

attackers = [1, 3, 5, 7]; defenders = [2, 4, 0, 8];

// 1 survivor vs 3 survivors

// return true

### Section 1.2: Crafting the Solution

The solution is relatively straightforward. We can define a JavaScript function like this:

export const hasSurvived = (attackers, defenders) => {

let attackingPower = attackers.reduce((acc, val) => acc + val, 0);

let defendingPower = defenders.reduce((acc, val) => acc + val, 0);

let attackingSurvivors = 0;

let defendingSurvivors = 0;

for (let i = 0; i < Math.max(attackers.length, defenders.length); i++) {

if (i >= attackers.length) {

defendingSurvivors++;} else if (i >= defenders.length) {

attackingSurvivors++;} else if (attackers[i] > defenders[i]) {

attackingSurvivors++;} else if (defenders[i] > attackers[i]) {

defendingSurvivors++;}

}

return (

defendingSurvivors > attackingSurvivors ||

(defendingSurvivors === attackingSurvivors && defendingPower >= attackingPower) ||

(defendingSurvivors === attackingSurvivors && attackingPower === defendingPower)

);

};

This function first calculates the total attack power for both teams. It then iterates through the arrays, comparing values at each index. Depending on the comparisons, it increments the count of survivors for each side. Lastly, it returns true or false based on the conditions outlined.

However, the structure of this function feels cumbersome due to the series of conditional statements, making it less readable. Over time, I've realized that complex-looking functions often have room for refinement.

#### Subsection 1.2.1: Streamlining the Code

To enhance the code's elegance, we can filter through the arrays to identify the elements that satisfy our conditions. Here's a more refined approach:

let defendersAfterFight = defenders.filter((e, i) => 0 < e - attackers[i]);

let attackersAfterFight = attackers.filter((e, i) => 0 < e - defenders[i]);

Now, we can easily calculate the number of survivors:

const hasSurvived = (attackers, defenders) => {

let attackingPower = attackers.reduce((acc, val) => acc + val, 0);

let defendingPower = defenders.reduce((acc, val) => acc + val, 0);

let defendersSurvived = defenders.filter((d, i) => 0 < d - attackers[i]).length;

let attackersSurvived = attackers.filter((a, i) => 0 < a - defenders[i]).length;

return (

defendersSurvived > attackersSurvived ||

(defendersSurvived === attackersSurvived && defendingPower >= attackingPower)

);

};

If we desire to condense the function further, we can do so, but I caution against excessive complexity. Clear and understandable code is always preferable, as our future selves will appreciate the clarity.

const hasSurvived = (a, d) =>

d.filter((x, i) => 0 < x - a[i]).length >

a.filter((x, i) => 0 < x - d[i]).length ||(d.filter((x, i) => 0 < x - a[i]).length ===

a.filter((x, i) => 0 < x - d[i]).length &&

d.reduce((c, v) => c + v, 0) >= a.reduce((c, v) => c + v, 0));

Thanks for diving into this exploration of JavaScript array comparisons! Stay tuned for more insights in our upcoming articles.

The first video titled "Comparing values of two arrays in JavaScript" provides an in-depth look at how to effectively compare array elements and understand the logic behind it.

The second video, "Build A Text Adventure Game With JavaScript," demonstrates how to apply these concepts in a practical game development scenario.