How to delete element to compare in two-dimensional structure - c++

Question

I was given an assignment in which the head of a top-secret organization, collecting statistics on retired agents
There are several secret agencies that employ spies. The time has come for the agencies to retire their employees
The given task:
The organization itself consists of 2 structures.
Agency which includes string-title, int-min_mission, int-agent_count and Spy* agents
Spy with the values name, string-speciality, int-completed_missions and bool-is_private.
I would like to point out that spies have only 3 specialty categories ("Diplomacy", "SpecOps", "DarkMistery")
Job Purpose: It is necessary to find an agency in which the maximum number of agents have been released.
In order to send them to resign the agency must check a few punuts, after surpassing which, its release from the position is accepted.
These rules are as follows:
His number of missions completed must exceed the minimum that his agency has set. If it is less, the agent cannot release him.
If the agent's speciality is "SpecOps", his minimum number of missions is 2 less than the others.
If an agent's speciality is "DarkMistery", his minimum number of missions is twice that of the others.
If the agent is Private, (that is, if the logical type is_private is == 1), then the agent will never be released
The input to test:
3
"For Angency - 1'st is Agency's name, 2'nd is min_number limit and 3'rd is number of agents" //
"For spies - 1'st is name, 2'nd is his\her speciality and 3'rd is completed missions"
BloodDragonfly 5 6
Jagternaut Diplomacy 7 0
Ditablo DarkMistery 6 0
Sartuman Diplomacy 3 1
Coltosus SpecOps 1 0
Samtanta DarkMistery 11 0
Tantos SpecOps 4 1
GoldenNose 6 4
Smith SpecOps 8 1
Smity DarkMistery 11 0
Smitens Diplomacy 5 0
Smaut DarkMistery 16 0
Lucaduca 10 5
Mario SpecOps 4 0
Puerrio Diplomacy 9 0
Luchio Diplomacy 11 1
Julietio Diplomacy 14 1
Bob DarkMistery 35 1
The value that should be displayed on the monitor OR Output:
Lucaduca
In short, I wrote a command that sorts out which agents can be released.
But I have forgotten how to remove the agents in the array that did pass the check, so that the size of the array changes.
(ignore the variable -> sum)
Here is my code.
#include "iostream"
#include "string"
using namespace std;
struct Spy { //The Spy structure
string name;
string speciality;
int missions;
bool is_private;
};
struct Agency { //The agency structure
string title;
int min_missions;
int agentCount;
Spy* agnt;
};
istream& operator >> (istream& is, Spy& sp) { //The operator to enter the values of spy
is >> sp.name >> sp.speciality >> sp.missions >> sp.is_private;
return is;
}
istream& operator >> (istream& is, Agency& agc) {//To enter the values of Agency
is >> agc.title >> agc.min_missions >> agc.agentCount;
return is;
}
int main() {
int N; cout << "Enter the number of agencies: \n";
cin >> N; //
Agency* agc = new Agency[N];
for (int i = 0; i < N; ++i) { //Creating a loop for the Agency struct, which would store the values of an individual agency
cin >> agc[i];
agc[i].agnt = new Spy[agc[i].agentCount];
for (int j = 0; j < agc[i].agentCount; ++j) { //This is for the struct Spy that will be stored inside the agentCount
cin >> agc[i].agnt[j];
}
}
for (int i = 0; i < N; ++i) {
int sum = 0;
int count = 0;
for (int j = 0; j < agc[i].agentCount; ++j) {
if (agc[i].agnt[j].is_private) { //Сonditional operator to check whether the agent is private or not
continue;
}
else {
if (agc[i].agnt[j].speciality == "DarkMistery") {//To check the speciality of agent
count = (agc[i].min_missions * 2);//If a spy's specialization is DarkMistery,
// he will get double the minimum number of missions than others
}
else if (agc[i].agnt[j].speciality == "SpecOps") {//If a spy's specialization is SpecOps,
count = (agc[i].min_missions - 2); //he/she will get 2 fewer mission than the others
}
else { //f a spy's specialization belongs to the third category
//Nothing will change for him/her
count = agc[i].min_missions;
}
if (agc[i].agnt[j].missions > count) {
sum++;
} else {
continue;
}
}
}
}
}
I tried to identify, through sum, the agency with the maximum number of non-exempt agents. But it will update every time it passes through the next agency.
I tried to use the delete command to delete the spy value, but I don't know how to use it on two-dimensional structures
I expect to see a change in the array agc[i].agentCount
so that it changes its size is dynamic if it is appropriate for this code of course.

Answer 1

If you only want to keep track of the number of agents an agency should release, you are almost done:
You could use a map from agency names to number of agents to be released.
Then, in your last two nested loops:
Before the inner loop, you reset a counter of agents to be released.
With each iteration of that inner loop, you update that counter.
After the inner loop, you insert a new element in the map, namely the name of the agency and the number of agents to be released.
The code below does that, although I'm afraid to say that the output is different than the expected (BloodDragonfly instead of Lucaduca). That may have to do with the input data or with the algorithm to decide if an agent has to be released.
[Demo]
using map_of_agents_to_be_released_per_agency_t = std::unordered_map<std::string, int>;
map_of_agents_to_be_released_per_agency_t agents_to_be_released{};
for (int i = 0; i < no_of_agencies; ++i) {
auto& agency{ agencies[i] };
int no_of_agents_to_be_released = 0;
for (int j = 0; j < agency.agent_count; ++j) {
auto& agent{ agency.agents[j] };
if (not agent.is_private) {
if (agent.speciality == "DarkMistery") {
if (agent.missions > agency.min_missions * 2) {
no_of_agents_to_be_released++;
}
} else if (agent.speciality == "SpecOps") {
if (agent.missions > agency.min_missions - 2) {
no_of_agents_to_be_released++;
}
} else if (agent.speciality == "Diplomacy") {
if (agent.missions > agency.min_missions) {
no_of_agents_to_be_released++;
}
}
}
}
agents_to_be_released.insert({agency.title, no_of_agents_to_be_released});
}
fmt::print("Agents to be released: {}\n", agents_to_be_released);
fmt::print("Agency with more agents to be released: {}\n",
std::ranges::max_element(
agents_to_be_released,
std::less<>{},
&map_of_agents_to_be_released_per_agency_t::value_type::second
)->first);
// Outputs:
//
// Agents to be released: {"Lucaduca": 0, "GoldenNose": 1, "BloodDragonfly": 2}
// Agency with more agents to be released: BloodDragonfly