cd

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

bool is_valid_string(const char *s) {
    int count_a = 0; // To count the number of 'a's
    int count_b = 0; // To count the number of 'b's
    
    // We need to first check that the string has no other characters than 'a' and 'b'
    // and that all 'a's appear before any 'b'.
    bool found_b = false; // Flag to check if we've started encountering 'b's
    
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] == 'a') {
            if (found_b) {
                return false; // If 'b' is encountered before 'a', invalid string
            }
            count_a++;
        }
        else if (s[i] == 'b') {
            found_b = true;
            count_b++;
        }
        else {
            return false; // If any character other than 'a' or 'b', invalid string
        }
    }
    
    // For the string to be valid, the number of 'a's must be equal to the number of 'b's
    return count_a == count_b;
}

int main() {
    char input[100];  // Array to hold user input (up to 99 characters)

    // Prompt the user for input
    printf("Enter a string (only 'a' and 'b' characters are allowed): ");
    scanf("%s", input);

    // Check and print the result
    if (is_valid_string(input)) {
        printf("The string '%s' is valid (a^n b^n).\n", input);
    } else {
        printf("The string '%s' is invalid.\n", input);
    }
    
    return 0;
}



#include <stdio.h>
#include <string.h>

int isValidString(char *str) {
    int count_a = 0, count_b = 0;
    int state = 0; // q0

    printf("\nTransition Table\n");
    printf("Current State | Input | Next State\n");
    printf("-------------------------------\n");

    for (int i = 0; str[i] != '\0'; i++) {
        char ch = str[i];

        printf("q%d | %c | ", state, ch);

        if (state == 0) {
            if (ch == 'a') {
                count_a++;
                printf("q0\n");
            } else if (ch == 'b') {
                state = 1;
                count_b++;
                printf("q1\n");
            } else {
                printf("Reject (Invalid character)\n");
                return 0;
            }
        } else if (state == 1) {
            if (ch == 'b') {
                count_b++;
                printf("q1\n");
            } else if (ch == 'a') {
                printf("Reject (a after b)\n");
                return 0;
            } else {
                printf("Reject (Invalid character)\n");
                return 0;
            }
        }
    }

    // Final validation
    if (state == 1 && count_a == count_b && count_a > 0) {
        printf("\nThe string is valid (a^n b^n)\n");
        return 1;
    } else {
        printf("\nThe string is invalid (a^n b^n)\n");
        return 0;
    }
}

int main() {
    char input[100];
    printf("Enter the string: ");
    scanf("%99s", input); // Prevent buffer overflow
    isValidString(input);
    return 0;
}




#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdbool.h>

bool is_identifier(const char *token) {
    if (!isalpha(token[0]) && token[0] != '_')
        return false;
    for (int i = 1; token[i] != '\0'; i++) {
        if (!isalnum(token[i]) && token[i] != '_')
            return false;
    }
    return true;
}

bool is_constant(const char *token) {
    int i = 0, dot_count = 0;
    if (token[i] == '-' || token[i] == '+') i++;

    if (token[i] == '\0') return false;

    for (; token[i] != '\0'; i++) {
        if (token[i] == '.') {
            if (++dot_count > 1) return false;
        } else if (!isdigit(token[i])) {
            return false;
        }
    }
    return true;
}

bool is_operator(const char *token) {
    const char *operators[] = {"+", "-", "*", "/", "=", "==", "!=", "<", ">", "<=", ">="};
    for (int i = 0; i < sizeof(operators) / sizeof(operators[0]); i++) {
        if (strcmp(token, operators[i]) == 0)
            return true;
    }
    return false;
}

int main() {
    char token[100];
    printf("Enter a token: ");
    scanf("%s", token);

    if (is_operator(token))
        printf("Operator\n");
    else if (is_constant(token))
        printf("Constant\n");
    else if (is_identifier(token))
        printf("Identifier\n");
    else
        printf("Unknown\n");

    return 0;
}



#include <stdio.h>
#include <ctype.h>
#include <string.h>

char keywords[10][10] = {"int", "float", "char", "if", "else", "while", "do", "return", "for", "void"};

int isKeyword(char *word) {
    for (int i = 0; i < 10; i++) {
        if (strcmp(keywords[i], word) == 0)
            return 1;
    }
    return 0;
}

