द्वि-आयामी सरणी। मैट्रिक्स का निर्माण और इसके तत्वों का आउटपुट

पास्कल में एक द्वि-आयामी सरणी को एक-आयामी सरणी के रूप में माना जाता है, जिसके तत्वों का प्रकार भी एक सरणी (सरणी की एक सरणी) है। द्वि-आयामी पास्कल सरणियों में तत्वों की स्थिति का वर्णन दो सूचकांकों द्वारा किया जाता है। उन्हें एक आयताकार तालिका या मैट्रिक्स के रूप में दर्शाया जा सकता है।

आयाम 3 * 3 के साथ दो-आयामी पास्कल सरणी पर विचार करें, अर्थात इसमें तीन पंक्तियाँ होंगी, और प्रत्येक पंक्ति में तीन तत्व होंगे:

प्रत्येक तत्व की अपनी संख्या होती है, जैसे एक-आयामी सरणियाँ, लेकिन अब संख्या में पहले से ही दो संख्याएँ होती हैं - उस पंक्ति की संख्या जिसमें तत्व स्थित है, और स्तंभ की संख्या। इस प्रकार, तत्व संख्या पंक्ति और स्तंभ के प्रतिच्छेदन द्वारा निर्धारित की जाती है। उदाहरण के लिए, 21 दूसरी पंक्ति में और पहले कॉलम में तत्व है।

द्वि-आयामी पास्कल सरणी का विवरण।

द्वि-आयामी पास्कल सरणी घोषित करने के कई तरीके हैं।

हम पहले से ही जानते हैं कि एक-आयामी सरणी का वर्णन कैसे किया जाता है, जिसके तत्व किसी भी प्रकार के हो सकते हैं, और इसके परिणामस्वरूप, तत्व स्वयं सरणी हो सकते हैं। प्रकारों और चरों के निम्नलिखित विवरण पर विचार करें:

प्रकार
वेक्टर = सरणी<тип_элементов>;
मैट्रिक्स = वेक्टर की सरणी;
वर्म: मैट्रिक्स;

हमने एक द्वि-आयामी पास्कल सरणी m घोषित की है, जिसमें 10 पंक्तियाँ हैं, जिनमें से प्रत्येक में 5 कॉलम हैं। इस मामले में, प्रत्येक i -th लाइन को m [i], और प्रत्येक j -th एलिमेंट को i -th लाइन - m [ i , j ] के अंदर एक्सेस किया जा सकता है।

द्वि-आयामी पास्कल सरणियों के लिए टाइप परिभाषाएँ भी एक पंक्ति में निर्दिष्ट की जा सकती हैं:

प्रकार
मैट्रिक्स = सरणी की सरणी< тип элементов >;
या इससे भी सरल:
प्रकार
मैट्रिक्स = सरणी<тип элементов>;

द्वि-आयामी सरणी के तत्वों तक पहुँचने का रूप है: M [i, j]। इसका मतलब है कि हम i -th रो और j -th कॉलम में स्थित एलिमेंट प्राप्त करना चाहते हैं। यहां मुख्य बात स्तंभों के साथ पंक्तियों को भ्रमित नहीं करना है, अन्यथा हम फिर से एक गैर-मौजूद तत्व तक पहुंच प्राप्त कर सकते हैं। उदाहरण के लिए, तत्व M तक पहुँचने का सही संकेतन है, लेकिन इससे प्रोग्राम में त्रुटि हो सकती है।

2डी पास्कल सरणियों के साथ बुनियादी संचालन

एक-आयामी सरणियों के साथ बुनियादी संचालन के बारे में जो कुछ भी कहा गया है वह मैट्रिस के लिए भी सही है। एक ही प्रकार के पूरे मैट्रिसेस पर की जा सकने वाली एकमात्र क्रिया असाइनमेंट है। यही है, अगर हमारे पास कार्यक्रम में वर्णित एक ही प्रकार के दो मैट्रिक्स हैं, उदाहरण के लिए,

प्रकार
मैट्रिक्स = पूर्णांक की सरणी;
वर
ए, बी: मैट्रिक्स;

