C भाषा में, दो-आयामी एरे (Two Dimensional Array) कई संख्यात्मक डेटा को एक संरचित तरीके से संग्रहीत करने के लिए उपयोग किया जाता है। यह एक आकार के दो बढ़ते हुए सूचकांकों का होता है जिसे रो और कॉलम के रूप में जाना जाता है।
निम्नलिखित Arrays का सचित्र प्रतिनिधित्व (pictorial representation) है
एक दो-आयामी एरे एक टेबल के रूप में भी जाना जाता है। टेबल में पंक्तियों और स्तंभों के संख्या बहुत अधिक हो सकती हैं, जो इसे एक बहुत बड़े संख्यात्मक डेटा सेट को संग्रहित करने के लिए उपयोगी बनाता है।
एक दो-आयामी एरे उस तत्वों की समूह होती है जिन्हें पंक्ति और स्तंभों के जोड़ में संरचित किया जाता है। दो-आयामी एरे को दो बैंक्स के रूप में भी सोचा जा सकता है जहां प्रत्येक बैंक में एक-एक आइटम होता है और प्रत्येक बैंक के सूचकांक एक डेटा पंक्ति और एक स्तंभ को निर्दिष्ट करता है।
Two Dimensional Arrays को declare करना
C भाषा में, दो-आयामी एरे घोषित करने के लिए आप निम्नलिखित विधि का उपयोग कर सकते हैं:
data_type array_name[row_size][column_size];
यहां, data_type आपके द्वारा एरे में रखने वाले तत्वों का डेटा टाइप होता है, array_name एरे का नाम है, row_size एरे की पंक्तियों की संख्या होती है और column_size एरे की स्तंभों की संख्या होती है।
उदाहरण के लिए, यदि आप एक 3x4 दो-आयामी एरे घोषित करना चाहते हैं, जिसमें संख्याएं स्टोर की जाएँगी, तो निम्न दिए गए संदर्भ का उपयोग करके आप इसे घोषित कर सकते हैं:
int matrix[3][4];
इससे, matrix नामक एक 3x4 दो-आयामी एरे बनेगा जो int डेटा टाइप के तत्वों को स्टोर करेगा।
Two Dimensional Arrays को Initializing करना
C भाषा में, दो-आयामी एरे को आप निम्नलिखित तरीकों से इनिशियलाइज कर सकते हैं:
एक संख्या एक बार में:
आप निम्नलिखित विधि का उपयोग करके एक संख्या से सभी तत्वों को इनिशियलाइज कर सकते हैं:
int matrix[3][4] = { {1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12} };
एक-एक संख्या:
आप एक-एक संख्या के लिए नेस्टेड फॉर लूप का उपयोग करके इनिशियलाइज कर सकते हैं:
int matrix[3][4];
int num = 1;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
matrix[i][j] = num;
num++;
}
}
एक संख्या से भरी एक स्ट्रिंग:
आप एक संख्या से भरी एक स्ट्रिंग का उपयोग करके एक-एक संख्या इनिशियलाइज कर सकते हैं:
int matrix[3][4] = { "1234",
"5678",
"9101112" };
इससे, एक 3x4 एरे बनता है जिसमें संख्याएं इस प्रकार स्टोर होती हैं: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}।
अन्य विधियों:
आप अन्य विधियों का उपयोग भी कर सकते हैं, जैसे:
int matrix[3][4] = { {0} }; // सभी तत्वों को 0 से भरें
यहां एक उदाहरण है जिसमें दो-आयामी एरे का उपयोग किया जाता है:
int matrix[2][3] = {
{1, 2, 3}, // पहली पंक्ति
{4, 5, 6} // दूसरी पंक्ति
};
यहां, `matrix` नामक दो-आयामी एरे घोषित किया गया है जिसमें दो पंक्तियां और तीन स्तंभ हैं। `matrix[0][0]` उपयोग करके हम पहले पंक्ति का पहला तत्व प्राप्त कर सकते हैं, जो `1` है। उसी तरह, `matrix[1][2]` उपयोग करके हम दूसरी पंक्ति का तीसरा तत्व प्राप्त कर सकते हैं, जो `6` है।
इस उदाहरण में, दो-आयामी एरे के प्रत्येक तत्व को `matrix[i][j]` द्वारा पहुंचा जा सकता है, जहां `i` पंक्ति और `j` स्तंभ को निर्दिष्ट करता है।
एक एरे को इंडेक्स के साथ एक्सेस करते समय सावधान रहना चाहिए क्योंकि अगर आप एरे के बाहर के इंडेक्स का उपयोग करते हैं तो आपको अपने कोड में error उत्पन्न कर सकते हैं। इसलिए, समझने से पहले कि कैसे एक एरे को एक्सेस किया जाता है, आपको यह सुनिश्चित करना चाहिए कि आप संभवतः इंडेक्स को सही रूप से निर्दिष्ट कर रहे हैं।
अगले उदाहरण में, हम एक for लूप का उपयोग करते हुए एक एरे में संख्याओं को जोड़ने वाले एक प्रोग्राम दिखाएँगे:
#include <stdio.h>
int main() {
int numbers[5] = {5, 10, 15, 20, 25};
int sum = 0;
for(int i = 0; i < 5; i++) {
sum += numbers[i];
}
printf("Sum = %d", sum);
return 0;
}
Two Dimensional Array के Elements को Accessing करना
C भाषा में 2D array के एलिमेंट को एक्सेस करने के लिए, दो इंडेक्स उपयोग करने होते हैं। जिस प्रकार से 1D array में एक्सेस करते हैं, उससे भिन्नता यह है कि 2D array में आपको पहले row नंबर और फिर column नंबर का उपयोग करके एक्सेस करना होता है।
इस तरह से एक 2D array के एलिमेंट को एक्सेस किया जा सकता है:
int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; // 2D array को इनिशियलाइज़ किया गया है
// 2D array के एक्सेस करने के लिए दो इंडेक्स का उपयोग करें
int element = arr[1][2]; // arr[1][2] एक्सेस किया गया है, जो 6 है
यहां, arr[1][2] के माध्यम से 2D array का तीसरा रो और दूसरा कॉलम का एलिमेंट, जो 6 है, एक्सेस किया गया है।
यहां, हमने numbers नामक एक int एरे बनाया है जिसमें 5 इंटीजर तत्व हैं। हमने sum नामक एक अन्य int में 0 को सेट कर दिया है। उसके बाद हमने for लूप का उपयोग करके numbers एरे के तत्वों को जोड़ा और सम के रूप में sum में संग्रहित किया। अंत में हमने printf() फंक्शन का उपयोग करके sum का मान प्रिंट किया।
C भाषा में Two Dimensional Arrays का उदहारण
दो आयामी (Two Dimensional) Array दो सूचकों के एक समूह का प्रतिनिधित्व करता है। इसका उपयोग दो या दो से अधिक विस्तृत सूचियों को एक स्थान पर संग्रहित करने के लिए किया जाता है।
उदाहरण के लिए, आप एक 10x10 के चेस बोर्ड को संग्रहीत करना चाहते हैं। यहां, प्रत्येक बॉक्स के लिए एक आयाम संख्या दर्शाता है जो उसके पंक्ति और स्तंभ की संख्या होती है।
इसके लिए आप एक 2 आयामी (2D) Array बना सकते हैं, जिसमें प्रत्येक बॉक्स के रूप में दो आयाम होंगे। उदाहरण के लिए, निम्नलिखित टेबल में, एक दो आयामी (2D) Array दिखाया गया है, जिसे चेस बोर्ड की स्थिति दर्शाता है।
int board[8][8] = {
{-1,-2,-3,-4,-5,-3,-2,-1},
{-6,-6,-6,-6,-6,-6,-6,-6},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{6, 6, 6, 6, 6, 6, 6, 6},
{1, 2, 3, 4, 5, 3, 2, 1}
};
यहां, आप देख सकते हैं कि दो आयामी (2D) Array का उपयोग चेस बोर्ड को बताता है
Multi dimensional Arrays बहु आयामी ऐरे
सी में मल्टी-डाइमेंशनल एरे एक ऐसी एरे होती है जो एक से अधिक आयाम वाली होती है। इन्हें पंक्तियों और स्तंभों वाली एक तालिका या ऊंचाई, चौड़ाई और गहराई वाले एक घन में भी समझा जा सकता है। मल्टी-डाइमेंशनल एरे के तत्वों को एक कम्बिनेशन ऑफ इंडेक्स का उपयोग करके एक्सेस किया जाता है, जहां प्रत्येक इंडेक्स एरे की एक विशिष्ट आयाम को दर्शाता है।
सी में, मल्टी-डाइमेंशनल एरे निम्नलिखित वाक्य संरचना का उपयोग करके घोषित की जाती है:
data_type array_name[size1][size2]...[sizeN];
यहाँ, डेटा_टाइप एरे में तत्वों की डेटा टाइप होती है, एरे_नाम एरे का नाम होता है, और आयाम_1, आयाम_2, ..., आयाम_N एरे के प्रत्येक आयाम का आकार होता है।
एक मल्टी-डाइमेंशनल एरे को इनिशियलाइज़ करने के लिए, आप हर आयाम को दर्शाने के लिए नेस्टेड ब्रेस का उपयोग कर सकते हैं।
C भाषा में Multi-Dimensional Arrays को डिक्लेयर, इनिशियलाइज और एक्सेस करना एक साथ एक दूसरे के समान होता है।
यहां हम एक Multi-Dimensional Array को तीन डाइमेंशन्स में लेते हैं।
Array का डिक्लेयर करना
Multi-Dimensional Arrays को डिक्लेयर करने के लिए आपको बेसिक सिंटैक्स का उपयोग करना होगा।
data_type array_name[size1][size2][size3];
जहाँ, data_type आपके एरे के संदर्भ और डेटा के टाइप को दर्शाता है, array_name एरे के नाम को दर्शाता है, size1 एक इंटीजर वैल्यू होती है जो एरे के पहले इंडेक्स की संख्या होती है, size2 एक इंटीजर वैल्यू होती है जो एरे के दूसरे इंडेक्स की संख्या होती है और size3 एक इंटीजर वैल्यू होती है जो एरे के तीसरे इंडेक्स की संख्या होती है।
यहां एक उदाहरण है जो एक तीन-डाइमेंशनल एरे को डिक्लेयर करता है:
int myArray[3][4][2];
इस उदाहरण में, myArray एक 3 x 4 x 2 एरे है। यहाँ 3 एक्सिस, 4 रोज़ और 2 कॉलम हैं।
Array का इनिशियलाइज़ करना
Multi-dimensional Arrays को initialize करने के लिए, हम आमतौर पर एक एकल फोर लूप का उपयोग करते हैं। उदाहरण के लिए, एक 2D Array को इस प्रकार इनिशलाइज़ किया जा सकता है:
int myArray[3][4] = {{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}};
इस मामले में, myArray घोषित की गई है और उसे ऊपर दिए गए ढंग से इनिशलाइज़ किया गया है।
Multi-dimensional Arrays के एक्सेस करने के लिए, हम आमतौर पर एक समान ढंग से इस्तेमाल करते हैं जैसे हम 2D Arrays के साथ करते हैं, बस इसमें हम अधिक आयाम जोड़ते हैं।
Multi dimensional Arrays को access करना
C भाषा में Multi-dimensional arrays को access करने के लिए, समान रूप से एक-एक डाइमेंशन को एक-एक करके एक्सेस किया जाता है। निम्नलिखित उदाहरण में, हम एक 3x3 मैट्रिक्स बनाते हैं और उसे एक्सेस करते हैं:
#include <stdio.h>
int main() {
int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
// accessing the elements of the array
printf("Element at arr[0][0]: %d\n", arr[0][0]);
printf("Element at arr[0][1]: %d\n", arr[0][1]);
printf("Element at arr[1][2]: %d\n", arr[1][2]);
printf("Element at arr[2][1]: %d\n", arr[2][1]);
return 0;
}
इस उदाहरण में, हम एक 3x3 मैट्रिक्स बनाते हैं जिसमें 1 से 9 तक के नंबर होते हैं। फिर हम उसके विभिन्न एलीमेंट को एक्सेस करते हैं। arr[0][0] में पहला एलिमेंट होगा जो 1 होगा, arr[0][1] में दूसरा एलिमेंट होगा जो 2 होगा, और इसी तरह से बाकी एलीमेंट्स एक्सेस किए जाएंगे।
3 dimensional Arrays को declare, Initializing और access करना
एक 3-dimensional array तीन आयामों (dimensions) के साथ आता है। C भाषा में, 3-dimensional array को इस तरह से declare किया जाता है:
data_type array_name[size1][size2][size3];
यहां, data_type वे डेटा टाइप हैं जो आप इस array में store करना चाहते हैं, array_name array का नाम है, और size1 , size2 और size3 array के तीन आयाम हैं।
जैसे कि एक तीन आयामी array को initialize करने के लिए, निम्नलिखित संख्याओं का एक लिस्ट बनाई जा सकती है:
int arr[2][3][2] = {
{ {1, 2}, {3, 4}, {5, 6} },
{ {7, 8}, {9, 10}, {11, 12} }
};
यहां, इस array का नाम arr है, जो 2x3x2 आकार का है। संख्याओं का एक लिस्ट दिखाई गई है जो इस array के सभी elements को initialize करती है।
3-dimensional array के elements को access करने के लिए, आप [] ऑपरेटर का उपयोग करते हुए array के तीनों आयामों को उल्लंघन करने की आवश्यकता होती है। निम्नलिखित कोड से आप इसकी समझ पा सकते हैं:
printf("%d", arr[1][2][1]);
इस उदाहरण में, arr array के 2nd index पर स्थित एक 2-dimensional array का दूसरा element (जिसका अंतिम index 1 है) एक integer है।
Passing Arrays को Function Arguments की तरह करना
C भाषा में Arrays को function में arguments के रूप में पास करने के लिए, array का pointer बनाकर function को pass किया जाता है।
जब हम एक array को function को pass करते हैं, तो यह pointer के रूप में पास किया जाता है। इसलिए, function को उस array के पते का पता हो जाता है और इसे modify कर सकता है।
यहां एक उदाहरण है:
#include <stdio.h>
void printArray(int *arr, int size) {
int i;
for(i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
}
int main() {
int arr[] = {1, 2, 3, 4, 5};
int size = sizeof(arr)/sizeof(int);
printArray(arr, size);
return 0;
}
यहां, printArray() function int pointer और int size के 2 arguments के रूप में define किया गया है। यह function उस array के पते का पता लगाता है जिसे हम main() function में declare किया है, और उसे print करता है।
main() function में, arr array declare किया गया है जिसे हम printArray() function को pass करते हैं। उस array के size को sizeof() operator के माध्यम से calculate किया जाता है।
यह program निम्नलिखित output को generate करेगा:
1 2 3 4 5
C भाषा में Passing Arrays as Function Arguments कितनी तरह से करते है
C भाषा में Arrays को function में दो तरीकों से pass किया जाता है:
Pass by Reference:
इसमें, function के parameter में array का address (pointer) pass किया जाता है जिससे function को array के अंदर के elements को modify करने में आसानी होती है।
उदाहरण:
void modifyArray(int arr[], int size){
for(int i=0;i<size;i++){
arr[i] = arr[i] * 2;
}
}
int main(){
int arr[5] = {1,2,3,4,5};
modifyArray(arr, 5);
return 0;
}
Pass by Value:
इसमें, function के parameter में array का copy पास किया जाता है। यह original array को modify नहीं करता है।
उदाहरण:
void printArray(int arr[], int size){
for(int i=0;i<size;i++){
printf("%d ", arr[i]);
}
}
int main(){
int arr[5] = {1,2,3,4,5};
printArray(arr, 5);
return 0;
}
C भाषा में function से array को return करना
C भाषा में, एक array को function से return करने के लिए, एक pointer variable का उपयोग करते हैं। function में, array को pointer variable में convert करते हैं और फिर उस pointer variable को return करते हैं।
इसके लिए, function को array के data type से अलग एक pointer data type को return करना होगा। उदाहरण के लिए, यदि हम int array को return करना चाहते हैं, तो हम इस तरह की function declaration करेंगे:
int* functionName();
इसके बाद, function body में, हम array को pointer में convert करेंगे और pointer को return करेंगे।
यहाँ एक उदाहरण दिया गया है:
#include <stdio.h>
// function to return an array
int* getArray() {
static int arr[3] = {1, 2, 3}; // static array
return arr;
}
int main() {
int* ptr;
ptr = getArray();
for (int i = 0; i < 3; i++) {
printf("%d ", *(ptr + i));
}
return 0;
}
यहाँ, getArray() function array को return करता है जो pointer variable ptr में store किया जाता है। फिर for loop का उपयोग करके array elements को print किया जाता है।
एक और दो Dimensional Array में अंतर
C भाषा में, एक आयामी (one-dimensional) एरे एक ही चित्रण में अंकों की एक सूची होती है जबकि दो-आयामी (two-dimensional) एरे तालिकाओं के एक समूह होते हैं, जो एक-आयामी तालिका की तरह होता है, लेकिन यहां यह एक समूह होता है, जिसे आप "पंक्ति" और "स्तंभ" के रूप में समझ सकते हैं। आप इसे एक तालिका के रूप में सोच सकते हैं, जिसे संख्या या अक्षरों के जोड़ों की एक मैट्रिक्स या तालिका के रूप में वर्णित किया जा सकता है। इसलिए, एक-आयामी तालिका अनुक्रमणिक एक संख्या होती है जबकि दो-आयामी तालिका अनुक्रमणिक दो संख्याओं होती हैं।
एक आयताकार (one-dimensional) एरे डेटा को स्टोर करने के लिए इस्तेमाल किया जाता है जबकि दो आयताकार (two-dimensional) एरे डेटा को रो और कॉलम में स्टोर करने के लिए इस्तेमाल किया जाता है।
यदि एक आयताकार (one-dimensional) एरे में डेटा को स्टोर करने के लिए हम एक वेरिएबल का उपयोग करते हैं तो दो आयताकार (two-dimensional) एरे में हम दो वेरिएबल्स का उपयोग करते हैं जो एक के बाद एक लिखे जाते हैं। इस प्रकार के एरे दो चारण (dimensions) होते हैं - पहला चारण रो नंबर होता है, और दूसरा चारण कॉलम नंबर होता है।
इस तरह के एरे में डेटा को स्टोर करने के लिए हम नेस्टेड फॉर लूप का उपयोग करते हैं। एक नेस्टेड फॉर लूप रो नंबर के लिए और दूसरा नेस्टेड फॉर लूप कॉलम नंबर के लिए होता है। c भाषा में एक और दो Dimensional Array में अंतर को उदाहरण से समझाये
ChatGPT
एक-आयतीय एरे और दो-आयतीय एरे में अंतर निम्नलिखित उदाहरण के माध्यम से समझाया जा सकता है।
एक-आयतीय एरे:
#include <stdio.h>
int main() {
int arr[5] = {1, 2, 3, 4, 5};
printf("arr[2] = %d\n", arr[2]); // Output: arr[2] = 3
printf("*(arr+2) = %d\n", *(arr+2)); // Output: *(arr+2) = 3
return 0;
}
इस उदाहरण में, हमने arr नामक एक-आयतीय एरे बनाया है, जिसमें 5 अंश होते हैं। हम arr एरे के 2 वें अंश को arr[2] या *(arr+2) के रूप में पहुँच सकते हैं।
दो-आयतीय एरे:
#include <stdio.h>
int main() {
int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
printf("arr[1][2] = %d\n", arr[1][2]); // Output: arr[1][2] = 6
printf("*(*(arr+1)+2) = %d\n", *(*(arr+1)+2)); // Output: *(*(arr+1)+2) = 6
return 0;
}
इस उदाहरण में, हमने arr नामक दो-आयतीय एरे बनाया है, जिसमें 2 पंक्तियाँ और 3 स्तंभ होते हैं। हम arr एरे के 1 वीं पंक्ति के 3 वें स्तंभ को arr[1][2] या *(*(arr+1)+2) के रूप में पहुँच सकते हैं।
आप इस प्रकार से ऊपरोक्त उदाहरण को पूरा कर सकते हैं:
#include <stdio.h>
int main() {
int i, j, arr[3][3], sum = 0;
// Initializing the array elements
for(i = 0; i < 3; i++) {
for(j = 0; j < 3; j++) {
arr[i][j] = i + j;
}
}
// Accessing and printing the array elements
printf("Array elements:\n");
for(i = 0; i < 3; i++) {
for(j = 0; j < 3; j++) {
printf("%d ", arr[i][j]);
}
printf("\n");
}
// Finding the sum of diagonal elements
for(i = 0; i < 3; i++) {
sum += arr[i][i];
}
printf("Sum of diagonal elements: %d\n", sum);
return 0;
}
इस प्रोग्राम के बाद, आप निम्न आउटपुट को देखेंगे:
Array elements:
0 1 2
1 2 3
2 3 4
Sum of diagonal elements: 6
इसमें एक 3x3 आयाम वाली एक दो-आयामी सरणी arr बनाई गई है जिसे एक नेस्टेड फॉर लूप का उपयोग करके अपनी मानों से भरा गया है। फिर इसके उपलब्ध तत्वों को एक नेस्टेड फॉर लूप का उपयोग करके प्रिंट किया जाता है। इसके बाद, एक अन्य नेस्टेड फॉर लूप का उपयोग करके मुख्य डायागोनल तत्वों के योग को पाया जाता है और उसे मुद्रित किया जाता है।