void lexer(char *code) {
    int i = 0;
    char ch, buffer[20];
    int bufferIndex = 0;

    while ((ch = code[i++]) != '\0') {
        if (isalnum(ch)) {
            buffer[bufferIndex++] = ch;
        } else {
            if (bufferIndex != 0) {
                buffer[bufferIndex] = '\0';
                bufferIndex = 0;

                if (isKeyword(buffer))
                    printf("[KEYWORD => %s]\n", buffer);
                else if (isdigit(buffer[0]))
                    printf("[NUMBER => %s]\n", buffer);
                else
                    printf("[IDENTIFIER => %s]\n", buffer);
            }

            if (ch == ' ' || ch == '\n' || ch == '\t')
                continue;

            if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '=')
                printf("[OPERATOR => %c]\n", ch);

            if (ch == '(' || ch == ')' || ch == ';' || ch == '{' || ch == '}')
                printf("[SEPARATOR => %c]\n", ch);
        }
    }
}

int main() {
    char code[1000];
    printf("Enter code (e.g., int a = 10;):\n");
    fgets(code, sizeof(code), stdin);

    printf("\n--- Lexical Tokens ---\n");
    lexer(code);
    return 0;
}



#include <stdio.h>
#include <string.h>

char prod[2][10] = { "S->aA", "A->b" };
char nonTerminals[2][10] = { "S", "A" };
char terminals[3][10] = { "a", "b", "$" };

char table[3][4][15]; // 3 rows (S, A + header), 4 columns (a, b, $, + header)

int getRow(char nt) {
    switch (nt) {
        case 'S': return 1;
        case 'A': return 2;
    }
    return 0;
}

int getCol(char t) {
    switch (t) {
        case 'a': return 1;
        case 'b': return 2;
        case '$': return 3;
    }
    return 0;
}

int main() {
    // Initialize table with empty strings
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 4; j++)
            strcpy(table[i][j], " ");

    // Fill headers
    strcpy(table[0][0], " ");
    strcpy(table[0][1], "a");
    strcpy(table[0][2], "b");
    strcpy(table[0][3], "$");

    strcpy(table[1][0], "S");
    strcpy(table[2][0], "A");

    // Fill table using FIRST sets
    strcpy(table[getRow('S')][getCol('a')], "S->aA");
    strcpy(table[getRow('A')][getCol('b')], "A->b");

    // Print the table
    printf("Predictive Parsing Table:\n");
    printf("-----------------------------------------\n");

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%-12s", table[i][j]);
        }
        printf("\n-----------------------------------------\n");
    }

    return 0;
}




#include <stdio.h>
#define SUCCESS 1
#define FAILED 0

const char *cursor;
char input[64];

int E(), Edash(), T(), Tdash(), F();

int main() {
    printf("Enter the string: ");
    scanf("%s", input);
    cursor = input;

    printf("\nInput Action\n");
    printf("-------------------------------\n");

    if (E() && *cursor == '\0') {
        printf("-------------------------------\n");
        printf("String is successfully parsed\n");
    } else {
        printf("-------------------------------\n");
        printf("Error in parsing String\n");
    }
    return 0;
}

int E() {
    printf("%-15s E -> T E'\n", cursor);
    return T() && Edash();
}

int Edash() {
    if (*cursor == '+') {
        printf("%-15s E' -> + T E'\n", cursor);
        cursor++;
        return T() && Edash();
    }
    printf("%-15s E' -> ε\n", cursor);
    return SUCCESS;
}

int T() {
    printf("%-15s T -> F T'\n", cursor);
    return F() && Tdash();
}

int Tdash() {
    if (*cursor == '*') {
        printf("%-15s T' -> * F T'\n", cursor);
        cursor++;
        return F() && Tdash();
    }
    printf("%-15s T' -> ε\n", cursor);
    return SUCCESS;
}

int F() {
    if (*cursor == '(') {
        printf("%-15s F -> ( E )\n", cursor);
        cursor++;
        if (E() && *cursor == ')') {
            cursor++;
            return SUCCESS;
        }
        return FAILED;
    } else if (*cursor == 'i') {
        printf("%-15s F -> i\n", cursor);
        cursor++;
        return SUCCESS;
    }
    return FAILED;
}





#include <stdio.h>
#include <string.h>

int tempVar = 1;