फिर कार्यक्रम के निष्पादन के दौरान मैट्रिक्स को असाइन करना संभव है एमैट्रिक्स मान बी(ए: = बी)। अन्य सभी ऑपरेशन तत्व-दर-तत्व किए जाते हैं, और सभी मान्य संचालन जो डेटा प्रकार के सरणी तत्वों के लिए परिभाषित किए जाते हैं, तत्वों पर किए जा सकते हैं। इसका मतलब यह है कि यदि सरणी में पूर्णांक होते हैं, तो पूर्णांक के लिए परिभाषित संचालन इसके तत्वों पर किया जा सकता है, लेकिन यदि सरणी में वर्ण होते हैं, तो वर्णों के साथ काम करने के लिए परिभाषित संचालन उन पर लागू होते हैं।

द्वि-आयामी पास्कल सरणी का इनपुट।

एक-आयामी सरणी के तत्वों को क्रमिक रूप से दर्ज करने के लिए, हमने लूप के लिए उपयोग किया, जिसमें हमने सूचकांक मान को 1 से अंतिम में बदल दिया। लेकिन दो-आयामी पास्कल सरणी में एक तत्व की स्थिति दो सूचकांकों द्वारा निर्धारित की जाती है: पंक्ति संख्या और स्तंभ संख्या। इसका मतलब है कि हमें पहली से आखिरी तक पंक्ति संख्या को क्रमिक रूप से बदलने की आवश्यकता होगी और प्रत्येक पंक्ति में कॉलम तत्वों पर पहली से आखिरी तक पुनरावृति करनी होगी। इसका मतलब है कि हमें दो लूप की आवश्यकता है, और उनमें से एक को दूसरे में नेस्ट किया जाएगा।

कीबोर्ड से द्वि-आयामी पास्कल सरणी दर्ज करने के एक उदाहरण पर विचार करें:

प्रकार
मैट्रिक्स = पूर्णांक की सरणी;
वर
ए,: मैट्रिक्स;
मैं, जे: पूर्णांक; (सरणी अनुक्रमणिका)
शुरू
मैं के लिए: = 1 से 5 करते हैं (सभी पंक्तियों के माध्यम से लूप)
रीडलन (ए [आई, जे]); (i-th लाइन और j-th कॉलम में एलिमेंट की कीबोर्ड एंट्री)

एक द्वि-आयामी पास्कल सरणी को यादृच्छिक रूप से भरा जा सकता है, अर्थात। यादृच्छिक (एन) फ़ंक्शन का उपयोग करें, और मैट्रिक्स के प्रत्येक तत्व को कुछ अभिव्यक्ति का मान भी निर्दिष्ट करें। द्वि-आयामी पास्कल सरणी को भरने का तरीका कार्य के आधार पर चुना जाता है, लेकिन किसी भी स्थिति में, प्रत्येक पंक्ति में प्रत्येक तत्व और प्रत्येक स्तंभ को निर्धारित किया जाना चाहिए।

स्क्रीन पर द्वि-आयामी पास्कल सरणी प्रदर्शित करना।

द्वि-आयामी पास्कल सरणी के तत्वों का आउटपुट भी क्रमिक रूप से किया जाता है, प्रत्येक पंक्ति और प्रत्येक स्तंभ के तत्वों को प्रिंट करना आवश्यक है। साथ ही, मैं चाहता हूं कि एक ही पंक्ति के तत्वों को एक साथ मुद्रित किया जाए, यानी। एक पंक्ति में, और स्तंभ के तत्व एक के नीचे एक स्थित थे। ऐसा करने के लिए, क्रियाओं का निम्नलिखित क्रम करें (पिछले उदाहरण में वर्णित सरणी के लिए प्रोग्राम के टुकड़े पर विचार करें):

मैं के लिए: = 1 से 5 करते हैं (सभी पंक्तियों के माध्यम से लूप)
शुरू
जे के लिए: = 1 से 10 तक (स्तंभों द्वारा पंक्ति के सभी तत्वों के माध्यम से पुनरावृति)
लिखें (ए [मैं, जे]: 4); (एक स्क्रीन लाइन में मैट्रिक्स की i -th पंक्ति में तत्वों को प्रिंट करना, जबकि प्रत्येक तत्व के आउटपुट के लिए 4 स्थान आवंटित किए गए हैं)
लेखन; (मैट्रिक्स में लाइन नंबर बदलने से पहले, आपको कर्सर को एक नई स्क्रीन लाइन की शुरुआत में ले जाना होगा)
समाप्त ;

