Question

I want to understand how this can be solved in c++. Please send a screenshot also with your code so I can see how it is supposed to be formatted or indented.

Instructions:

Your program will read in a file of commands. There are three types of commands:

Warrior creates a new warrior with the specified name and strength. Battle causes a battle to occur between two warriors. Status lists all warriors, alive or dead, and their strengths.

A sample input file looks like:

"Warrior Jim 42

Warrior Lancelot 15

Warrior Arthur 15

Warrior Torvalds 20

Warrior Gates 8

Status

Battle Arthur Lancelot

Battle Jim Lancelot

Battle Torvalds Gates

Battle Gates Lancelot

Status"

The name of the input file will be "warriors.txt". Note that the commands do not have to appear in that order. The only requirement is that a Battle command cannot appear until the specified warriors have been seen.

The Status command displays how many warriors there, then displays each one with his strength. The Warrior command does not display anything. The Battle command displays one line to says who is fighting whom and a second line to report the results, as shown below.

The output (which would display on the screen) for this file should look like:

"There are: 5 warriors

Warrior: Jim, strength: 42

Warrior: Lancelot, strength: 15

Warrior: Arthur, strength: 15

Warrior: Torvalds, strength: 20

Warrior: Gates, strength: 8

Arthur battles Lancelot

Mutual Annihilation: Arthur and Lancelot die at each other's hands

Jim battles Lancelot

He's dead, Jim

Torvalds battles Gates

Torvalds defeats Gates

Gates battles Lancelot

Oh, NO! They're both dead! Yuck!

There are: 5 warriors

Warrior: Jim, strength: 42

Warrior: Lancelot, strength: 0

Warrior: Arthur, strength: 0

Warrior: Torvalds, strength: 12

Warrior: Gates, strength: 0"

For the sequence of commands, your output should looke exactly as shown above. Please don't exercise you creativity here. Use a struct. That means we do not want you to define classes or methods, or to use data hiding.

Make good use of functions. In this program, for example, when you determine that you are looking at a Warrior command then you should call a function to handle that command. Similarly with the other commands. Have useful comments explaining what each part of your code does. The code must be well formatted with good indentation. All structs, functions and variables should have good names. Function names should clearly identify what the function does. Follow the convention that structs begin with an uppercase letter, constants are all uppercase and functions and variables begin with a lowercase letter.

Each warrior starts out with a name and a certain amount of strength. Each time he fights, he loses some strength. (He gets to keep his name.) If his opponent is stronger than he is, then he loses all of his strength, in which case he is dead, or at the very least pretty useless as a fighter. Otherwise he loses as much strength as his opponent had. Of course, if he and his opponent had the same strength then they are both losers.

Even losers are allowed to pick a fight. It doesn't require having any strength in order to do battle with someone else. Not that you stand much of a chance of winning anything, but perhaps it's worth getting beaten (again) just to have those 15 seconds of fame.

The output, "He's dead, Jim", is because Jim is battling Lancelot but Lancelot, sadly, has already died. It is not meant as a phrase to be used whenever one of the participants is dead and the other is alive. Sure, in all such cases you would say "He's dead FILL_IN_THE_BLANK", where FILL_IN_THE_BLANK is the name of the person who is not dead.

Answer 1

First, we think about how we want to save the warriors. We start by creating a Warrior struct. This has the name, strength and the constructor for Warrior. Now we would like to have an array for adding all these warriors. We use a vector of Warriors to do this. Now over here I have also used an unordered_map to keep track of the index a warrior is saved in the array. Why? because in the battle commands we are given just the names of the warriors so to find these warriors in our array we would have to search it linearly. This is O(n) search. Using unordered_map we can do it in O(1) although we are using a little bit more space.

Next, we start by reading the file. We read the file line by line and tokenize each line. After tokenizing we check which command was given and the corresponding function is called.

The create_warrior function creates a new warrior, pushes it into our warrior vector and saves in which index the warrior is stored in the unordered_map. Note that we are using pass by reference to pass our vector in so changes made in the function to vector would reflect in our original vector in the main function.

Next, in the start_battle function, we get the indices of the warriors from the unordered_map then get the corresponding strength of these warriors from our array. We then apply the various conditional statements to check who wins and update their strengths accordingly.