void newTemp(char *temp) {
    sprintf(temp, "t%d", tempVar++);
}
void replace(char expr[][10], int *n, int i, char *temp) {
    strcpy(expr[i - 1], temp);
    for (int j = i + 2; j < *n; j++)
        strcpy(expr[j - 2], expr[j]);
    *n -= 2;
}
void generateTAC(char input[]) {
    char lhs[10], rhs[100];
    int n = 0;
    // Split into lhs and rhs
    sscanf(input, "%[^=]=%s", lhs, rhs);
    char expr[50][10], temp[10];
    // Tokenize RHS
    for (int i = 0; rhs[i]; i++) {
        char t[2] = {rhs[i], '\0'};
        strcpy(expr[n++], t);
    }
    // First handle * and /
    for (int i = 0; i < n; i++)
        if (!strcmp(expr[i], "*") || !strcmp(expr[i], "/")) {
            newTemp(temp);
            printf("%s = %s %s %s\n", temp, expr[i - 1], expr[i], expr[i + 1]);
            replace(expr, &n, i, temp);
            i = -1;
        }
    // Then handle + and -
    for (int i = 0; i < n; i++)
        if (!strcmp(expr[i], "+") || !strcmp(expr[i], "-")) {
            newTemp(temp);
            printf("%s = %s %s %s\n", temp, expr[i - 1], expr[i], expr[i + 1]);
            replace(expr, &n, i, temp);
            i = -1;
        }
    // Final assignment
    printf("%s = %s\n", lhs, expr[0]);
}
int main() {
    char expr[100];
    printf("Enter expression (e.g., a=b+c*d): ");
    scanf("%s", expr);
    generateTAC(expr);
    return 0;
}





#include <stdio.h>
#include <string.h>
 
char prol[7][10] = { "S", "A", "A", "B", "B", "C", "C" };
char pror[7][10] = { "A", "Bb", "Cd", "aB", "@", "Cc", "@" };
char prod[7][10] = { "S->A", "A->Bb", "A->Cd", "B->aB", "B->@", "C->Cc", "C->@" };
char first[7][10] = { "abcd", "ab", "cd", "a@", "@", "c@", "@" };
char follow[7][10] = { "$", "$", "$", "a$", "b$", "c$", "d$" };
char table[5][6][10];
 
int numr(char c)
{
   switch (c)
   {
      case 'S':
         return 0;
 
      case 'A':
         return 1;
 
      case 'B':
         return 2;
 
      case 'C':
         return 3;
 
      case 'a':
         return 0;
 
      case 'b':
         return 1;
 
      case 'c':
         return 2;
 
      case 'd':
         return 3;
 
      case '$':
         return 4;
   }
 
   return (2);
}
 
int main()
{
   int i, j, k;
 
   for (i = 0; i < 5; i++)
      for (j = 0; j < 6; j++)
         strcpy(table[i][j], " ");
 
   printf("The following grammar is used for Parsing Table:\n");
 
   for (i = 0; i < 7; i++)
      printf("%s\n", prod[i]);
 
   printf("\nPredictive parsing table:\n");
 
   fflush(stdin);
 
   for (i = 0; i < 7; i++)
   {
      k = strlen(first[i]);
      for (j = 0; j < 10; j++)
         if (first[i][j] != '@')
            strcpy(table[numr(prol[i][0]) + 1][numr(first[i][j]) + 1], prod[i]);
   }
 
   for (i = 0; i < 7; i++)
   {
      if (strlen(pror[i]) == 1)
      {
         if (pror[i][0] == '@')
         {
            k = strlen(follow[i]);
            for (j = 0; j < k; j++)
               strcpy(table[numr(prol[i][0]) + 1][numr(follow[i][j]) + 1], prod[i]);
         }
      }
   }
 
   strcpy(table[0][0], " ");
 
   strcpy(table[0][1], "a");
 
   strcpy(table[0][2], "b");
 
   strcpy(table[0][3], "c");
 
   strcpy(table[0][4], "d");
 
   strcpy(table[0][5], "$");
 
   strcpy(table[1][0], "S");
 
   strcpy(table[2][0], "A");
 
   strcpy(table[3][0], "B");
 
   strcpy(table[4][0], "C");
 
   printf("\n--------------------------------------------------------\n");
 
   for (i = 0; i < 5; i++)
      for (j = 0; j < 6; j++)
      {
         printf("%-10s", table[i][j]);
         if (j == 5)
            printf("\n--------------------------------------------------------\n");
      }
}