टिप्पणी ( क्या यह महत्वपूर्ण है!): बहुत बार छात्र कार्यक्रमों में एक त्रुटि होती है जब किसी सरणी की स्क्रीन पर कीबोर्ड या आउटपुट से इनपुट का प्रयास निम्नानुसार किया जाता है: रीडल (ए), राइटलाइन (ए), जहां एएक सरणी चर है। साथ ही, वे संकलक के संदेश से हैरान हैं कि इस प्रकार के एक चर को पढ़ा या मुद्रित नहीं किया जा सकता है। शायद आप समझेंगे कि ऐसा क्यों नहीं किया जा सकता है यदि आप कल्पना करते हैं कि एन मग एक पंक्ति में खड़े हैं, और आपके हाथों में, उदाहरण के लिए, पानी की केतली। क्या आप "पानी डालो" के आदेश पर सभी मग एक साथ भर सकते हैं? आप कितनी भी कोशिश कर लें, आपको प्रत्येक मग में अलग से डालना होगा। सरणी के तत्वों को भरना और प्रदर्शित करना भी क्रमिक रूप से और तत्व द्वारा तत्व किया जाना चाहिए, क्योंकि कंप्यूटर मेमोरी में, सरणी तत्व लगातार कोशिकाओं में स्थित होते हैं।

मेमोरी में 2D पास्कल ऐरे का प्रतिनिधित्व करना

मशीन की स्मृति में एक सार सरणी के तत्वों को शारीरिक रूप से क्रमिक रूप से व्यवस्थित किया जाता है, जैसा कि वर्णित है। इस मामले में, प्रत्येक तत्व स्मृति में उसके आकार के अनुरूप बाइट्स की संख्या रखता है। उदाहरण के लिए, यदि सरणी में पूर्णांक प्रकार के तत्व होते हैं, तो प्रत्येक तत्व दो बाइट्स पर कब्जा कर लेगा। और संपूर्ण सरणी S^2 बाइट्स लेगा, जहां S सरणी में तत्वों की संख्या है।

और सरणियों से युक्त एक सरणी कितनी जगह लेगा, अर्थात। आव्यूह? जाहिर है: S i^S j , जहां S i पंक्तियों की संख्या है, और S j प्रत्येक पंक्ति में तत्वों की संख्या है। उदाहरण के लिए, प्रकार की एक सरणी के लिए

मैट्रिक्स = पूर्णांक की सरणी;

12 बाइट्स मेमोरी की आवश्यकता होती है।

इस सरणी के तत्वों को स्मृति में कैसे संग्रहीत किया जाएगा? स्मृति में मैट्रिक्स प्रकार के एक सरणी एम के लेआउट पर विचार करें।

प्रत्येक तत्व M प्रकार के पूर्णांक के लिए, दो मेमोरी सेल आवंटित किए जाते हैं। मेमोरी एलोकेशन नीचे से ऊपर की ओर किया जाता है। तत्वों को सूचकांक परिवर्तन के क्रम में रखा गया है, जो नेस्टेड लूप योजना से मेल खाती है: पहली पंक्ति पहले रखी जाती है, फिर दूसरी, तीसरी... पंक्ति के अंदर, तत्व क्रम में चलते हैं: पहला, दूसरा, और इसी तरह।

जैसा कि हम जानते हैं, किसी भी वेरिएबल तक पहुंच तभी संभव है, जब वेरिएबल स्टोर की गई मेमोरी लोकेशन का पता ज्ञात हो। प्रोग्राम लोड होने पर चर के लिए विशिष्ट मेमोरी आवंटित की जाती है, अर्थात, चर और सेल पते के बीच एक पारस्परिक पत्राचार स्थापित किया जाता है। लेकिन अगर हमने चर को एक सरणी के रूप में घोषित किया है, तो प्रोग्राम सरणी की शुरुआत का पता "जानता है", यानी इसका पहला तत्व। सरणी के अन्य सभी तत्वों तक पहुंच कैसे है? दो-आयामी सरणी के एक तत्व को संग्रहीत करने वाले मेमोरी सेल तक वास्तविक पहुंच के दौरान, सिस्टम सूत्र का उपयोग करके अपने पते की गणना करता है:

Addr + SizeElem * Cols *(I -1)+ SizeElem *(J -1),

जहां Addr वास्तविक प्रारंभिक पता है जहां सरणी स्मृति में स्थित है; I , J - द्वि-आयामी सरणी में किसी तत्व की अनुक्रमणिका; SizeElem - सरणी तत्व आकार (उदाहरण के लिए, पूर्णांक तत्वों के लिए दो बाइट्स); कोल्स एक पंक्ति में तत्वों की संख्या है।

