CodinGame_2023_09_07__18_45_03__logic_gates.java

import java.util.Scanner;
import java.util.Map;
import java.util.HashMap;

/**
 * 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).
 *
 * Entrée :
 * Ligne 1 : le nombre n de signaux d'entrée.
 * Ligne 2 : le nombre m de signaux de sortie.
 * Les n lignes suivantes : deux chaînes de caractères séparées par un espace : le nom du signal d'entrée, puis la forme du signal.
 * Les m lignes suivantes : quatre chaînes de caractères séparées par un espace : le nom du signal de sortie, le type de porte logique, le nom du premier signal d'entrée, puis le nom du deuxième signal d'entrée.
 *
 * Sortie :
 * m lignes : deux chaînes de caractères séparées par un espace : le nom du signal de sortie, puis la forme du signal.
 *
 * Contraintes :
 * 1 ≤ n ≤ 4
 * 1 ≤ m ≤ 16
 *
 * Exemple :
 * Entrée
 * 2
 * 3
 * A __---___---___---___---___
 * B ____---___---___---___---_
 * C AND A B
 * D OR A B
 * E XOR A B
 *
 * Sortie
 * C ____-_____-_____-_____-___
 * D __-----_-----_-----_-----_
 * E __--_--_--_--_--_--_--_--_
 */
class Solution {

    public static void main(String args[]) {
        final Scanner in = new Scanner(System.in);
        final int n = in.nextInt();
        final int m = in.nextInt();
        final Map<String, String> hm = new HashMap<String, String>();
        for (int i = 0; i < n; i++) {
            String inputName = in.next();
            String inputSignal = in.next();
            hm.put(inputName, inputSignal);
        }
        String outputName = null;
        String type = null;
        String inputName1 = null;
        String inputName2 = null;
        LogicOperator lo = null;
        String signalForm1 = null;
        String signalForm2 = null;
        int length = 0;
        Character signal1Char = null;
        Character signal2Char = null;
        Boolean signal1Bool = null;
        Boolean signal2Bool = null;
        Character result = null;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < m; i++) {
            outputName = in.next();
            type = in.next();
            inputName1 = in.next();
            inputName2 = in.next();
            lo = LogicOperator.getLogicOperatorByOperationName(type);
            signalForm1 = hm.get(inputName1);
            signalForm2 = hm.get(inputName2);
            length = Math.min(signalForm1.length(), signalForm2.length());
            sb.append(outputName + " ");
            for (int j = 0; j < length; j++) {
                signal1Char = signalForm1.charAt(j);
                signal2Char = signalForm2.charAt(j);
                signal1Bool = charToBoolLogicGates(signal1Char);
                signal2Bool = charToBoolLogicGates(signal2Char);
                result = boolToCharLogicGates(lo.doOperator(signal1Bool, signal2Bool));
                sb.append(Character.toString(result));
            }
            sb.append("\n");
        }
        System.out.println(sb.toString().trim());
    }

    private static Character boolToCharLogicGates(boolean b) {
        return b ? '-' : '_';
    }

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

    private enum LogicOperator {

        AND("AND") {
            public Boolean doOperator(Boolean a, Boolean b) {
                return a & b;
            }
        },
        OR("OR") {
            public Boolean doOperator(Boolean a, Boolean b) {
                return a | b;
            }
        },
        XOR("XOR") {
            public Boolean doOperator(Boolean a, Boolean b) {
                return a ^ b;
            }
        },
        NAND("NAND") {
            public Boolean doOperator(Boolean a, Boolean b) {
                return !(a & b);
            }
        },
        NOR("NOR") {
            public Boolean doOperator(Boolean a, Boolean b) {
                return !(a | b);
            }
        },
        NXOR("NXOR") {
            public Boolean doOperator(Boolean a, Boolean b) {
                return !(a ^ b);
            }
        };

        private String logicOperatorName;
        LogicOperator(String logicOperatorName) {
            this.logicOperatorName = logicOperatorName;
        }

        public String getLogicOperatorName() {
            return this.logicOperatorName;
        }

        public static LogicOperator getLogicOperatorByOperationName(String logicOperatorName) {
            for (LogicOperator o : LogicOperator.values()) {
                if (o.getLogicOperatorName().equals(logicOperatorName)) {
                    return o;
                }
            }
            return null;
        }

        public abstract Boolean doOperator(Boolean a, Boolean b);

    }
}