C అర్రేలు (1D Arrays & 2D Matrices) & మెమరీ మోడల్

డేటా స్ట్రక్చర్స్ మరియు అల్గారిథమ్స్‌లో అర్రే అనేది అత్యంత ప్రాథమికమైన మరియు వేగవంతమైన బిల్డింగ్ బ్లాక్. ఈ అధ్యాయంలో కవర్ చేయబడే ప్రధానాంశాలు:

• అర్రే ప్రాథమిక ఆవశ్యకత: హోమోజీనియస్ ఎలిమెంట్స్ (Homogeneous Data Types) మరియు వేల వేరియబుల్స్‌ను ఒకే పేరుతో పిలవడం.
• కంటిగ్యువస్ మెమరీ కేటాయింపు (Contiguous Allocation): RAM లో ఎలిమెంట్స్ మధ్య ఖాళీ లేకుండా పక్కపక్కనే భద్రపరచడం.
• 0-బేస్డ్ ఇండెక్సింగ్ రహస్యం: C లో ఇండెక్స్ 1 నుండి కాకుండా 0 నుండే ఎందుకు మొదలవుతుంది? (ఆఫ్‌సెట్ కాలిక్యులేషన్).
• 1D అర్రే డిక్లరేషన్ & ఇనిషియలైజేషన్: కంప్లీట్, పార్షియల్, మరియు డైనమిక్ సైజ్ ఇనిషియలైజర్స్.
• బౌండ్స్ చెకింగ్ లోపం (No Bounds Checking in C): C కంపైలర్ ఇండెక్స్ లిమిట్లను ఎందుకు తనిఖీ చేయదు? సెగ్‌ఫాల్ట్ ప్రమాదాలు.
• అర్రే సైజు ఆటో-కాలిక్యులేషన్: sizeof(arr) / sizeof(arr[0]) గోల్డెన్ ఇడియమ్.
• ఫంక్షన్లకు అర్రేలను పాస్ చేయడం: Array Decay అంటే ఏమిటి? సైజును ప్రత్యేక పారామీటర్‌గా ఎందుకు పాస్ చేయాలి?
• 2D అర్రేలు (Two-Dimensional Matrices): టేబుల్ ఫార్మాట్, రోస్ మరియు కాలమ్స్ విజువలైజేషన్.
• Row-Major Order మెమరీ ఫార్ములా: హార్డ్‌వేర్ RAM లో 2D మ్యాట్రిక్స్ 1D గా ఎలా రూపాంతరం చెందుతుంది? అడ్రస్ గణన సమీకరణం.
• మ్యాట్రిక్స్ ఆపరేషన్లు: మ్యాట్రిక్స్ కూడిక (Addition) మరియు $O(N^3)$ మ్యాట్రిక్స్ గుణకారం (Multiplication).
• సమగ్ర రియల్ వరల్డ్ ప్రాజెక్ట్: మల్టీ-సబ్జెక్ట్ స్టూడెంట్ గ్రేడింగ్ & క్లాస్ టాపర్ అనలిటిక్స్ సిస్టమ్.
• బిగినర్స్ చేసే టాప్ 5 అర్రే తప్పులు: ఆఫ్-బై-వన్, డైరెక్ట్ అసైన్‌మెంట్ (arr1 = arr2) మిథ్య, నెగెటివ్ ఇండెక్సింగ్.
• స్వీయ మూల్యాంకన క్విజ్: 5 లోతైన ప్రాక్టికల్ ప్రశ్నలు & గేట్ ఎగ్జామ్ బిట్స్.

కంప్యూటర్ ప్రోగ్రామింగ్‌లో అర్రే (Array) అనగా: ఒకే డేటా టైప్‌కు చెందిన బహుళ అంశాలను RAM లో ఒకదాని పక్కన ఒకటి వరుసగా (Contiguous Memory Locations) నిల్వ చేసే స్థిర పరిమాణ డేటా నిర్మాణం.

C లో 1D అర్రేను డిక్లేర్ చేసే ప్రామాణిక సింటాక్స్ ఇది:

C లో ఇండెక్స్ 0 నుండి ఎందుకు ప్రారంభమవుతుంది? (The Offset Formula):

చాలా మంది కొత్త ప్రోగ్రామర్లకు ఆశ్చర్యం కలుగుతుంది: మొదటి ఎలిమెంట్‌ను marks[1] అనకుండా marks[0] అని ఎందుకు పిలవాలి? ఎందుకంటే C లో ఇండెక్స్ అనేది ఒక సంఖ్య కాదు; అది బేస్ అడ్రస్ నుండి ఉండే దూరం (Memory Offset)!