अभिव्यक्ति SizeElem * Cols *(I -1)+ SizeElem *(J -1) को सरणी की शुरुआत से ऑफसेट कहा जाता है।

किसी सरणी के लिए कितनी मेमोरी आवंटित की जाती है?

एक सरणी के लिए कितनी मेमोरी आवंटित की जाती है, इस सवाल पर विचार न करें (हमने पिछले अनुभाग में इस पर चर्चा की थी), लेकिन सीमित मात्रा में स्मृति को देखते हुए सरणी का अधिकतम स्वीकार्य आकार क्या है।

मेमोरी को प्रोग्राम ऑपरेशन के लिए 64 केबी के सेगमेंट में आवंटित किया गया है, जिनमें से कम से कम एक को परिभाषित किया गया है डेटा खंड. यह इस खंड में है कि डेटा जिसे प्रोग्राम संसाधित करेगा वह स्थित है। कोई भी प्रोग्राम वेरिएबल एक से अधिक सेगमेंट में अवस्थित नहीं हो सकता है। इसलिए, भले ही खंड में केवल एक चर है, जिसे सरणी के रूप में वर्णित किया गया है, यह 65536 बाइट्स से अधिक प्राप्त नहीं कर सकता है। लेकिन लगभग निश्चित रूप से, सरणी के अलावा, डेटा खंड में कुछ और चर का वर्णन किया जाएगा, इसलिए सरणी के लिए आवंटित की जा सकने वाली मेमोरी की वास्तविक मात्रा सूत्र द्वारा पाई जाती है: 65536- S , जहां S की मात्रा है स्मृति पहले से ही अन्य चर के लिए आवंटित।

हमें ये जानने की ज़रूरत क्यों है? आश्चर्यचकित न होने के लिए, यदि संकलन के दौरान, संकलक एक सरणी घोषित करने के बारे में एक त्रुटि संदेश देगा जो कि प्रोग्राम में विवरण का सामना करने पर बहुत लंबा है (वाक्यविन्यास के संदर्भ में सही):

myArray = पूर्णांक की सरणी टाइप करें;

आप पहले से ही जानते हैं कि, पूर्णांकों के दो-बाइट प्रतिनिधित्व को देखते हुए, 65536/2 -1 = 32767 के बराबर तत्वों की संख्या के साथ एक सरणी घोषित करना वास्तव में संभव है। और तब ही जब कोई अन्य चर न हो। द्वि-आयामी सरणियों में और भी छोटी अनुक्रमणिका सीमाएँ होनी चाहिए।

द्वि-आयामी पास्कल सरणियों के साथ समस्याओं को हल करने के उदाहरण

कार्य:शून्येतर आव्यूह तत्वों का गुणनफल ज्ञात कीजिए।

समाधान:

• इस समस्या को हल करने के लिए, हमें चरों की आवश्यकता है: एक मैट्रिक्स जिसमें उदाहरण के लिए, पूर्णांक तत्व होते हैं; P, 0 के अलावा अन्य तत्वों का गुणनफल है; मैं , जे - सरणी अनुक्रमणिका; एन, एम - मैट्रिक्स में पंक्तियों और स्तंभों की संख्या।
• इनपुट डेटा N , M हैं - हम कीबोर्ड से उनके मान दर्ज करेंगे; मैट्रिक्स - हम मैट्रिक्स के इनपुट को एक प्रक्रिया के रूप में व्यवस्थित करेंगे, हम मैट्रिक्स को यादृच्छिक रूप से भरेंगे, अर्थात। यादृच्छिक () फ़ंक्शन का उपयोग करना।
• आउटपुट चर P (उत्पाद) का मान होगा।
• कार्यक्रम निष्पादन की शुद्धता की जांच करने के लिए, स्क्रीन पर मैट्रिक्स प्रदर्शित करना आवश्यक है, इसके लिए हम मैट्रिक्स प्रदर्शित करने की प्रक्रिया जारी करेंगे।
• समस्या के समाधान की प्रगति :

आइए पहले मुख्य कार्यक्रम के निष्पादन पर चर्चा करें, प्रक्रियाओं के कार्यान्वयन पर थोड़ी देर बाद चर्चा की जाएगी:

