## DEV Community is a community of 662,276 amazing developers

We're a place where coders share, stay up-to-date and grow their careers.

# Daily Challenge #170 - Pokemon Damage Calculator dev.to staff
The hardworking team behind dev.to ❤️

### Setup

For this challenge, you'll be thrown into a Pokemon battle! Calculate the damage that a particular move would do using the following formula:

`total damage` = `base damage` * (`attack` / `defense`) * `effectiveness`

`base damage` = the original power of the attack
`attack` = your attack stat
`defense` = the opponent's defense stat
`effectiveness` = the effectiveness of the attack based on the type matchup

Attacks can be `super effective`, `neutral`, or `not very effective` depending on the matchup.

• `super effective` : 2x damage
• `neutral`: 1x damage
• `not very effective`: 0.5x damage

To prevent the challenge from being too tedious, you'll only deal with four types: fire, water, grass, and electric. Here are the matchups:

```fire > grass
fire < water
fire = electric
water < grass
water < electric
grass = electric
**Any type against itself is not very effective
```

Overall, the function you implement must take in:

• the opponent's type
• attack power
• the opponent's defense

... and must output the `total damage` of the attack.

### Tests

What are the `total damage` outputs of these attacks?

1. "grass", "electric", 57, 19
2. "grass", "water", 40, 40
3. "grass", "fire", 35, 5
4. "fire", "electric", 10, 2

Good luck!

This challenge comes from yaphi1 on CodeWars. Thank you to CodeWars, who has licensed redistribution of this challenge under the 2-Clause BSD License!

Want to propose a challenge idea for a future post? Email yo+challenge@dev.to with your suggestions!

## Discussion (5) Kyle Jones • Edited

As there's no mention of the value, I set the base damage to 50 in each scenario.

### Code

``````def compare_attack_types(first_type, second_type):
if first_type == "fire":
if second_type == "grass":
return 2
if second_type == "water":
return 0.5
if first_type == "grass":
if second_type == "fire":
return 0.5
if second_type == "water":
return 2
if first_type == "electric":
if second_type == "water":
return 2
if first_type == "water":
if second_type == "fire":
return 2
if second_type == "grass":
return 0.5
return 1

def calculate_damage(base_damage, own_type, opponent_type, attack, defense):
return base_damage * (attack / defense) * compare_attack_types(own_type, opponent_type)

print(calculate_damage(50, "grass", "electric", 57, 19))
print(calculate_damage(50, "grass", "water", 40, 40))
print(calculate_damage(50, "grass", "fire", 35, 5))
print(calculate_damage(50, "fire", "electric", 10, 2))
``````

### Results

150
100
175
250 lusen / they / them 🏳️‍🌈🥑

Ok cool. I'll use 50, too.

Here'a another Python implementation:

``````SUPER_EFFECTIVE = 'super_effective'
NEUTRAL = 'neutral'
NOT_VERY_EFFECTIVE = 'not_very_effective'

EFFECTIVENESS_MULTIPLIER = {
SUPER_EFFECTIVE: 2,
NEUTRAL: 1,
NOT_VERY_EFFECTIVE: .5}

FIRE = 'fire'
GRASS = 'grass'
WATER = 'water'
ELECTRIC = 'electric'

ATTACK_ON_DEFENSE_EFFECTIVENESS = {
FIRE: {
FIRE: NOT_VERY_EFFECTIVE,
GRASS: SUPER_EFFECTIVE,
WATER: NOT_VERY_EFFECTIVE,
ELECTRIC: NEUTRAL,
},
GRASS: {
GRASS: NOT_VERY_EFFECTIVE,
WATER: SUPER_EFFECTIVE,
ELECTRIC: NEUTRAL,
FIRE: NOT_VERY_EFFECTIVE
},
WATER: {
WATER: NOT_VERY_EFFECTIVE,
GRASS: NOT_VERY_EFFECTIVE,
ELECTRIC: NOT_VERY_EFFECTIVE,
FIRE: SUPER_EFFECTIVE
},
ELECTRIC: {
ELECTRIC: NOT_VERY_EFFECTIVE,
GRASS: NEUTRAL,
WATER: SUPER_EFFECTIVE,
FIRE: SUPER_EFFECTIVE
}
}

