#include <Keypad.h>
#include <LiquidCrystal_I2C.h>

const int ROW_NUM = 4; // Four rows
const int COLUMN_NUM = 4; // Four columns

char keys[ROW_NUM][COLUMN_NUM] = {
    {'1', '2', '3', 'A'},
    {'4', '5', '6', 'B'},
    {'7', '8', '9', 'C'},
    {'*', '0', '#', 'D'}
};

byte pin_rows[ROW_NUM] = {9, 8, 7, 6}; // Connect to the row pinouts of the keypad
byte pin_column[COLUMN_NUM] = {5, 4, 3, 2}; // Connect to the column pinouts of the keypad

Keypad keypad = Keypad(makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM);
LiquidCrystal_I2C lcd(0x27, 16, 2); // I2C address 0x27, 16 columns and 2 rows

int cursorColumn = 0;

void setup() {
    lcd.init(); // Initialize the LCD
    lcd.backlight();
}

void loop() {
    char key = keypad.getKey();
    if (key) {
        lcd.setCursor(cursorColumn, 0); // Move cursor to (cursorColumn, 0)
        lcd.print(key); // Print key at (cursorColumn, 0)
        cursorColumn++; // Move cursor to the next position
        if (cursorColumn == 16) {
            // If reaching the limit, clear the LCD
            lcd.clear();
            cursorColumn = 0;
        }
    }
}
#include <Arduino.h>

// Function to simplify boolean algebra expression using Karnaugh map
String simplifyExpression(int minterms[], int numMinterms) {
    // Initialize Karnaugh map with all elements as false
    bool karnaughMap[4][4] = {false};

    // Mark the cells corresponding to the minterms as true
    for (int i = 0; i < numMinterms; ++i) {
        int row = minterms[i] / 4;
        int col = minterms[i] % 4;
        karnaughMap[row][col] = true;
    }

    // Simplification using Karnaugh map
    String simplifiedExpression = "";

    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            if (karnaughMap[i][j]) {
                simplifiedExpression += "(";
                simplifiedExpression += (i == 0) ? "!A" : "A";
                simplifiedExpression += (j == 0) ? "!B" : "B";
                simplifiedExpression += (i == 2) ? "!C" : "C";
                simplifiedExpression += (j == 2) ? "!D" : "D";
                simplifiedExpression += ") + ";
            }
        }
    }

    // Remove the trailing " + " from the expression
    if (simplifiedExpression.length() > 0) {
        simplifiedExpression.remove(simplifiedExpression.length() - 3);
    }

    return simplifiedExpression;
}

//void setup() {
    Serial.begin(9600);
    
    // Example minterms
    int minterms[] = {0, 1, 2, 3, 4, 5, 6, 7};
    int numMinterms = sizeof(minterms) / sizeof(minterms[0]);

    // Simplify the expression
    String simplifiedExpression = simplifyExpression(minterms, numMinterms);

    // Output the simplified expression
   // Serial.println("Simplified expression: " + simplifiedExpression);
}

void loop() {
    // Empty loop, as we only need to run once in setup
}