• हम एन और एम के मूल्यों का परिचय देते हैं;
• हम एक द्वि-आयामी पास्कल सरणी का परिचय देते हैं, इसके लिए हम प्रक्रिया vvod (a) की ओर मुड़ते हैं, जहाँ a एक मैट्रिक्स है;
• आइए परिणामी मैट्रिक्स को प्रिंट करें, इसके लिए हम प्रिंट (ए) प्रक्रिया की ओर मुड़ते हैं;
• चर P = 1 के लिए प्रारंभिक मान निर्दिष्ट करें;
• हम क्रमिक रूप से 1 से एनटी तक सभी पंक्तियों के माध्यम से जाएंगे, प्रत्येक पंक्ति में हम 1 से एमएच तक सभी कॉलम जे से गुजरेंगे, मैट्रिक्स के प्रत्येक तत्व के लिए हम स्थिति की जांच करेंगे: यदि कोई ij ? 0 है, तो गुणनफल P को तत्व a ij (P = P * a ij) से गुणा किया जाएगा;
• आइए मैट्रिक्स के गैर-शून्य तत्वों के उत्पाद का मान प्रदर्शित करें - P ;

अब बात करते हैं प्रक्रियाओं की।

टिप्पणी (क्या यह महत्वपूर्ण है!) पूर्वनिर्धारित प्रकार का कोई भी चर एक प्रक्रिया पैरामीटर हो सकता है, जिसका अर्थ है कि किसी सरणी को प्रक्रिया के पैरामीटर के रूप में पारित करने के लिए, इसके प्रकार को पहले से घोषित किया जाना चाहिए। उदाहरण के लिए:

प्रकार
मैट्रिक्स = पूर्णांक की सरणी;
प्रक्रिया प्राइमर (ए: मैट्रिक्स);
..............................

आइए अब अपनी प्रक्रियाओं पर वापस आते हैं।

मैट्रिक्स इनपुट प्रक्रिया को vvod कहा जाता है, प्रक्रिया पैरामीटर एक मैट्रिक्स है, और परिणामस्वरूप, इसे मुख्य कार्यक्रम में पास किया जाना चाहिए, इसलिए, पैरामीटर को संदर्भ द्वारा पारित किया जाना चाहिए। तब हमारी प्रक्रिया का हेडर इस तरह दिखेगा:

प्रक्रिया vvod (var m: मैट्रिक्स);

नेस्टेड लूप को एक प्रक्रिया में लागू करने के लिए, हमें स्थानीय काउंटर वैरिएबल की आवश्यकता होती है, जैसे k और h । मैट्रिक्स फिलिंग एल्गोरिथम पर पहले ही चर्चा की जा चुकी है, इसलिए हम इसे नहीं दोहराएंगे।

स्क्रीन पर मैट्रिक्स प्रदर्शित करने की प्रक्रिया को प्रिंट कहा जाता है, प्रक्रिया पैरामीटर एक मैट्रिक्स है, लेकिन इस मामले में यह एक इनपुट पैरामीटर है, इसलिए, इसे मान द्वारा पारित किया जाता है। इस प्रक्रिया का शीर्षक इस तरह दिखेगा:

प्रिंट प्रक्रिया (एम: मैट्रिक्स);

और फिर, प्रक्रिया के अंदर नेस्टेड छोरों को लागू करने के लिए, हमें काउंटरों की आवश्यकता है, उन्हें समान - k और h कहा जाए। स्क्रीन पर मैट्रिक्स प्रदर्शित करने के लिए एल्गोरिथ्म ऊपर वर्णित किया गया था, हम इस विवरण का उपयोग करेंगे।

कार्यक्रम उत्पादन;
प्रकार
मैट्रिक्स = पूर्णांक की सरणी;
वर
ए: मैट्रिक्स;
एन, एम, आई, जे: बाइट;
पी: पूर्णांक
प्रक्रिया vvod (var m: मैट्रिक्स);
वार के, एच: बाइट;
शुरू
i:=1 से n do के लिए (प्रक्रिया के लिए चर n वैश्विक है, और इसलिए "ज्ञात")
j:=1 से m do के लिए (प्रक्रिया के लिए चर m वैश्विक है, जिसका अर्थ है "ज्ञात")
एम: = यादृच्छिक (10);
समाप्त;
प्रिंट प्रक्रिया (एम: मैट्रिक्स);
वर्क, एच: बाइट;
शुरू
मैं के लिए:=1 से n do
शुरू
j:=1 से m do . के लिए
लिखें (एम: 4);
राइटलन;
समाप्त ;
समाप्त ;
शुरुआत (मुख्य कार्यक्रम की शुरुआत)
राइटलन ("मैट्रिक्स का आयाम दर्ज करें:");
रीडलन (एन, एम);
इनपुट (ए);
प्रिंट (ए);
पी: = 1;
मैं के लिए: = 1 से एन डू
j के लिए:=1 से M do
यदि एक<>0 तब p:=p*a;
राइटलन (पी);
समाप्त।