Finally, in the get_status function, we simply iterate over our warrior's vector and print out the names and strengths of the warriors.

Source Code and screenshots given below:

Source code:

#include <iostream>
#include <cstring>
#include <fstream>
#include <string>
#include <vector>
#include <unordered_map>

using namespace std;

// Struct of warrior
struct Warrior {
   string name;
   int strength;
   // Constructor
   Warrior(string n, int s) {
       name = n;
       strength = s;
   }
};

// Function that tokenizes the given string and returns it as a vector
// Example: line = "Warrior Arthur 15"
// Return vector<string> = {"Warrior", "Arthur", "15"}
vector<string> tokenize_str(string line) {
   vector<string> v;
   string temp = "";
   for (int i = 0; i < line.size(); i++) {
       if (line[i] != ' ') {
           temp += line[i];
       } else {
           v.push_back(temp);
           temp = "";
       }
   }
   v.push_back(temp);
   return v;
}

// Function which creates a new warrior and pushes it into our warrior vector
// It also saves the index of the array in which the warrior has been added in the unordered_map
// This way we don't have to search for warriors during the battle command
void create_warrior(string name, string s, vector<Warrior> &warriors, unordered_map<string, int> &index) {
   // Converts string to int
   int strength = stoi(s);
   Warrior new_warrior = Warrior(name, strength);
   index[name] = warriors.size();
   warriors.push_back(new_warrior);
   return;
}

// Battle function
void start_battle(string name1, string name2, vector<Warrior> &warriors, unordered_map<string, int> &index) {
   // Get index of warriors in the vector using the unordered_map
   int i = index[name1];
   int j = index[name2];
   // Get the strengths of these warriors
   int s1 = warriors[i].strength;
   int s2 = warriors[j].strength;
   cout << name1 << " battles " << name2 << endl;
   if (s1 == 0 && s2 == 0) {
       cout << "Oh, NO! They're both dead! Yuck!" << endl;
   } else if (s2 == 0) {
       cout << "He's dead, " << name1 << endl;
   } else if (s1 == 0) {
       cout << "He's dead, " << name2 << endl;
   } else if (s1 > s2) {
       cout << name1 << " defeats " << name2 << endl;
       warriors[i].strength -= s2;
       warriors[j].strength = 0;
   } else if (s2 > s1) {
       cout << name2 << " defeats " << name1 << endl;
       warriors[j].strength -= s1;
       warriors[i].strength = 0;
   } else {
       cout << "Mutual Annihilation: " << name1 << " and " << name2 << " die at each other's hands" << endl;
       warriors[i].strength = 0;
       warriors[j].strength = 0;
   }
}

// Status function
// Prints the status using the warriors vector
void get_status(vector<Warrior> &warriors) {
   int num_warriors = warriors.size();
   cout << "There are: " << num_warriors << " warriors" << endl;
   for (int i = 0; i < num_warriors; i++) {
       cout << "Warrior: " << warriors[i].name << ", strength: " << warriors[i].strength << endl;
   }
   return;
}

int main() {
   // A vector which stores all our warriors
   vector<Warrior> warriors;

   // an unordered map to store the index in which the warrior is saved in the vector
   // This always us to get the warrior in O(1) time during battle
   // You have the option of not using this but then you would have to search the warrior vector every time
   // in the battle function
   unordered_map<string, int> index;
  
   // Open the warriors file
   ifstream myFile;
   myFile.open("warriors.txt");
  
   // Check if file has been opened properly
   if (!myFile) {
       cerr << "Unable to open file";
       // Exit the program if file did not open successfully
       exit(1);
   }

   // If file opened successfully
  
   // Variable which stores each line in the warriors.txt file
   string line;
   // Read the file till we reach the end
   while(getline(myFile,line)) {
       // Tokenize the line
       vector<string> tokens = tokenize_str(line);
      
       // The first word is the command
       string command = tokens[0];

       // Check what the command is and execute the corresponding function
       if (command == "Warrior") {
           create_warrior(tokens[1], tokens[2], warriors, index);
       } else if (command == "Battle") {
           start_battle(tokens[1], tokens[2], warriors, index);
       } else {
           get_status(warriors);
       }
   }
   return 0;
}