def _calculate_effectiveness(attack_type, defense_type):
effectiveness_name = ATTACK_ON_DEFENSE_EFFECTIVENESS[attack_type][defense_type]
return EFFECTIVENESS_MULTIPLIER[effectiveness_name]

def _total_damage(base_damage, attack, defense, effectiveness):
return base_damage * (attack / defense) * effectiveness

def calculate_damage(base_damage, attack_type, defense_type, attack_power, defense_power):
return _total_damage(
base_damage,
attack_power,
defense_power,
_calculate_effectiveness(attack_type, defense_type)
)

print(calculate_damage(50, "grass", "electric", 57, 19))
print(calculate_damage(50, "grass", "water", 40, 40))
print(calculate_damage(50, "grass", "fire", 35, 5))
print(calculate_damage(50, "fire", "electric", 10, 2))

`````` Ilyes Chouia • Edited

PHP ::)

``````class Pokemon {

public \$baseDamage;
public \$own;
public \$opponent;
public \$attack;
public \$defense;

public function __construct (\$baseDamage, \$own, \$opponent, \$attack, \$defense)
{
\$this->baseDamage = \$baseDamage;
\$this->attack = \$attack;
\$this->defense = \$defense;
\$this->own = \$own;
\$this->opponent = \$opponent;
}

public function compareAttackTypes ()
{
switch(\$this->own){
case "fire":
if(\$this->opponent == "grass"){ return 2; }
if(\$this->opponent == "water"){ return 0.5; }
case "grass":
if(\$this->opponent == "fire"){ return 0.5; }
if(\$this->opponent == "water"){ return 2; }
case "electric":
if(\$this->opponent == "water"){ return 2; }
case "water":
if(\$this->opponent == "fire"){ return 2; }
if(\$this->opponent == "grass"){ return 0.5; }
default:
return 1;
}
}

public function calculateDamage ()
{
return \$this->baseDamage * (\$this->attack / \$this->defense) * \$this->compareAttackTypes();
}
}

\$pk = new Pokemon(50, "grass", "water", 40, 40); // result : 100
echo \$pk->calculateDamage();
`````` Haskell solution. The last argument of the function is the base damage. I'm also changing the function to accept an ADT Type type instead of strings for the Pokémon type.

``````data Type = Grass | Fire | Water | Electric deriving (Eq)

effect :: Type -> Type -> Double
effect Fire Grass = 2
effect Water Fire = 2
effect Fire Electric = 1
effect Grass Water = 2
effect Electric Water = 2
effect Grass Electric = 1
effect a b
| a == b    = 1
| otherwise = recip \$ effect b a

totalDamage :: Type -> Type -> Double -> Double -> Double -> Double
totalDamage t1 t2 att def = (*) \$ att / def * effect t1 t2
`````` SavagePixie • Edited

Pattern matching for the win!

I didn't know what to do with the `base_power` thing, so I left it as one.

Elixir

``````defmodule Pokemon do
def calculate(effectiveness, attack, defence) do
1 * (attack / defence) * effectiveness
end

def total_damage(a, a, att, def), do: calculate(0.5, att, def)
def total_damage("electric", "water", att, def), do: calculate(2, att, def)
def total_damage("fire", "grass", att, def), do: calculate(2, att, def)
def total_damage("fire", "water", att, def), do: calculate(0.5, att, def)
def total_damage("grass", "fire", att, def), do: calculate(0.5, att, def)
def total_damage("grass", "water", att, def), do: calculate(2, att, def)
def total_damage("water", "electric", att, def), do: calculate(0.5, att, def)
def total_damage("water", "fire", att, def), do: calculate(2, att, def)
def total_damage("water", "grass", att, def), do: calculate(0.5, att, def)
def total_damage(_, _, att, def), do: calculate(1, att, def)
end
``````