द्वि-आयामी सरणीडेटा संरचना जो प्रपत्र के आयताकार मैट्रिक्स को संग्रहीत करती है:

ए 11 ए 12 ए 13 ए 14 ए 15 ...ए 1mए 21 ए 22 ए 23 ए 24 ए 25 ...ए 2मीए 31 ए 32 ए 33 ए 34 ए 35 ...ए 3मीए 41 ए 42 ए 43 ए 44 ए 45 ...ए 4मीए 51 ए 52 ए 53 ए 54 ए 55 ...ए 5m... ... ... ... ... ... ... ए एन 1ए एन 2ए n3ए n4ए n5...ए एनएम

• एक मैट्रिक्स में, प्रत्येक तत्व पंक्ति संख्या और स्तंभ संख्या द्वारा निर्धारित किया जाता है, जिसके चौराहे पर यह स्थित है।
• पास्कल में, एक द्वि-आयामी सरणी को एक सरणी के रूप में माना जाता है जिसके तत्व रैखिक सरणी (सरणी की एक सरणी) होते हैं। द्वि-आयामी सरणियों के निम्नलिखित दो विवरण समान हैं वर मास: असली की सरणी की सरणी; वर मास: असली की सरणी;
• एक मैट्रिक्स जिसमें पंक्तियों की संख्या स्तंभों की संख्या के बराबर होती है, कहलाती है वर्ग मैट्रिक्स.
• मैट्रिक्स तत्व को संदर्भित करने के लिए, आपको पंक्ति संख्या और स्तंभ संख्या को इंगित करने वाले दो सूचकांकों का उपयोग करना चाहिए। मिसाल के तौर पर MyArr1. इस मामले में, सरणी तत्व (MyArr1) चौथी पंक्ति और पांचवें कॉलम में है।
• एक-आयामी सरणियों के साथ बुनियादी संचालन के बारे में जो कुछ भी कहा गया है वह मैट्रिस के लिए भी सही है। लूप में तत्व द्वारा किसी सरणी तत्व पर पुनरावृति करते समय, पूर्णांक प्रकार के चर सूचकांक के रूप में कार्य करते हैं। परंपरागत रूप से, पहचानकर्ता " मैं ", और कॉलम -" जे “.
• मैट्रिक्स के प्रसंस्करण में यह तथ्य शामिल है कि पहले पहली पंक्ति (कॉलम) के तत्वों को बदले में माना जाता है, फिर दूसरा, और इसी तरह अंतिम तक।
• यदि तत्व की पंक्ति संख्या स्तंभ संख्या से मेल खाती है ( मैं = जे), जिसका अर्थ है कि तत्व पर स्थित है मुख्य विकर्ण मैट्रिक्स
• यदि कोई तत्व विकर्ण पर स्थित है, तो सूचकांक तत्वों की संख्या से संबंधित हैं ( एन) निम्नलिखित समानता से: मैं + जे = एन + 1

द्वि-आयामी सरणी का विवरण

पास्कल में द्वि-आयामी सरणी घोषित करने (वर्णन) करने के कई तरीके हैं।

सरणी प्रकार का प्रारंभिक विवरण

पहले सरणी के प्रकार की घोषणा किए बिना एक चर को एक सरणी के रूप में परिभाषित करना

द्वि-आयामी सरणी प्रारंभ करना

द्वि-आयामी सरणियों को प्रारंभ करते समय, प्रत्येक पंक्ति कोष्ठक की एक अतिरिक्त जोड़ी में संलग्न होती है:

स्थिरांक द्रव्यमान: सरणी = ((2,3,1,0), (1,9,1,3), (3,5,7,0));

द्वि-आयामी सरणी के तत्वों के मूल्यों का इनपुट / आउटपुट

बहुत बार सरणी तत्वों के मान कीबोर्ड से दर्ज किए जाते हैं। बड़े आकार के सरणियों के साथ काम करते समय जानकारी निर्दिष्ट करने का यह तरीका बहुत समय लेने वाला है। एल्गोरिदम की एक विस्तृत श्रेणी को डीबग करने के लिए, सूचना के ऐसे इनपुट को यादृच्छिक तरीके से सरणी तत्वों के गठन द्वारा प्रतिस्थापित किया जाना चाहिए। ऐसा करने के लिए, प्रक्रिया का उपयोग करें अनियमितऔर समारोह यादृच्छिक रूप से. द्वि-आयामी सरणियों के साथ काम करते समय, नेस्टेड लूप का उपयोग किया जाता है (आमतौर पर एक पैरामीटर के साथ एक लूप के लिये).

