Multidimensional Arrays
& Strings in C

#include <stdio.h>
#define ROWS 3
#define COLS 4

int main() {
    int marks[ROWS][COLS];    /* declare 3×4 integer matrix */
    int i, j;

    /* Fill using nested loops */
    for (i = 0; i < ROWS; i++)
        for (j = 0; j < COLS; j++)
            marks[i][j] = (i + 1) * 10 + j;  /* 10,11,12,13 / 20,21... */

    /* Print in matrix format */
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++)
            printf("%4d", marks[i][j]);
        printf("\n");
    }

    /* Direct access — specific cell */
    printf("marks[1][2] = %d\n", marks[1][2]);  /* row 1, col 2 */
    return 0;
}

#include <stdio.h>

int main() {
    int a[3][4];
    int i, j;

    printf("Memory addresses of a[i][j]:\n");
    printf("%-12s %-12s %-14s\n", "Element", "Address", "Offset");
    printf("-------------------------------------------\n");

    for (i = 0; i < 3; i++) {
        for (j = 0; j < 4; j++) {
            printf("a[%d][%d]     %p    +%ld bytes\n",
                   i, j,
                   (void*)&a[i][j],
                   (char*)&a[i][j] - (char*)&a[0][0]);
        }
    }
    return 0;
}

/* Method 1: Row-wise with inner braces (most readable) */
int a[3][3] = {
    {1, 2, 3},   /* row 0 */
    {4, 5, 6},   /* row 1 */
    {7, 8, 9}    /* row 2 */
};

