#include <iostream>
#include <string>
#include <vector>
#include <utility>
#include <chrono>
#include <thread>
#include <random>
#include <algorithm>

int main()
{
    std::mt19937 mt(static_cast<unsigned int>(std::chrono::high_resolution_clock::now().time_since_epoch().count()));

    auto age = std::uniform_int_distribution<int>(18, 60);

    std::vector<std::pair<std::string, int>> employees;

    employees.push_back(std::make_pair("Kim", 20));
    employees.push_back(std::make_pair("Joe", 20));
    employees.push_back(std::make_pair("Dave", age(mt)));
    employees.push_back(std::make_pair("Steve", age(mt)));
    employees.push_back(std::make_pair("Scott", age(mt)));
    employees.push_back(std::make_pair("Mark", age(mt)));
    employees.push_back(std::make_pair("Megan", age(mt)));
    employees.push_back(std::make_pair("Stephanie", age(mt)));
    employees.push_back(std::make_pair("Jim", age(mt)));
    employees.push_back(std::make_pair("Kylie", age(mt)));

    for (auto& i : employees)
    {
        std::cout << i.first << " - " << i.second << '\n';
    }

    std::cout << "\nLets remove  all people with the same age!, Pick an age to remove the person.\n";
    std::cout << '>';
    
    int input{ };

    std::cin >> input;

    auto compare = [&input](const auto& a)
        {
            return a.second == input;
        };

    auto it = std::find_if(employees.begin(), employees.end(), compare);

    int counter{ 0 };

    std::vector<std::string> removedPeople;

    while (it != employees.end())
    {
        removedPeople.push_back(it->first);
        employees.erase(it);
        ++counter;
        //We redefine find_if here because when we remove a name from the vector the iterator
        //pointing to that element is invalidated, so we need to re-validate it by callinf find_if again.
        it = std::find_if(employees.begin(), employees.end(), compare);
    }

    if(counter > 0)
    {
        std::cout << "Found " << counter << " instances of the number " << input << '\n';
    }
    else
    {
        std::cout << "No instances of the number " << input << " were found.\n";
    }

    std::cout << "\n\n";

    std::cout << "The following people were removed from the list\n\n";

    for (auto& i : removedPeople)
    {
        std::cout << i << "\n";
    }
}

#include <iostream>
#include <string>
#include <vector>
#include <utility>
#include <random>
#include <algorithm>

int main() {
	std::mt19937 mt(std::random_device {}());
	auto agedist { std::uniform_int_distribution<int>(18, 60) };

	std::vector<std::pair<std::string, int>> employees {{"Kim", 20}, { "Joe", 20 }, { "Dave", agedist(mt) },
		{ "Steve", agedist(mt) }, { "Scott", agedist(mt) }, { "Mark", agedist(mt) }, { "Megan", agedist(mt) },
		{ "Stephanie", agedist(mt) }, { "Jim", agedist(mt) }, { "Kylie", agedist(mt) }};

	for (const auto& [name, age] : employees)
		std::cout << name << " - " << age << '\n';

	int age { };
	std::vector<std::string> removedPeople;

	std::cout << "\nLets remove all people with the same age!\nPick an age to remove the person: ";
	std::cin >> age;

	const auto removed { std::erase_if(employees, [&](const auto& data) {
		const auto erase {data.second == age};

		if (erase)
			removedPeople.push_back(data.first);

		return erase;
	}) };

	if (removed > 0) {
		std::cout << "\nFound " << removed << " people of the age " << age << '\n';
		std::cout << "\nThe following people were removed from the list\n\n";

		for (const auto& r : removedPeople)
			std::cout << r << "\n";
	} else
		std::cout << "\nNo instances of the number " << age << " were found.\n";
}

#include <iostream>
#include <string>
#include <vector>
#include <utility>
#include <random>
#include <algorithm>

int main() {
	std::mt19937 mt(std::random_device {}());
	auto agedist { std::uniform_int_distribution<int>(18, 60) };

	std::vector<std::pair<std::string, int>> employees {{"Kim", 20}, { "Joe", 20 }, { "Dave", agedist(mt) },
		{ "Steve", agedist(mt) }, { "Scott", agedist(mt) }, { "Mark", agedist(mt) }, { "Megan", agedist(mt) },
		{ "Stephanie", agedist(mt) }, { "Jim", agedist(mt) }, { "Kylie", agedist(mt) }};

	for (const auto& [name, age] : employees)
		std::cout << name << " - " << age << '\n';

	int age { };
	std::vector<std::string> removedPeople;

	const auto compare { [&](const auto& data) {
		const auto erase { data.second == age };

		if (erase)
			removedPeople.push_back(data.first);

		return erase;
	} };

	std::cout << "\nLets remove all people with the same age!\nPick an age to remove the person: ";
	std::cin >> age;

	employees.erase(std::remove_if(employees.begin(), employees.end(), compare), employees.end());

	if (!removedPeople.empty()) {
		std::cout << "\nFound " << removedPeople.size() << " people of the age " << age << '\n';
		std::cout << "\nThe following people were removed from the list\n\n";

		for (const auto& r : removedPeople)
			std::cout << r << "\n";
	} else
		std::cout << "\nNo instances of the number " << age << " were found.\n";
}

#include <iostream>
#include <vector>
#include <string>
#include <utility>
#include <algorithm>
#include <iterator>

int main()
{
    using employee_t = std::pair<std::string,int> ;
    std::vector<employee_t> employees { { "kim", 20 },
                                        { "joe", 30 },
                                        { "dave", 20 },
                                        { "steve", 42 },
                                        { "scott", 20 },
                                        { "mark", 18 },
                                        { "megan", 24 } } ;

    const int target_age = 20 ;
    const auto partition_pt = std::partition( employees.begin(), employees.end(),
                                              []( const employee_t& e ) { return e.second != target_age ; } ) ;
    const std::vector<employee_t> removedPeople( std::make_move_iterator(partition_pt),
                                                 std::make_move_iterator(employees.end() ) ) ;
    employees.resize( std::size_t( partition_pt - employees.begin() ) ) ;

    std::cout << employees.size() << " | " << removedPeople.size() << '\n' ; // 4 | 3
}