మొదటి ఎలిమెంట్ బేస్ అడ్రస్ వద్దే ఉంటుంది కాబట్టి, దాని దూరం (Offset) సరిగ్గా 0! అందుకే $i = 0$:

#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};

    printf("=== అర్రే ఎలిమెంట్స్ & వాటి మెమరీ చిరునామాలు (Contiguous Proof) ===\n");
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %2d  |  మెమరీ అడ్రస్ = %p\n", i, arr[i], (void*)&arr[i]);
    }

    return 0;
}

పైన కోడ్ రన్ చేస్తే ప్రతి అడ్రస్‌కు తర్వాతి అడ్రస్‌కు మధ్య ఖచ్చితంగా 4 బైట్ల వ్యత్యాసం ఉండటాన్ని మీరు స్పష్టంగా చూడవచ్చు!

జావా లేదా పైథాన్ వంటి ఇతర ఆధునిక భాషలలో మీరు 5 సైజు ఉన్న అర్రేలో 10వ ఇండెక్స్‌ను యాక్సెస్ చేయబోతే, రన్‌టైమ్ వెంటనే IndexOutOfBoundsException అని అరిచి ఆపేస్తుంది. కానీ C లాంగ్వేజ్‌లో:

ఒక అర్రేలో ఎన్ని ఎలిమెంట్స్ ఉన్నాయో హార్డ్-కోడ్ చేయకుండా, ప్రోగ్రామ్ స్వయంచాలకంగా లెక్కించడానికి C లో అత్యంత ప్రసిద్ధ ఇంజనీరింగ్ సూత్రం:

#include <stdio.h>

int main() {
    double prices[] = {19.99, 45.50, 120.00, 8.75, 99.90, 250.00};

    // మొత్తం అర్రే సైజు: 6 elements * 8 bytes = 48 bytes
    // ఒక్క ఎలిమెంట్ సైజు: 8 bytes
    // పొడవు = 48 / 8 = 6 elements!
    int count = sizeof(prices) / sizeof(prices[0]);

    printf("మొత్తం ప్రొడక్టుల సంఖ్య: %d\n", count);
    for (int i = 0; i < count; i++) {
        printf("ప్రొడక్ట్ #%d: రూ. %.2f\n", i + 1, prices[i]);
    }

    return 0;
}

ఒక అర్రేను ఫంక్షన్‌కు పారామీటర్‌గా పంపినప్పుడు C లో ఒక వింతైన మార్పు జరుగుతుంది: మొత్తం అర్రే ఎప్పటికీ కాపీ కాదు! కేవలం మొదటి ఎలిమెంట్ యొక్క పాయింటర్ (Pointer to first element) మాత్రమే వెళ్తుంది. దీనినే Array Decay అంటారు.

#include <stdio.h>

// int arr[] అనేది సాంకేతికంగా int *arr తో సమానం!
double calculateAverage(const int arr[], int size) {
    long sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return (double)sum / size;
}

int main() {
    int scores[] = {88, 92, 79, 95, 84};
    int len = sizeof(scores) / sizeof(scores[0]);

    double avg = calculateAverage(scores, len); // అర్రే పేరు మాత్రమే పాస్ చేస్తాం
    printf("తరగతి సగటు మార్కులు: %.2f\n", avg);
    return 0;
}

గణితంలో మ్యాట్రిక్స్ (Matrix), ఎక్సెల్ స్ప్రెడ్‌షీట్ (Spreadsheet), లేదా చదరంగం బోర్డు (Chessboard) లాంటి 2D గ్రిడ్‌లను కంప్యూటర్‌లో నిల్వ చేయడానికి 2D అర్రేలు ఉపయోగపడతాయి. ఇందులో అడ్డు వరుసలు (Rows) మరియు నిలువు వరుసలు (Columns) ఉంటాయి:

#include <stdio.h>

int main() {
    int grid[2][4] = {
        {10, 20, 30, 40},
        {50, 60, 70, 80}
    };

    printf("=== 2x4 మ్యాట్రిక్స్ గ్రిడ్ ప్రింటింగ్ ===\n");
    for (int r = 0; r < 2; r++) { // Rows లూప్
        for (int c = 0; c < 4; c++) { // Cols లూప్
            printf("%4d ", grid[r][c]);
        }
        printf("\n");
    }

    return 0;
}

కంప్యూటర్ సైన్స్‌లో అత్యంత ముఖ్యమైన వాస్తవం: భౌతికంగా కంప్యూటర్ RAM లో 2D అర్రేలు అంటూ ఏమీ ఉండవు! RAM అనేది కేవలం ఒక సరళరేఖ లాంటి 1D వరుస మెమరీ మాత్రమే!