#include <stdio.h>
#include <string.h>

#define NUM_NON_TERMINALS 5
#define NUM_TERMINALS 6
#define MAX_PRODUCTIONS 8
#define MAX_STRING_LENGTH 15

// Grammar productions
char prod[MAX_PRODUCTIONS][MAX_STRING_LENGTH] = { 
    "E->TE'", 
    "E'->+TE'", 
    "E'->@", 
    "T->FT'", 
    "T'->*FT'", 
    "T'->@", 
    "F->(E)", 
    "F->id" 
};

// Non-terminals and terminals
char nonTerminals[NUM_NON_TERMINALS][MAX_STRING_LENGTH] = { "E", "E'", "T", "T'", "F" };
char terminals[NUM_TERMINALS][MAX_STRING_LENGTH] = { "id", "+", "*", "(", ")", "$" };

// First and Follow sets
char first[MAX_PRODUCTIONS][MAX_STRING_LENGTH] = { "id(", "+", "@", "id(", "*", "@", "(", "id" };
char follow[NUM_NON_TERMINALS][MAX_STRING_LENGTH] = { "$)", "$)", "+$)", "+$)", "+*)$" };

// Parsing table
char table[NUM_NON_TERMINALS + 1][NUM_TERMINALS + 1][MAX_STRING_LENGTH];

int getRow(char c) {
    switch (c) {
        case 'E': return 1;
        case 'e': return 2; // treating E' as e
        case 'T': return 3;
        case 't': return 4; // T' as t
        case 'F': return 5;
        default: return 0;
    }
}

int getCol(char *sym) {
    for (int i = 0; i < NUM_TERMINALS; i++) {
        if (strcmp(terminals[i], sym) == 0)
            return i + 1;
    }
    return 0;
}

void fillParsingTable() {
    // Initialize table with empty strings
    for (int i = 0; i <= NUM_NON_TERMINALS; i++) {
        for (int j = 0; j <= NUM_TERMINALS; j++) {
            strcpy(table[i][j], "");
        }
    }

    // Header row
    strcpy(table[0][0], " ");
    for (int i = 0; i < NUM_TERMINALS; i++)
        strcpy(table[0][i + 1], terminals[i]);

    // Left column (non-terminals)
    for (int i = 0; i < NUM_NON_TERMINALS; i++)
        strcpy(table[i + 1][0], nonTerminals[i]);

    // Fill productions in the table
    for (int i = 0; i < MAX_PRODUCTIONS; i++) {
        char nt = prod[i][0];  // Non-terminal in production
        int row = getRow(nt);

        // Iterate through the first set of the production
        for (int j = 0; j < strlen(first[i]); j++) {
            char ch = first[i][j];
            if (ch == '@') {
                // Epsilon production, fill the table using the Follow set
                for (int k = 0; k < strlen(follow[row - 1]); k++) {
                    char fch = follow[row - 1][k];
                    char sym[2] = { fch, '\0' };
                    int col = getCol(sym);
                    if (strcmp(table[row][col], "") == 0)  // If cell is empty, fill it
                        strcpy(table[row][col], prod[i]);
                }
            } else {
                char sym[3] = { ch, '\0', '\0' };  // Increase size to 3 to hold 'i' and 'd' for "id"
                if (ch == 'i') strcpy(sym, "id"); // map 'i' to "id"
                int col = getCol(sym);
                if (strcmp(table[row][col], "") == 0)  // If cell is empty, fill it
                    strcpy(table[row][col], prod[i]);
            }
        }
    }
}

void printTable() {
    printf("-------------------------------------------------------------\n");
    printf("            id          +           *           (           )           $           \n");
    printf("-------------------------------------------------------------\n");

    for (int i = 0; i <= NUM_NON_TERMINALS; i++) {
        for (int j = 0; j <= NUM_TERMINALS; j++) {
            if (strcmp(table[i][j], "") != 0)  // Only print non-empty cells
                printf("%-12s", table[i][j]);
            else
                printf("%-12s", " ");  // Print space for empty cells
        }
        printf("\n-------------------------------------------------------------\n");
    }
}

int main() {
    fillParsingTable();
    printTable();

    return 0;
}