/* Method 2: Flat list — filled row by row left to right */
int b[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

/* Method 3: Partial — rest filled with 0 automatically */
int c[3][3] = {{1,2}, {4}};
/* c = { {1,2,0}, {4,0,0}, {0,0,0} } */

/* Method 4: All zeros — two ways */
int d[3][3] = {0};                      /* all zeros */
static int e[3][3];                     /* static: auto zero */

/* Method 5: Size can be omitted for rows (NOT columns) */
int f[][3] = {{1,2,3},{4,5,6}};  /* compiler counts rows = 2 */

#include <stdio.h>
#define M 2   /* rows of A */
#define N 3   /* cols of A = rows of B */
#define P 2   /* cols of B */

void printMat(int m[][P], int r, int c) {
    int i, j;
    for (i=0;i<r;i++){for(j=0;j<c;j++) printf("%5d",m[i][j]);printf("\n");}
}

int main() {
    int A[M][N] = {{1,2,3},{4,5,6}};    /* 2×3 */
    int B[N][P] = {{7,8},{9,10},{11,12}};  /* 3×2 */
    int C[M][P] = {0};                      /* result 2×2, initialise 0 */
    int i, j, k;

    /* C[i][j] = sum of A[i][k] * B[k][j] for all k */
    for (i = 0; i < M; i++)
        for (j = 0; j < P; j++)
            for (k = 0; k < N; k++)
                C[i][j] += A[i][k] * B[k][j];

    printf("A (2x3):\n"); printMat(A, M, N);
    printf("B (3x2):\n"); printMat(B, N, P);
    printf("C = A x B (2x2):\n"); printMat(C, M, P);
    return 0;
}

#include <stdio.h>
#define N 3

void print(int m[][N], int n){
    int i,j;
    for(i=0;i<n;i++){for(j=0;j<n;j++)printf("%4d",m[i][j]);printf("\n");}
}

int main() {
    int m[N][N] = {{1,2,3},{4,5,6},{7,8,9}};
    int i, j, temp;

    printf("Original:\n"); print(m, N);

    /* Only visit upper triangle — j starts at i+1 */
    /* Starting j at 0 would swap each pair TWICE → undone */
    for (i = 0; i < N; i++)
        for (j = i + 1; j < N; j++) {
            temp    = m[i][j];
            m[i][j] = m[j][i];
            m[j][i] = temp;
        }

    printf("Transposed:\n"); print(m, N);
    return 0;
}

#include <stdio.h>
/* Exam scores: 2 years, 3 students, 4 subjects */
#define YEARS    2
#define STUDENTS 3
#define SUBJECTS 4

int main() {
    int score[YEARS][STUDENTS][SUBJECTS] = {
        /* Year 2023 */
        {{ 80, 75, 90, 85},
         { 70, 65, 80, 75},
         { 95, 90, 85, 92}},
        /* Year 2024 */
        {{ 88, 82, 91, 86},
         { 72, 78, 83, 79},
         { 96, 93, 89, 97}}
    };
    int   y, s, sub, total;
    float avg, best = 0;
    int   bestY = 0, bestS = 0;

    for (y = 0; y < YEARS; y++) {
        printf("=== Year %d ===\n", 2023 + y);
        for (s = 0; s < STUDENTS; s++) {
            total = 0;
            for (sub = 0; sub < SUBJECTS; sub++) total += score[y][s][sub];
            avg = (float)total / SUBJECTS;
            printf("  Student %d: avg = %.1f\n", s+1, avg);
            if (avg > best) { best=avg; bestY=y; bestS=s; }
        }
    }
    printf("\nOverall best: Year %d, Student %d, avg %.1f\n",
           2023+bestY, bestS+1, best);
    return 0;
}

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

int main() {
    /* Method 1: string literal — '\0' added automatically */
    char a[] = "Ananta";             /* size = 7 (auto) */

    /* Method 2: character-by-character — manual '\0' */
    char b[5] = {'C','o','d','e','\0'}; /* must add '\0' */

    /* Method 3: buffer for input */
    char c[50];                       /* uninitialised — fill via scanf/fgets */

    /* Proving a string is just chars */
    int i;
    printf("Printing char by char:\n");
    for (i = 0; a[i] != '\0'; i++)
        printf("a[%d] = '%c'  ASCII = %d\n", i, a[i], a[i]);

    printf("\nNull terminator: a[%zu] = %d\n", strlen(a), a[strlen(a)]);
    printf("strlen = %zu  (doesn't count '\\0')\n", strlen(a));
    printf("sizeof = %zu  (counts '\\0')\n", sizeof(a));

    return 0;
}

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

int main() {
    char name[30], sentence[100];

    /* ── Method 1: scanf("%s") ────────────────────────────── */
    /* Reads one word only. Stops at whitespace. No overflow check. */
    printf("Enter username (no spaces): ");
    scanf("%s", name);         /* no & because array = address */
    printf("Got: [%s]\n", name);

    /* Clear input buffer before next read */
    while(getchar() != '\n');

    /* ── Method 2: scanf with width limit ─────────────────── */
    /* Safer: %29s reads max 29 chars (leaves room for '\0') */
    printf("Enter city (max 29 chars): ");
    scanf("%29s", name);
    printf("City: [%s]\n", name);
    while(getchar() != '\n');

    /* ── Method 3: fgets ──────────────────────────────────── */
    /* BEST: reads full line with spaces, has size limit */
    printf("Enter a sentence: ");
    fgets(sentence, sizeof(sentence), stdin);

    /* fgets keeps '\n' at end — remove it */
    int len = strlen(sentence);
    if (sentence[len-1] == '\n')
        sentence[len-1] = '\0';

    printf("Sentence: [%s]\n", sentence);
    printf("Length  : %zu\n", strlen(sentence));
    return 0;
}

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

int main() {
    char s1[60] = "Hello";
    char s2[]  = "World";
    char s3[60];
    char *ptr;

    /* 1. strlen — count characters (not counting '\0') */
    printf("strlen(\"%s\") = %zu\n", s1, strlen(s1));   /* 5 */

    /* 2. strcpy — copy src into dest (dest must be big enough) */
    strcpy(s3, s1);
    printf("strcpy: s3 = \"%s\"\n", s3);               /* Hello */

    /* 3. strncpy — copy at most n chars (safer than strcpy) */
    char s4[10];
    strncpy(s4, s2, 3);
    s4[3] = '\0';                    /* strncpy doesn't add '\0' if n reached */
    printf("strncpy 3: \"%s\"\n", s4);                /* Wor */

    /* 4. strcat — append s2 to end of s1 */
    strcat(s1, " ");
    strcat(s1, s2);
    printf("strcat: \"%s\"\n", s1);                  /* Hello World */

    /* 5. strcmp — compare: 0=equal, <0=s1 before s2, >0=s1 after */
    printf("strcmp(\"abc\",\"abc\") = %d\n", strcmp("abc","abc")); /* 0 */
    printf("strcmp(\"abc\",\"abd\") = %d\n", strcmp("abc","abd")); /* negative */
    printf("strcmp(\"b\",\"a\")   = %d\n",   strcmp("b","a"));     /* positive */

    /* 6. strchr — find first occurrence of a character */
    ptr = strchr(s1, 'o');
    if (ptr) printf("strchr 'o': found at pos %ld\n", ptr - s1); /* 4 */

    /* 7. strstr — find first occurrence of a substring */
    ptr = strstr(s1, "World");
    if (ptr) printf("strstr: 'World' at pos %ld\n", ptr - s1); /* 6 */

    /* 8. Manual length without strlen */
    int len = 0;
    while (s2[len] != '\0') len++;
    printf("Manual strlen(\"%s\") = %d\n", s2, len);   /* 5 */

    return 0;
}

#include <stdio.h>
#include <string.h>
#define N 5
#define MAXLEN 30

int main() {
    char names[N][MAXLEN] = {
        "Vikram", "Ananta", "Sneha", "Priya", "Rahul"
    };
    char temp[MAXLEN];
    int  i, j;

    /* Bubble sort on strings using strcmp */
    for (i = 0; i < N - 1; i++)
        for (j = 0; j < N - i - 1; j++)
            if (strcmp(names[j], names[j+1]) > 0) {
                strcpy(temp,     names[j]);
                strcpy(names[j], names[j+1]);
                strcpy(names[j+1], temp);   /* swap whole strings */
            }

    printf("Alphabetical order:\n");
    for (i = 0; i < N; i++)
        printf("%d. %s\n", i+1, names[i]);

    return 0;
}

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

int isVowel(char c) {
    c = tolower(c);
    return c=='a'||c=='e'||c=='i'||c=='o'||c=='u';
}

int main() {
    char s[200];
    int  words=0, vowels=0, cons=0, digits=0, spaces=0;
    int  inWord = 0;   /* flag: are we currently inside a word? */

    printf("Enter sentence: ");
    fgets(s, sizeof(s), stdin);

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

        if (isspace(c)) {
            spaces++;
            inWord = 0;
        } else {
            if (!inWord) { words++; inWord = 1; }  /* new word starts */

            if      (isdigit(c))    digits++;
            else if (isVowel(c))   vowels++;
            else if (isalpha(c))   cons++;
        }
    }

    printf("\n--- Statistics ---\n");
    printf("Words      : %d\n", words);
    printf("Vowels     : %d\n", vowels);
    printf("Consonants : %d\n", cons);
    printf("Digits     : %d\n", digits);
    printf("Spaces     : %d\n", spaces);
    return 0;
}

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