यादृच्छिक संख्याओं के साथ एक सरणी भरना

समस्या समाधान के उदाहरण

उदाहरण 1

समस्या का निरूपण। धनात्मक पूर्णांक M और N दिए गए हैं। M × N आकार का एक पूर्णांक मैट्रिक्स उत्पन्न करें, जिसमें J-वें स्तंभ के सभी तत्वों का मान 5·J (J = 1, …, N) हो।

कास्ट एम = 7; एन = 10; वर मैं, जे:बाइट; मैट्रिक्स: पूर्णांक की सरणी; i के लिए शुरू करें: = 1 से m j के लिए करें: = 1 से n मैट्रिक्स करें: = 5 * j; ... (सरणी आउटपुट)

उदाहरण 2

समस्या का निरूपण। आपको धनात्मक पूर्णांक M, N और M संख्याओं का एक समूह दिया गया है। मूल सेट (उसी क्रम में) से सभी नंबरों वाले प्रत्येक कॉलम के साथ एक एम × एन मैट्रिक्स बनाएं।

कास्ट एम = 5; एन = 7; वेक्टर: पूर्णांक की सरणी = (3, 5, 2, 7, 4); वर मैं, जे:बाइट; मैट्रिक्स: पूर्णांक की सरणी; j के लिए शुरू करें: = 1 से n करें (jth कॉलम लें) i: = 1 से m do (पंक्ति द्वारा jth कॉलम पंक्ति के तत्वों तक पहुंच) मैट्रिक्स: = वेक्टर [i]; (कार्यान्वयन) ... (परिणामी द्वि-आयामी सरणी का आउटपुट)

होम वर्क

1. धनात्मक पूर्णांक M और N दिए गए हैं। M × N आकार का एक पूर्णांक मैट्रिक्स उत्पन्न करें, जिसमें I-वें पंक्ति के सभी तत्वों का मान 10·I (I = 1,…, M) हो।
2. आपको धनात्मक पूर्णांक M, N और N संख्याओं का एक समूह दिया गया है। मूल सेट (उसी क्रम में) से सभी नंबरों वाली प्रत्येक पंक्ति के साथ एक एम × एन मैट्रिक्स बनाएं।
3. इसके अतिरिक्त।आपको धनात्मक पूर्णांक M, N, एक संख्या D और M संख्याओं का एक समूह दिया गया है। एक एम × एन मैट्रिक्स उत्पन्न करें, जिसमें पहला कॉलम संख्याओं के मूल सेट के साथ मेल खाता है, और प्रत्येक अगले कॉलम के तत्व पिछले कॉलम के संबंधित तत्व और संख्या डी के योग के बराबर होते हैं (परिणामस्वरूप, प्रत्येक मैट्रिक्स की पंक्ति में अंकगणितीय प्रगति के तत्व होंगे)।
4. इसके अतिरिक्त।एक एम × एन मैट्रिक्स दिया गया है। सम संख्याओं (2, 4, ...) के साथ पंक्तियों में स्थित इसके तत्वों को प्रिंट करें। तत्वों को लाइन दर लाइन प्रदर्शित करें, सशर्त ऑपरेटर का उपयोग न करें।

पिछला पास्कल पाठ पहले से ही 7 मार्च को लिखा गया था, फिर हमने विश्लेषण किया। आज हम जानेंगे कि क्या है पास्कल में द्वि-आयामी सरणीयह कैसे वर्णित है और यह क्या है। अधिक विवरण नीचे।

तो द्वि-आयामी सरणी क्या है?आसान धारणा के लिए, आइए एक रेखा के रूप में एक-आयामी सरणी की कल्पना करें, और जिसमें सभी तत्व एक के बाद एक क्षैतिज रूप से जाते हैं, और एक द्वि-आयामी सरणी एक वर्ग के रूप में, जिसमें तत्व क्षैतिज और लंबवत दोनों स्थित होते हैं। द्वि-आयामी सरणी में पंक्तियाँ और स्तंभ होते हैं, उन्हें मैट्रिक्स या मैट्रिक्स सरणी भी कहा जाता है।

