CodinGame_2023_09_07__18_53_43__logic_gates.cpp

#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include <algorithm>
#include <map>

using namespace std;

/**
 * Objectif
 * Une porte logique est un dispositif électronique qui met en œuvre une fonction booléenne, effectue une opération logique sur une ou plusieurs entrées binaires et produit une seule sortie binaire.
 *
 * Énoncé :
 * Étant donné n noms de signaux d'entrée et leurs données respectives, et m noms de signaux de sortie avec leur type de porte logique respective et deux noms de signaux d'entrée, fournissez les noms des signaux de sortie m et leurs données respectives, dans le même ordre que ceux fournis dans la description de l'entrée.
 *
 * Tous les types de portes auront toujours deux entrées et une sortie.
 * Toutes les données des signaux d'entrée ont toujours la même longueur.
 *
 * Les types de portes sont les suivants :
 * - AND : effectue une opération ET logique.
 * - OR : effectue une opération OU logique.
 * - XOR : effectue une opération OU exclusif logique.
 * - NAND : effectue une opération ET logique inversée.
 * - NOR : effectue une opération OU logique inversée.
 * - NXOR : effectue une opération OU exclusif logique inversée.
 *
 * Les signaux sont représentés par des caractères de soulignement et de tiret, un soulignement correspondant à un niveau bas (0, ou faux) et un tiret correspondant à un niveau élevé (1, ou vrai).
 **/

char boolToCharLogicGates(bool b) {
    return b ? '-' : '_';
}

bool charToBoolLogicGates(char c) {
    return c == '-' ? true : false;
}

enum class LogicOperator {
    AND,
    OR,
    XOR,
    NAND,
    NOR,
    NXOR
};

bool doOperator(LogicOperator op, bool a, bool b) {
    switch (op) {
        case LogicOperator::AND:
            return a && b;
        case LogicOperator::OR:
            return a || b;
        case LogicOperator::XOR:
            return a != b;
        case LogicOperator::NAND:
            return !(a && b);
        case LogicOperator::NOR:
            return !(a || b);
        case LogicOperator::NXOR:
            return a == b;
        default:
            return false;
    }
}

int main()
{
    int n;
    cin >> n; cin.ignore();
    int m;
    cin >> m; cin.ignore();

    // Traitement des données des signaux d'entrée
    map<string, string> inputSignals;
    for (int i = 0; i < n; i++) {
        string inputName;
        string inputSignal;
        cin >> inputName >> inputSignal; cin.ignore();
        inputSignals[inputName] = inputSignal;
    }

    // Traitement des signaux de sortie
    for (int i = 0; i < m; i++) {
        string outputName;
        string type;
        string inputName1;
        string inputName2;
        cin >> outputName >> type >> inputName1 >> inputName2; cin.ignore();

        // Récupère les données des signaux d'entrée
        string signalForm1 = inputSignals[inputName1];
        string signalForm2 = inputSignals[inputName2];
        int length = min(signalForm1.length(), signalForm2.length());

        // Détermine le type d'opérateur logique
        LogicOperator gateType;
        if (type == "AND") gateType = LogicOperator::AND;
        else if (type == "OR") gateType = LogicOperator::OR;
        else if (type == "XOR") gateType = LogicOperator::XOR;
        else if (type == "NAND") gateType = LogicOperator::NAND;
        else if (type == "NOR") gateType = LogicOperator::NOR;
        else if (type == "NXOR") gateType = LogicOperator::NXOR;

        // Calcule la sortie
        string outputSignal;
        for (int j = 0; j < length; j++) {
            bool signal1 = charToBoolLogicGates(signalForm1[j]);
            bool signal2 = charToBoolLogicGates(signalForm2[j]);
            bool result = doOperator(gateType, signal1, signal2);
            outputSignal += boolToCharLogicGates(result);
        }
        cout << outputName << " " << outputSignal << endl;
    }
    return EXIT_SUCCESS;
}