void caesar(char *s, int shift, int encrypt) {
    if (!encrypt) shift = 26 - shift;  /* decrypt = reverse shift */

    for (int i = 0; s[i] != '\0'; i++) {
        if (isupper(s[i]))
            s[i] = (char)((toupper(s[i]) - 'A' + shift) % 26 + 'A');
        else if (islower(s[i]))
            s[i] = (char)((tolower(s[i]) - 'a' + shift) % 26 + 'a');
        /* digits and spaces unchanged */
    }
}

int main() {
    char msg[100];
    int  key;

    printf("Enter message : ");
    fgets(msg, sizeof(msg), stdin);
    msg[strlen(msg)-1] = '\0';    /* remove newline */

    printf("Enter shift key: ");
    scanf("%d", &key);

    printf("Original : %s\n", msg);

    caesar(msg, key, 1);
    printf("Encrypted: %s\n", msg);

    caesar(msg, key, 0);
    printf("Decrypted: %s\n", msg);

    return 0;
}

#include <stdio.h>
#include <string.h>
#define STU  5
#define SUB  4

char grade(float avg) {
    if      (avg >= 90) return 'A';
    else if (avg >= 75) return 'B';
    else if (avg >= 55) return 'C';
    else                return 'F';
}

int main() {
    char names[STU][20] = {"Ananta","Priya","Rahul","Vikram","Sneha"};
    char subj[SUB][10] = {"Maths","Physics","C Prog","English"};
    int marks[STU][SUB] = {
        {92,85,98,88},
        {78,82,75,90},
        {60,55,70,65},
        {88,90,85,92},
        {95,93,97,96}
    };
    int   i, j, total, topIdx = 0;
    float avg, topAvg = 0;

    printf("%-10s", "Name");
    for(j=0;j<SUB;j++) printf("%-9s",subj[j]);
    printf("Total  Avg    Grade\n");
    printf("----------------------------------------------------------------\n");

    for (i = 0; i < STU; i++) {
        total = 0;
        for (j = 0; j < SUB; j++) total += marks[i][j];
        avg = (float)total / SUB;

        printf("%-10s", names[i]);
        for (j=0;j<SUB;j++) printf("%-9d",marks[i][j]);
        printf("%5d  %5.1f   %c\n", total, avg, grade(avg));

        if (avg > topAvg) { topAvg = avg; topIdx = i; }
    }

    printf("----------------------------------------------------------------\n");
    printf("CLASS TOPPER: %s  (%.1f average)\n", names[topIdx], topAvg);
    return 0;
}