## DEV Community is a community of 765,064 amazing developers

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

dev.to staff

Posted on

# Daily Challenge #170 - Pokemon Damage Calculator

### 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 on

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 on

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();
``````
Craig McIlwrath

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 on

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
``````