द्वि-आयामी सरणियों का वर्णन कैसे किया जाता है?द्वि-आयामी सरणियों को लिखने के कई तरीके हैं, मैं उनमें से 2 पर विचार करूंगा।

किसी सरणी का वर्णन करने का पहला तरीका: किसी सरणी में चर के प्रकार की सरणी (पूर्णांक/वास्तविक/बाइट);

किसी सरणी का वर्णन करने का 2 तरीका: किसी सरणी में चर के प्रकार की सरणी की सरणी;

सबसे पहले, पंक्तियों (1..m) का वर्णन किया गया है, और फिर कॉलम (1..n) का वर्णन किया गया है।

दूसरी विधि में, दो एक-आयामी सरणियों का वर्णन किया गया है, जैसा कि वे थे, जो एक साथ एक द्वि-आयामी सरणी बनाते हैं।

एक द्वि-आयामी सरणी को प्रकार अनुभाग में वर्णित किया जा सकता है, इसके बाद कई बार पहुंच के लिए, या Var चर विवरण अनुभाग में, मैं यह नोट करना चाहता हूं कि आप m और n के बजाय संख्याओं को प्रतिस्थापित कर सकते हैं, या आप स्थिरांक का उपयोग कर सकते हैं।

परिवर्तनीय घोषणा अनुभाग में द्वि-आयामी सरणी निर्दिष्ट करने का एक उदाहरण:

कॉन्स्ट
एम = 100;
एन = 100;
वर
ए: पूर्णांक की सरणी;

इस मामले में, हमने एक दो-आयामी सरणी दी है जिसका आकार 100 बटा 100 है, यानी हमारे पास एक वर्ग मैट्रिक्स है।

प्रकार अनुभाग का उपयोग करके मैट्रिक्स सरणी निर्दिष्ट करने का एक उदाहरण:

कॉन्स्ट
एम = 100;
एन = 100;
प्रकार
मैट्रिक्स = पूर्णांक की सरणी;
वर
ए: मैट्रिक्स;
बी: मैट्रिक्स;

दूसरे उदाहरण में, हमने 100 गुणा 100 के आयामों के साथ दो समान मैट्रिक्स सरणियों को निर्दिष्ट किया; सरणी बी का वर्णन करते समय, हमें इसके आयामों और डेटा प्रकार का फिर से वर्णन करने की आवश्यकता नहीं थी।

द्वि-आयामी सरणी के सेल-चर का उपयोग कैसे करें?

द्वि-आयामी सरणी को संदर्भित करने के लिए, आपको पहले पंक्ति संख्या और फिर स्तंभ संख्या निर्दिष्ट करनी होगी, जैसा कि निम्नानुसार है:

x कोई भी चर है, a सरणी का नाम है, i पंक्ति संख्या है, j स्तंभ संख्या है।

इसके अलावा, i और j दोनों चर और पूर्णांक हो सकते हैं।

किसी सरणी में डेटा लिखने का एक उदाहरण:

i:= 1 से n do // के लिए लूप में लाइन नंबर सेट करें
j:=1 से m do // के लिए लूप में कॉलम नंबर सेट करना
ए: = यादृच्छिक (100); // पंक्ति संख्या i और स्तंभ संख्या j . के साथ एक सेल के लिए एक यादृच्छिक मान निर्दिष्ट करना

हमने सरणी को 1 से 100 तक यादृच्छिक संख्याओं से भर दिया।

द्वि-आयामी सरणी का उपयोग करने वाला एक उदाहरण प्रोग्राम, जिसमें हम सरणी को यादृच्छिक संख्याओं से भरते हैं और इसे स्क्रीन पर प्रिंट करते हैं:

Var // चर और सरणी का विवरण
मैट्रिक्स: पूर्णांक की सरणी;
मैं, जे: पूर्णांक;

प्रारंभ//मुख्य कार्यक्रम की शुरुआत
writeln ("दो आयामी सरणी:"); // उपयोगकर्ता के साथ संवाद

i:= 1 से 10 के लिए // सरणी भरें
j के लिए:= 1 से 10 do
मैट्रिक्स: = यादृच्छिक (100);

i:= 1 से 10 के लिए प्रारंभ//आउटपुट सरणी
j के लिए:= 1 से 10 do
राइट (मैट्रिक्स, "");
लेखन
राइटलन ("साइट"); // आप चाहें तो हटा सकते हैं
समाप्त; // कार्यक्रम का अंत

//readln//टर्बो पास्कल में प्रयोग किया जाता है