మరి కంపైలర్ 2D మ్యాట్రిక్స్‌ను RAM లో ఎలా నిల్వ చేస్తుంది? C లాంగ్వేజ్ Row-Major Order అనే పద్ధతిని పాటిస్తుంది. అంటే మొదటి అడ్డు వరుస (Row 0) ను ముందుగా భద్రపరిచి, దాని వెంటే రెండవ అడ్డు వరుస (Row 1), ఆ వెంటే మూడవ వరుసను వరుసగా అమర్చుతుంది:

1D మరియు 2D అర్రేల మధ్య గల సమగ్ర సాంకేతిక పోలికలు:

రెండు మ్యాట్రిక్స్‌లను గుణించాలంటే ఒక కఠినమైన గణిత నిబంధన ఉంది: మొదటి మ్యాట్రిక్స్ యొక్క కాలమ్స్ సంఖ్య రెండవ మ్యాట్రిక్స్ యొక్క రోస్ సంఖ్యకు సమానంగా ఉండాలి! దీనిని సాధించడానికి 3 స్థాయిల నెస్టెడ్ లూప్స్ ($O(N^3)$) వాడతాం:

#include <stdio.h>

int main() {
    int A[2][2] = { {1, 2}, {3, 4} };
    int B[2][2] = { {5, 6}, {7, 8} };
    int C[2][2] = { {0, 0}, {0, 0} };

    // మ్యాట్రిక్స్ గుణకారం (Matrix Multiplication O(N^3))
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 2; k++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }

    printf("=== మ్యాట్రిక్స్ గుణకార ఫలితం (A x B) ===\n");
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%4d ", C[i][j]);
        }
        printf("\n");
    }

    return 0;
}

ఇప్పటివరకు నేర్చుకున్న 1D మరియు 2D అర్రేలను ఉపయోగించి ఒక సమగ్ర విద్యార్థుల మార్కుల విశ్లేషణ ఇంజిన్ (Academic Analytics Engine) నిర్మిద్దాం. ఇందులో 3 మంది విద్యార్థులు, 4 సబ్జెక్టుల మార్కులను ప్రాసెస్ చేసి, ప్రతి విద్యార్థి మొత్తం మార్కులు, సగటు మరియు క్లాస్ టాపర్‌ను కనుగొంటాం:

#include <stdio.h>

#define STUDENTS 3
#define SUBJECTS 4

int main() {
    // విద్యార్థుల పేర్లు
    const char* names[STUDENTS] = {"అఖిల్ వర్మ", "భావన రెడ్డి", "చైతన్య కృష్ణ"};

    // 2D అర్రే: 3 విద్యార్థులు x 4 సబ్జెక్టుల మార్కులు (Maths, Physics, Chem, CS)
    int marks[STUDENTS][SUBJECTS] = {
        {92, 85, 88, 95}, // అఖిల్
        {96, 94, 91, 98}, // భావన
        {78, 82, 80, 85}  // చైతన్య
    };

    printf("==============================================================\n");
    printf("     మనా అకడమిక్ గ్రేడింగ్ రిపోర్ట్ (Academic Analytics 2026)\n");
    printf("==============================================================\n");
    printf("%-16s | %-6s | %-6s | %-6s | %-6s | %-6s | %-6s\n",
           "విద్యార్థి పేరు", "M1", "M2", "M3", "M4", "మొత్తం", "సగటు%%");
    printf("--------------------------------------------------------------\n");

    int highestTotal = -1;
    int topperIndex = -1;

    for (int i = 0; i < STUDENTS; i++) {
        int studentTotal = 0;
        printf("%-16s | ", names[i]);

        for (int j = 0; j < SUBJECTS; j++) {
            printf("%-6d | ", marks[i][j]);
            studentTotal += marks[i][j];
        }

        double percentage = (double)studentTotal / SUBJECTS;
        printf("%-6d | %-6.2f%%\n", studentTotal, percentage);

        // క్లాస్ టాపర్ ను కనుగొనడం
        if (studentTotal > highestTotal) {
            highestTotal = studentTotal;
            topperIndex = i;
        }
    }

    printf("==============================================================\n");
    printf("🏆 క్లాస్ టాపర్: %s (మొత్తం స్కోర్: %d / %d)\n",
           names[topperIndex], highestTotal, SUBJECTS * 100);
    printf("==============================================================\n");

    return 0;
}

ఈ పాఠంలోని లోతైన అంశాలను క్రింది 5 ప్రాక్టికల్ ప్రశ్నల ద్వారా పరీక్షించుకోండి: