Урок 6: Декомпозиция и отладка кода

#include <cassert>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#include <sstream>
#include <unordered_map>

using namespace std;

enum class QueryType {
    NewBus,
    BusesForStop,
    StopsForBus,
    AllBuses,
};

struct Query {
    QueryType type;
    string bus;
    string stop;
    vector<string> stops;
};

istream& operator>>(istream& is, Query& q) {

    string in_type;
    is >> in_type;

    if (in_type == "NEW_BUS"s) {
        q.type = QueryType::NewBus;
        int stop_num;
        is >> q.bus >> stop_num;
        string st;
        q.stops.clear();
        for (int i = 0; i < stop_num; ++i){
            is >> st;
            q.stops.push_back(st);
        }
    }
    else if (in_type == "BUSES_FOR_STOP"s) {
        q.type = QueryType::BusesForStop;
        is >> q.stop;
    }
    else if (in_type == "STOPS_FOR_BUS"s) {
        q.type = QueryType::StopsForBus;
        is >> q.bus;
    }
    else if (in_type == "ALL_BUSES"s) {
        q.type = QueryType::AllBuses;
    }

    return is;
}

struct BusesForStopResponse {

    vector <string> buses;
};

ostream& operator<<(ostream& os, const BusesForStopResponse& r) {

    if(r.buses.empty()) {
        os << "No bus"s;
    }
    else {
        for (auto &bus : r.buses) {
            os << bus << " "s;
        }
    }
    return os;
}

struct unorderedStops {
    string stop;
    vector <string> buses;
};

struct StopsForBusResponse {
    vector<unorderedStops> stop_buses;
};

ostream& operator<<(ostream& os, const StopsForBusResponse& r) {

    if(r.stop_buses.empty()) {
        os << "No stop"s;
    }
    else {
        bool first = true;
        for (auto stp_bss : r.stop_buses) {
            if (!first) {
                os << endl;
            }
            first = false;
            os << "Stop "s << stp_bss.stop << ": "s;

            if (stp_bss.buses.empty()) {
                os << "no interchange"s;
            }
            else {
                for (auto& bus : stp_bss.buses) {
                    os << bus << " "s;
                }
            }

        }
    }
    return os;
}

struct AllBusesResponse {
    map <string, vector<string>> bus_stops;
};

ostream& operator<<(ostream& os, const AllBusesResponse& r) {

    if (r.bus_stops.empty()) {
        os << "No buses"s;
    }
    else {
        for (auto& [bus, stops] : r.bus_stops) {
            os << "Bus "s << bus << ": "s;
            for (auto& stop : stops) {
                os << stop << " "s;
            }
            os << endl;
        }
    }
    return os;
}

bool operator==(const StopsForBusResponse& lhs, const StopsForBusResponse& rhs) {


    return lhs.stop_buses == rhs.stop_buses;
}
bool operator==(const unorderedStops& lhs, const unorderedStops& rhs) {


    return lhs.stop == rhs.stop && lhs.buses == rhs.buses;
}

bool operator==(const AllBusesResponse& lhs, const AllBusesResponse& rhs) {

    return lhs.bus_stops == rhs.bus_stops;
}
bool operator==(const BusesForStopResponse& lhs, const BusesForStopResponse& rhs) {

    return lhs.buses == rhs.buses;
}

class BusManager {
private:
map<string, vector<string>> buses_to_stops, stops_to_buses;

public:
    void AddBus(const string& bus, const vector<string>& stops) {

        for (auto& stop : stops) {
            stops_to_buses[stop].push_back(bus);
            buses_to_stops[bus].push_back(stop);
        }
    }

    BusesForStopResponse GetBusesForStop(const string& stop) const {

        BusesForStopResponse ret;
        if (stops_to_buses.count(stop) == 0) {
            return ret;
        }
        ret.buses = stops_to_buses.at(stop);
        return ret;
    }
/*
STOPS_FOR_BUS 272
    Stop Vnukovo: 32 32K 950
    Stop Moskovsky: no interchange
    Stop Rumyantsevo: no interchange
    Stop Troparyovo: 950
*/
    StopsForBusResponse GetStopsForBus(const string& bus) const {
        // StopsForBusResponse: map <string, vector<string>> stop_buses;
        StopsForBusResponse ret;
        if (buses_to_stops.count(bus) == 0) {
            return ret;
        }
        vector <string> dummy;
        for (const string& stop : buses_to_stops.at(bus)) {
            if (stops_to_buses.count(stop) > 0 && stops_to_buses.at(stop).size() == 1) {
                ret.stop_buses.push_back({stop, {}});
            }
            else {
                for (const string& other_bus : stops_to_buses.at(stop)) {
                    if(other_bus == bus) continue;
                    dummy.push_back(other_bus);
                }
                ret.stop_buses.push_back({stop, dummy});
                dummy.clear();
            }
        }

        return ret;
    }
/*
ALL_BUSES
    Bus 272: Vnukovo Moskovsky Rumyantsevo Troparyovo
    Bus 32: Tolstopaltsevo Marushkino Vnukovo
    Bus 32K: Tolstopaltsevo Marushkino Vnukovo Peredelkino Solntsevo Skolkovo
    Bus 950: Kokoshkino Marushkino Vnukovo Peredelkino Solntsevo Troparyovo
*/

