Multi-dimensional Arrays क्या हैं

एक two-dimensional array एक egg-carton grid या एक chessboard जैसा है: इसमें rows और columns हैं, इसलिए आप दो numbers देकर चीज़ें ढूंढते हैं।

In this page:

2D Array Basics
Matrix Traversal
Matrix Calculations
Diagonal Operations
Practical Matrix Problems

Syntax

markup

matrix = [[a, b, c],
          [d, e, f]]
for row in range(len(matrix)):
    for col in range(len(matrix[row])):
        process(matrix[row][col])

2D Array Basics

एक two-dimensional array data को rows और columns के रूप में store करता है, effectively arrays का एक array, जो naturally grid-like data represent करता है जैसे एक spreadsheet, एक game board, या एक image के pixels।

उदाहरण: 2D Array Basics

#include <iostream>
using namespace std;
int main() {
    int grid[2][3] = {{1, 2, 3}, {4, 5, 6}}; // rows and columns
    cout << "grid[1][2]: " << grid[1][2] << endl;
    return 0;
}

public class Main {
    public static void main(String[] args) {
        int[][] grid = {{1, 2, 3}, {4, 5, 6}}; // rows and columns
        System.out.println("grid[1][2]: " + grid[1][2]);
    }
}

grid = [[1, 2, 3], [4, 5, 6]]  # rows and columns
print("grid[1][2]:", grid[1][2])

#include <stdio.h>
int main() {
    int grid[2][3] = {{1, 2, 3}, {4, 5, 6}}; /* rows and columns */
    printf("grid[1][2]: %d\n", grid[1][2]);
    return 0;
}

Matrix Traversal

किसी 2D array के हर cell को visit करना आमतौर पर दो nested loops उपयोग करता है: outer loop rows में चलता है, और inner loop उस row के अंदर columns में चलता है, आपको हर element बिल्कुल एक बार access करने देते हुए।

उदाहरण: Matrix Traversal

#include <iostream>
using namespace std;
int main() {
    int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) cout << grid[i][j] << " ";
        cout << endl;
    }
    return 0;
}

public class Main {
    public static void main(String[] args) {
        int[][] grid = {{1, 2, 3}, {4, 5, 6}};
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) System.out.print(grid[i][j] + " ");
            System.out.println();
        }
    }
}

grid = [[1, 2, 3], [4, 5, 6]]
for row in grid:
    for val in row:
        print(val, end=" ")
    print()

#include <stdio.h>
int main() {
    int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) printf("%d ", grid[i][j]);
        printf("\n");
    }
    return 0;
}

Matrix Calculations

आप elementwise operations perform कर सकते हैं जैसे दो एक जैसे size वाले matrices जोड़ना, या इसे traverse करते समय दोनों loops में हर element sum करके एक matrix को एक single value में reduce करना।

उदाहरण: Matrix Calculations

#include <iostream>
using namespace std;
int main() {
    int a[2][2] = {{1, 2}, {3, 4}};
    int b[2][2] = {{5, 6}, {7, 8}};
    int sum[2][2], total = 0;
    for (int i = 0; i < 2; i++)
        for (int j = 0; j < 2; j++) {
            sum[i][j] = a[i][j] + b[i][j];
            total += sum[i][j];
        }
    cout << "sum[0][0]: " << sum[0][0] << ", Total of all cells: " << total << endl;
    return 0;
}

public class Main {
    public static void main(String[] args) {
        int[][] a = {{1, 2}, {3, 4}};
        int[][] b = {{5, 6}, {7, 8}};
        int[][] sum = new int[2][2];
        int total = 0;
        for (int i = 0; i < 2; i++)
            for (int j = 0; j < 2; j++) {
                sum[i][j] = a[i][j] + b[i][j];
                total += sum[i][j];
            }
        System.out.println("sum[0][0]: " + sum[0][0] + ", Total of all cells: " + total);
    }
}

a = [[1, 2], [3, 4]]
b = [[5, 6], [7, 8]]
result = [[a[i][j] + b[i][j] for j in range(2)] for i in range(2)]
total = sum(sum(row) for row in result)
print("sum[0][0]:", result[0][0], ", Total of all cells:", total)

#include <stdio.h>
int main() {
    int a[2][2] = {{1, 2}, {3, 4}};
    int b[2][2] = {{5, 6}, {7, 8}};
    int sum[2][2], total = 0;
    for (int i = 0; i < 2; i++)
        for (int j = 0; j < 2; j++) {
            sum[i][j] = a[i][j] + b[i][j];
            total += sum[i][j];
        }
    printf("sum[0][0]: %d, Total of all cells: %d\n", sum[0][0], total);
    return 0;
}

Diagonal Operations

एक square matrix में, main diagonal में हर वह cell शामिल है जहां row index column index के बराबर है (matrix[i][i]), जो symmetry, identity matrices, या rotation से जुड़ी problems में अक्सर आता है।

उदाहरण: Diagonal Operations

#include <iostream>
using namespace std;
int main() {
    int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int diagSum = 0;
    for (int i = 0; i < 3; i++) diagSum += matrix[i][i]; // main diagonal
    cout << "Main diagonal sum: " << diagSum << endl;
    return 0;
}

public class Main {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int diagSum = 0;
        for (int i = 0; i < 3; i++) diagSum += matrix[i][i]; // main diagonal
        System.out.println("Main diagonal sum: " + diagSum);
    }
}

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
diag_sum = sum(matrix[i][i] for i in range(3))  # main diagonal
print("Main diagonal sum:", diag_sum)

#include <stdio.h>
int main() {
    int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int diagSum = 0;
    for (int i = 0; i < 3; i++) diagSum += matrix[i][i]; /* main diagonal */
    printf("Main diagonal sum: %d\n", diagSum);
    return 0;
}

Practical Matrix Problems

Matrix problems nested-loop thinking के लिए excellent practice हैं, और आम exercises में एक matrix को transpose करना (rows और columns swap करना), इसे 90 degrees rotate करना, या पूरे grid में एक value search करना शामिल है।

उदाहरण: Practical Matrix Problems

#include <iostream>
using namespace std;
int main() {
    int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int transposed[3][2];
    for (int i = 0; i < 2; i++)
        for (int j = 0; j < 3; j++)
            transposed[j][i] = matrix[i][j]; // swap rows and columns
    cout << "transposed[2][1]: " << transposed[2][1] << endl;
    return 0;
}

public class Main {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}};
        int[][] transposed = new int[3][2];
        for (int i = 0; i < 2; i++)
            for (int j = 0; j < 3; j++)
                transposed[j][i] = matrix[i][j]; // swap rows and columns
        System.out.println("transposed[2][1]: " + transposed[2][1]);
    }
}

matrix = [[1, 2, 3], [4, 5, 6]]
transposed = [[matrix[i][j] for i in range(2)] for j in range(3)]  # swap rows/cols
print("transposed[2][1]:", transposed[2][1])

#include <stdio.h>
int main() {
    int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int transposed[3][2];
    for (int i = 0; i < 2; i++)
        for (int j = 0; j < 3; j++)
            transposed[j][i] = matrix[i][j];
    printf("transposed[2][1]: %d\n", transposed[2][1]);
    return 0;
}

Chapter Quiz — Complete all 8 topics to unlock

0/8 topics done

Complete these topics first:

← Previous Lesson Array Traversal and Operations Next Lesson → Sliding Window Technique