    AllBusesResponse GetAllBuses() const {
        // AllBusesResponse: map <string, vector<string>> bus_stops;
        AllBusesResponse ret;
        if (buses_to_stops.empty()) return ret;
        for (const auto& [bus, stops] : buses_to_stops) {
            ret.bus_stops[bus] = stops;
        }
        return ret;
    }
};

void TestQueryInput() {
/*
    QueryType type;
    string bus;
    string stop;
    vector<string> stops;
*/

    istringstream input;
    // Метод str(строка) у istringstream позволяет задать содержимое, которое будет считываться из istringstream
    input.str("NEW_BUS 32 3 Tolstopaltsevo Marushkino Vnukovo"s);
    Query q;
    input >> q;
    assert(q.type == QueryType::NewBus);
    assert(q.bus == "32"s);
    vector <string> st = {"Tolstopaltsevo"s, "Marushkino"s, "Vnukovo"s};
    assert(q.stops == st);
}

void BusManagerTest() {

    BusManager bm;
    AllBusesResponse dummy;
    BusesForStopResponse dummy2;
    // ALL_BUSES
    assert(bm.GetAllBuses() == dummy);
    // BUSES_FOR_STOP Marushkino
    assert(bm.GetBusesForStop("Marushkino"s) == dummy2);
    // STOPS_FOR_BUS 32K
    StopsForBusResponse dummy3;
    assert(bm.GetStopsForBus("32K"s) == dummy3);
    // NEW_BUS 32 3 Tolstopaltsevo Marushkino Vnukovo
    bm.AddBus("32"s, {"Tolstopaltsevo"s, "Marushkino"s, "Vnukovo"s});
    // NEW_BUS 32K 6 Tolstopaltsevo Marushkino Vnukovo Peredelkino Solntsevo Skolkovo
    bm.AddBus("32K"s, {"Tolstopaltsevo"s, "Marushkino"s, "Vnukovo"s, "Peredelkino"s, "Solntsevo"s, "Skolkovo"s});
    // BUSES_FOR_STOP Vnukovo
    BusesForStopResponse dummy4;
    dummy4.buses = {"32"s, "32K"s};
    assert(bm.GetBusesForStop("Vnukovo"s) == dummy4);
    // NEW_BUS 950 6 Kokoshkino Marushkino Vnukovo Peredelkino Solntsevo Troparyovo
    bm.AddBus("950"s, {"Kokoshkino"s, "Marushkino"s, "Vnukovo"s, "Peredelkino"s, "Solntsevo"s, "Troparyovo"s});
    // NEW_BUS 272 4 Vnukovo Moskovsky Rumyantsevo Troparyovo
    bm.AddBus("272"s, {"Vnukovo"s, "Moskovsky"s, "Rumyantsevo"s, "Troparyovo"s});
    // STOPS_FOR_BUS 272
    dummy3.stop_buses = {{"Vnukovo"s, {"32"s, "32K"s, "950"s}}, {"Moskovsky"s, {}}, {"Rumyantsevo"s, {}}, {"Troparyovo"s, {"950"s}}};
    StopsForBusResponse dummy_left;
    dummy_left = bm.GetStopsForBus("272"s);
        // cout << dummy_left << endl;
        // cout << dummy3 << endl;
    assert(dummy_left == dummy3);
    // ALL_BUSES
    dummy.bus_stops = {{"272"s, {"Vnukovo"s, "Moskovsky"s, "Rumyantsevo"s, "Troparyovo"s}}, {"32"s, {"Tolstopaltsevo"s, "Marushkino"s, "Vnukovo"s}}, {"32K"s, {"Tolstopaltsevo"s, "Marushkino"s, "Vnukovo"s, "Peredelkino"s, "Solntsevo"s, "Skolkovo"s}}, {"950"s, {"Kokoshkino"s, "Marushkino"s, "Vnukovo"s, "Peredelkino"s, "Solntsevo"s, "Troparyovo"s}}};
    assert(bm.GetAllBuses() == dummy);

}

// Реализуйте функции и классы, объявленные выше, чтобы эта функция main
// решала задачу "Автобусные остановки"

int main() {
    int query_count;
    Query q;

    TestQueryInput();
    BusManagerTest();

    cin >> query_count;

    BusManager bm;
    for (int i = 0; i < query_count; ++i) {
        cin >> q;
        switch (q.type) {
            case QueryType::NewBus:
                bm.AddBus(q.bus, q.stops);
                break;
            case QueryType::BusesForStop:
                cout << bm.GetBusesForStop(q.stop) << endl;
                break;
            case QueryType::StopsForBus:
                cout << bm.GetStopsForBus(q.bus) << endl;
                break;
            case QueryType::AllBuses:
                cout << bm.GetAllBuses() << endl;
                break;
        }
    }
}