पास्कल में जटिल सशर्त बयानों के उदाहरण। पास्कल ऑपरेटर। पास्कल प्रोग्रामिंग भाषा। नहीं, या उलटा
शायद हर छात्र "पास्कल" नामक प्रोग्रामिंग भाषा जानता है। वह क्या प्रतिनिधित्व करता है? बहुत पहले दी गई भाषामृत हो गया, क्योंकि इसका उपयोग केवल छात्रों को पढ़ाने के लिए स्कूलों में किया जाता है और इसे आधार माना जाता है। यह अल्गोल भाषा के सरलीकृत संस्करण को संदर्भित करता है। लेकिन, बाद वाले के विपरीत, "पास्कल" का उपयोग वास्तविक कार्यक्रम और यहां तक कि गेम लिखने के लिए भी किया जा सकता है। पहले, इसकी पर्याप्त लोकप्रियता थी, लेकिन अब इसे केवल शैक्षिक उद्देश्यों के लिए ही संरक्षित किया गया है। पहली चीज जो संभावित प्रोग्रामर को पास्कल की ओर आकर्षित करती है, वह है गुणों को संरक्षित करते हुए लिखने की क्षमता अंग्रेजी भाषा के, और सी जैसी भाषाओं में स्वीकार की जाने वाली विशेष योजनाओं के उपयोग पर पहेली नहीं।
एक ऑपरेटर एक प्रतीक है जो संकलक को कुछ गणितीय या तार्किक जोड़तोड़ करने के लिए कहता है। पास्कल आपको निम्न प्रकार के ऑपरेटरों का उपयोग करने की अनुमति देता है। अंकगणितीय ऑपरेटर रिलेशनल ऑपरेटर्स बूलियन ऑपरेटर्स बिट ऑपरेटर्स ऑपरेटर ऑपरेटर्स स्ट्रिंग ऑपरेटर्स। आइए एक-एक करके अंकगणित, संबंधपरक, बूलियन और बिटवाइज ऑपरेटरों पर चर्चा करें।
ये सभी ऑपरेटर बूलियन ऑपरेंड पर काम करते हैं और बूलियन परिणाम उत्पन्न करते हैं। बिटवाइज़ ऑपरेटर बिट्स पर काम करते हैं और बिटवाइज़ ऑपरेशन करते हैं। ये सभी ऑपरेटर पूर्णांक ऑपरेंड पर काम करते हैं और पूर्णांक परिणाम उत्पन्न करते हैं। बिटवाइज़ और, बिटवाइज़ या, और बिटवाइज़ के लिए सत्य तालिका निम्नलिखित नहीं है।
पास्कल को 1970 में निकलॉस विर्थ द्वारा बनाया गया था। भाषा का नाम उस वैज्ञानिक के नाम पर रखा गया है जो दुनिया की पहली मशीन का जनक बना। वह दो अलग-अलग संख्याएँ जोड़ सकती थी। पास्कल भाषा का प्रत्यक्ष वंशज मोडुला -2 है। बाद वाला एक उन्नत संस्करण है।
प्रोग्रामिंग सिस्टम
पास्कल एबीसी एक प्रोग्रामिंग भाषा है जो पहले से मौजूद सिस्टम द्वारा प्रस्तुत की जाती है। हालाँकि, वर्णित एक नई पीढ़ी का संस्करण है।
पास्कल में ऑपरेटर वरीयता
संचालिका पूर्वता एक व्यंजक में पदों के समूहन को निर्धारित करती है। यह अभिव्यक्ति के मूल्यांकन को प्रभावित करता है। कुछ ऑपरेटरों की प्राथमिकता दूसरों की तुलना में अधिक होती है; उदाहरण के लिए, गुणन ऑपरेटर को अतिरिक्त ऑपरेटर की तुलना में उच्च प्राथमिकता है। यहां, उच्चतम प्राथमिकता वाले ऑपरेटर तालिका के शीर्ष पर दिखाई देते हैं, जबकि सबसे कम प्राथमिकता वाले ऑपरेटर नीचे दिखाई देते हैं। एक एक्सप्रेशन के भीतर, उच्च प्राथमिकता वाले ऑपरेटरों का मूल्यांकन पहले किया जाएगा।
अक्सर निम्नलिखित पाया जाता है: जब यह समाप्त हो जाएगा तो यह क्या होगा? वाक्यविन्यास पर्याप्त स्पष्ट है: एक बूलियन अभिव्यक्ति तुलना हो सकती है, लेकिन यह एक बूलियन मान भी हो सकती है: या एक बूलियन अभिव्यक्ति। एक मामले के लिए "परिणाम = 0", और दूसरे मामले में "परिणाम 0"। 0 के बराबर नहीं का मान जरूरी नहीं कि 1 या -1 हो! "झूठी" के साथ तुलना बेमानी है, लेकिन कार्यक्रम के गलत व्यवहार की ओर नहीं ले जाती है। आइए एक फ़ंक्शन लिखें जो एक स्ट्रिंग से एक पूर्णांक पढ़ता है और एक त्रुटि चर सेट करता है यदि स्ट्रिंग में एक मान्य संख्या नहीं है।
- पैरामीटर के साथ लूप;
- पुनरावृत्त
प्रत्येक क्या दर्शाता है? पहले वाले (पैरामीटर के साथ लूप) में हमेशा ज्ञात पैरामीटर होते हैं। कभी-कभी इसे नियमित भी कहा जाता है। इसका मुख्य अंतर यह है कि लूप के पुनरावृत्तियों की संख्या शुरू होने से पहले ही ज्ञात हो जाती है।
पुनरावृत्त में, ऐसी बारीकियां अज्ञात हैं। शर्त पूरी होने तक लूप निष्पादित किया जाता है।
हम इसके लिए अच्छे पुराने "वैल" का उपयोग करते हैं - क्योंकि हमें अपवादों के बारे में चिंता करने और समय और प्रयास बचाने की आवश्यकता नहीं है। कोड में 0 होता है यदि रूपांतरण संभव था या स्ट्रिंग में त्रुटि की स्थिति। इसके परिणामस्वरूप बूलियन चर का क्रमिक मान 0 या 0 होता है।
नहीं, या उलटा
आइए इस फ़ंक्शन का गलत उपयोग करें। यदि अब हम यह सब इस प्रकार कहेंगे: हमें क्रमिक रूप से संदेश प्राप्त होते हैं। थोड़ा बालों वाला उदाहरण इतना अच्छा नहीं है। बूलियन अभिव्यक्तियों का मूल्यांकन। बूलियन अभिव्यक्तियों के साथ, निश्चित रूप से, ऐसा हो सकता है कि परिणाम समय से पहले कैप्चर हो जाए। हालांकि, बूलियन अभिव्यक्तियों का संक्षिप्त मूल्यांकन एक और दुष्ट मामले की ओर जाता है। यह बहुत खतरनाक बात है। यदि आप एक कंपाइलर सेटिंग पर भरोसा करते हैं, तो आप बने रहते हैं और फिर उपयोगकर्ता से फीडबैक प्राप्त करते हैं कि संपूर्ण "कभी-कभी" गलत किया जाता है।
आप कुछ संरचनाओं का उपयोग करके प्रकार और चक्रों के बीच अंतर कर सकते हैं:
- दोहराना: एक पोस्टकंडीशन के साथ दोहराव।
- जबकि: पूर्व शर्त के साथ दोहराएं।
- के लिए - खाता संचालक। इसका उपयोग एक पैरामीटर के साथ लूप में किया जाता है।
पहले दो विकल्पों का उपयोग पुनरावृत्त दोहराव के लिए किया जाता है। अंतिम कथन से उनका मुख्य अंतर यह है कि उनका उपयोग FOR में किया जा सकता है, लेकिन बिना किसी पैरामीटर के दोहराव के लिए यह असंभव है। 
तो समस्या को इस तरह हल किया जा सकता है। किसी फ़ंक्शन में मूल्यांकन को इनकैप्सुलेट किया जा सकता है। संक्षिप्त मूल्यांकन का अर्थ और बकवास। ऊपर के उदाहरण में, मुड़ा हुआ स्कोर उपयोगी प्रतीत होता है। लेकिन क्या होगा यदि कई कार्यों को बुलाया जाता है, प्रत्येक अभी भी कुछ और कर रहा है?
उदाहरण। घनाभ के स्थान की गणना करें। यदि सभी मान सही ढंग से दर्ज किए गए हैं, तो परिणाम फ़ील्ड कमरे की सामग्री पर सेट है। कैप्शन: = "त्रुटि!"। परिणाम। यदि हमने शॉर्ट सर्किट को सक्षम किया है, तो केवल पहली त्रुटि की सूचना दी जाएगी। जब मूल्यांकन पूरा हो जाता है, तो सभी त्रुटियों की सूचना दी जाती है।
आई/ओ स्टेटमेंट्स
प्रोग्रामिंग वातावरण के साथ बातचीत के लिए वातावरण I/O ऑपरेटर प्रतिक्रिया देते हैं। वे आपको जानकारी दर्ज करने और स्क्रीन या प्रिंट पर परिणाम प्रदर्शित करने की अनुमति देते हैं। रीड कमांड उपयोगकर्ता को चल रहे प्रोग्राम में अपना डेटा दर्ज करने की अनुमति देगा। यह कैसे होता है? कार्यक्रम थोड़ी देर के लिए रुक जाता है, स्क्रीन पर एक ब्लिंकिंग कर्सर दिखाई देता है, जो किसी व्यक्ति से इनपुट की प्रतीक्षा कर रहा है। दोनों के पढ़ने और पढ़ने के तरीके में बहुत कम अंतर है। उत्तरार्द्ध बस कर्सर को अगली पंक्ति में ले जाता है।
मानक बूलियन फ़ंक्शन
एप्लिकेशन में दोनों संस्करणों में एक साथ मूल्यांकन के साथ एक पूरी परियोजना है। आप कई क्षेत्रों में इनपुट त्रुटियों में अंतर देख सकते हैं। एर्गोनॉमिक्स से, बाएं कॉलम के व्यवहार का उपयोग किया जाना चाहिए। यदि आप संकलन नहीं करना चाहते हैं, तो आप छिपकली को भी डाउनलोड कर सकते हैं।
सब कुछ जितना संभव हो उतना सरल है - यह सिर्फ एक सिद्धांत है जिसे दिखाया जाना है। जो स्वाभाविक रूप से आदर्श वाक्य का पालन करता है "यह संकलित करता है, हम इसे वितरित कर सकते हैं" भाग्य से बाहर है। इस अध्याय में हम शाखाओं को देखेंगे। लक्ष्य प्रोग्रामिंग प्रक्रिया को शर्तों के साथ नियंत्रित करना है।
आउटपुट ऑपरेटर ("पास्कल") राइट (एलएन) है। कण एलएन आपको अगली पंक्ति में डेटा के आउटपुट को जारी रखने की अनुमति देता है। यदि आप प्रोग्राम में केवल एक ऑपरेटर निर्दिष्ट करते हैं, तो एक खाली शब्द प्रदर्शित होगा। इस अर्थ में इस आदेश का उपयोग करना आवश्यक नहीं है।
वर और करीबी ऑपरेटर भी हैं। यदि प्रोग्राम को स्वयं इसकी आवश्यकता नहीं है, तो आप उनका उपयोग नहीं कर सकते।
अब तक कंप्यूटर ने हर इनपुट पर उसी तरह प्रतिक्रिया दी है। ऐसा करने के लिए, हमें एक तथाकथित "अनुरोध" की आवश्यकता है। कंप्यूटर जांचता है कि क्या विशिष्ट मामलासही या गलत। स्थिति तुलना या एकल सत्य मान का संयोजन है। सबसे पहले, हम खुद को तुलना के लिए समर्पित करना चाहते हैं।
लेकिन पहले, आइए लिंक पर जाने से पहले एक उदाहरण देखें। देखते हैं कि ह्यूगो अपना नाम कहता है या नहीं। पहला नाम धर्मत्यागी पर लागू नहीं होता है, क्योंकि यह एक चर का नाम है। हालांकि, ह्यूगो वह मान है जिसके खिलाफ चर की तुलना की जानी चाहिए, इसलिए यहां एपोस्ट्रोफ की आवश्यकता है। पूरा कार्यक्रम अब इस तरह दिखता है।
लेख में मुख्य ऑपरेटरों ("पास्कल") का वर्णन किया गया है। वे आपको एक बेहतर कार्यक्रम लिखने में मदद करेंगे, लेकिन वे स्वयं जल्दी और बिना किसी असफलता के काम करते हैं। उनके बिना, पास्कल भाषा के साथ काम करते समय भविष्य के प्रोग्रामर के लिए कुछ भी काम नहीं करेगा। ऑपरेटरों के बिना कार्यक्रमों की कल्पना नहीं की जा सकती। इसलिए, उन्हें काम करने में सक्षम होने की आवश्यकता है। लूप स्टेटमेंट जटिल लग सकते हैं, लेकिन अभ्यास के साथ, सभी समस्याएं गायब हो जाएंगी। आपके काम के साथ शुभकामनाएँ!
ऐसा करने के लिए, हम अपने सिंटैक्स का थोड़ा विस्तार करेंगे। तो हमारा विस्तारित कार्यक्रम अब कुछ इस तरह दिखता है। इस वेरिएबल को अब क्वेरीज़ में फिर से इस्तेमाल किया जा सकता है। इसलिए, बूलियन चर के लिए किसी तुलना की आवश्यकता नहीं है, क्योंकि वे पहले से ही एक वास्तविक मान हैं।
यदि हम अब एक ही समय में कई शर्तों का अनुरोध करते हैं, तो कई अनुरोध सेट करना संभव होगा। हालांकि, यहां कई समस्याएं हैं। जटिल प्रश्नों के लिए, यह बहुत भ्रमित करने वाला है। . इन समस्याओं को हल करने के लिए, हम दो अनुरोधों को एक में बदलना चाहते हैं। हमें बस इतना करना है कि प्रत्येक तुलना कोष्ठक और उनके बीच में रखें। और यह एकमात्र ऑपरेटर नहीं है।
कई पास्कल कार्यक्रमों में, ऐसी स्थितियां होती हैं, जब एक निश्चित शर्त के आधार पर, कई कथनों को निष्पादित किया जाएगा या नहीं किया जाएगा।
इन शर्तों को सही या गलत बयानों (TRUE, FALSE) के रूप में परिभाषित किया गया है। उदाहरण के लिए:
एक्स>3("x 3 से बड़ा है") जहां "x" एक पूर्णांक चर है। "x" के लिए अलग-अलग मानों को प्रतिस्थापित करने पर हम पाएंगे कि कथन या तो सत्य (TRUE) है या गलत (FALSE)। मान लें कि "x" 4 के बराबर है।
अगर अनुरोधों को अलग तरह से संभाला जा सकता है, अगर अनुरोध जल्दी भ्रमित हो सकते हैं। उनके साथ, एक चर का मान केवल एक बार पुनर्प्राप्त किया जाता है, और प्रोग्राम फिर सीधे उस स्थान पर कूद जाता है जिसे संबंधित मान के लिए निष्पादित किया जाता है।
मामला अनुरोध निम्नानुसार संरचित है। यदि समान क्रियाओं को के साथ किया जाना चाहिए विभिन्न मूल्य, इन मानों को अल्पविराम द्वारा अलग किया जा सकता है। आप प्रपत्र मान में मानों की संपूर्ण श्रेणी भी निर्दिष्ट कर सकते हैं। हालाँकि, ध्यान दें कि एक चर के केवल एक मान का मूल्यांकन किया जाता है।
4>3 यह स्पष्ट है कि चार तीन से बड़ा है, जिसका अर्थ है कि कथन सत्य है (TRUE)। यदि चर "x" मान 2 लेता है, तो व्यंजक में बदल जाएगा
2>3 जो, निश्चित रूप से, असत्य (FALSE) है। "x=3" (3>3 गलत है) के साथ भी ऐसा ही होगा।
आइए देखते हैं कार्यक्रम:
(1) प्रोग्राम बोल्डेमो; (2) var (3) x: पूर्णांक; (4) बी: बूलियन; (5) शुरू (6) एक्स: = 4; (7) बी: = एक्स> 3; (8) राइटलाइन (बी); (9) b:= x प्रोग्राम आउटपुट: TRUE FALSE FALSE
बहुत बार अनुरोधित डेटा प्रकार स्ट्रिंग का उपयोग मामले में नहीं किया जा सकता है। कार्यक्रम आपको फिर से प्रवेश करने के लिए प्रेरित करेगा और इस बार एक वर्ण की अपेक्षा करेगा। तो आप अनुरोध के मामले में ऐसे चर को संभाल सकते हैं। पिछली पोस्ट में हमने सिलेक्शन स्ट्रक्चर के बारे में ही बात की थी। एक और व्यापक रूप से इस्तेमाल की जाने वाली चयन संरचना कम्यूटेटर है।
एक स्विच की मदद से, हम कुछ स्थिरांक के साथ एक चर की सामग्री की तुलना करते हैं, और इस तरह हम चुनते हैं कि हमारे एप्लिकेशन द्वारा कोड का कौन सा टुकड़ा निष्पादित किया जाएगा। उसके तुरंत बाद, हम वाक्य रचना के विवरण के बारे में बात करेंगे। हमारे पास दिलचस्प विशेषताएं हैं जिन पर इस कोड स्निपेट में चर्चा की जा सकती है। फिर हम तुलना को परिभाषित करते हैं।
पंक्तियाँ 1-3हम पहले से ही परिचित हैं, लेकिन पंक्ति 4 एक नए प्रकार "बूलियन" के साथ एक चर का प्रतिनिधित्व करती है। इस प्रकार का एक चर केवल 2 मान ले सकता है - TRUE, FALSE। साथ ही, इस प्रकार का एक चर उस अभिव्यक्ति के आधार पर कुछ मान ले सकता है जिसके साथ वह जुड़ा हुआ है। यानी आप b:=true लिख सकते हैं या b:=2>1 और यहां तक कि b:=3-1>5-4 भी लिख सकते हैं। इन सभी मामलों में, चर का मान "TRUE" होगा।
इस स्थिरांक का पूर्णांक मान होना आवश्यक नहीं है। यह एक चरित्र, फ़्लोटिंग पॉइंट इत्यादि हो सकता है। स्थिरांक के बाद, हम जोड़ते हैं: इंगित करता है कि इस समाधान के अनुरूप कोड का टुकड़ा शुरू होता है। कोलन के बाद, हम चाबियाँ खोल भी सकते हैं और नहीं भी। यह देखना दुर्लभ है कि यह कौन करता है, लेकिन यह हर एक का स्वाद है। कुछ इसे संगठन के मामले के रूप में पसंद करते हैं, लेकिन कुछ भी नहीं जो अच्छी तरह से निष्पादित इंडेंटेशन हल करता है। वैसे भी, कोड के इस टुकड़े को परिभाषित करने के लिए कुंजियों का उपयोग करें या न करें।
हमारे उदाहरण के मामले में, हम इसी चर को बढ़ाते हैं, यह अनुकरण करते हुए कि प्रत्येक चुनाव में एक विशेष उम्मीदवार का प्रतिनिधित्व करेगा। जब आप किसी मामले की तुलना को परिभाषित करते हैं, तो आप वास्तव में संरचना के "मार्कअप" को परिभाषित कर रहे होते हैं। जब चलाया जाता है, तो प्रोग्राम इन परिभाषित लेबलों के भीतर तब तक खोज करेगा जब तक कि उसे एक ऐसी तुलना न मिल जाए जो चर की वर्तमान सामग्री को संतुष्ट करती हो।
लाइन 6 पर, चर "x" को मान 4 दिया गया है।
पंक्ति 7 में, बूलियन चर "b" को "X>3" स्थिति का मान दिया गया है, अर्थात TRUE (आखिरकार, पंक्ति 6 के बाद, x 4 के बराबर हो गया)।
लाइन 8 इस मान को प्रिंट करती है।
9-10 और 11-12 की पंक्तियों में, "x" स्थितियों के मान एक ही चर को दिए गए हैं। इसके बाद, मैं शर्तों के बारे में बात करूंगा। शर्तें निम्नलिखित ऑपरेटरों का उपयोग करती हैं:
लेबल सिर्फ "मार्कर" हैं, जिसका अर्थ है कि हमें "ब्लॉक" बंद होने की चेतावनी देने के लिए एक ब्रेक की आवश्यकता है। अधिक अनुकूल परिस्थितियों में, हम इसका उपयोग करेंगे और हम बेहतर प्रदर्शन करेंगे। यदि कोई कार्रवाई नहीं की जाती है यदि चर किसी भी परीक्षण मामले से मेल नहीं खाता है, तो हम डिफ़ॉल्ट स्निपेट को छोड़ सकते हैं या इसे खाली छोड़ सकते हैं।
इस परिच्छेद में, हमारे पास चरों को बढ़ाने का एक बहुत ही दिलचस्प तरीका है। जब हम उसके बाद एक वेरिएबल नाम डालते हैं, तो हम केवल उसका मान लेते हैं और उसे जोड़ते हैं। हम - का उपयोग कम करने के लिए भी ऐसा ही कर सकते हैं। आपने चर नाम से पहले और बाद में इन वेतन वृद्धि और कमी को पहले ही देख लिया होगा।
"नहीं" ऑपरेटर को अभिव्यक्ति या बूलियन चर से पहले रखा जाता है। यह किसी वैरिएबल या एक्सप्रेशन के मान को TRUE से FALSE या इसके विपरीत में बदल देता है।
ऑपरेटरों "और", "या", "xor" को दो अभिव्यक्तियों (बूलियन चर) के बीच रखा जाता है। "और" के साथ एक अभिव्यक्ति "TRUE" का मूल्यांकन केवल तभी करती है जब दोनों अभिव्यक्तियां (दाएं और बाएं) "TRUE" का मूल्यांकन करती हैं, अन्यथा "FALSE"। एक या व्यंजक का मूल्यांकन "TRUE" होता है यदि "उप-अभिव्यक्तियों" में से कम से कम एक "TRUE" का मूल्यांकन करता है। "xor" वाला एक व्यंजक "TRUE" का मूल्यांकन करता है, यदि केवल एक उप-अभिव्यक्ति का मूल्यांकन "TRUE" होता है
दोनों रूपों में क्या अंतर है? यदि वृद्धि चर नाम से पहले है, तो वेतन वृद्धि को अभिव्यक्ति में चर के मान का उपयोग करने से पहले किया जाता है। यदि यह बाद में है, तो इसका उपयोग बाद में किया जाएगा। सरल, लेकिन एक रूप या किसी अन्य का उपयोग करते समय ध्यान देने की आवश्यकता है।
जैसा कि निम्नलिखित उदाहरणों में देखा जा सकता है, इसकी संरचना पास्कल में इसकी संरचना के समान है। इसके तुरंत बाद, हमारे पास सार्वजनिक कुंजियाँ हैं जो पुनर्प्रयास ब्लॉक को परिभाषित करती हैं। यदि दोहराए जाने वाले ब्लॉक में केवल एक कमांड है, तो आप कुंजियों को छोड़ सकते हैं।
शेष ऑपरेटरों को एक ही प्रकार के मूल्यों/चर के बीच रखा जाता है।
शर्तों में कोष्ठक की भी अनुमति है। ऑपरेटरों 1 से 4 की सर्वोच्च प्राथमिकता है, इसके बाद अन्य सभी हैं।
ये रही परिणाम तालिका तार्किक संचालनचर के साथ "ए" और "बी" ("ए", "बी" प्रकार के बूलियन हैं)।
| एक | बी | ए और बी | ए या बी | एक एक्सोर बी |
| सच | सच | सच | सच | असत्य |
| सच | असत्य | असत्य | सच | सच |
| असत्य | सच | असत्य | सच | सच |
| असत्य | असत्य | असत्य | असत्य | असत्य |
और यहाँ एक प्रोग्राम है जो उपरोक्त सभी को दिखाता है।
यह कथन कुछ भी नहीं करता है, लेकिन इसके बाद हमारे पास मौजूद चर के वर्तमान मूल्य में जोड़ देता है। ऐसा ही अन्य ऑपरेटरों के साथ भी किया जा सकता है। उपयोग की जाने वाली एक और पुनरावृत्ति संरचना करते समय है। ठीक है, वाक्य रचना काफी सरल है और पहले दिखाए गए के समान है। हम एक कीवर्ड और चाबियों के बीच परिभाषित कोड के एक ब्लॉक से शुरू करते हैं। केवल विवरण यह है कि शर्त के बाद अर्धविराम का उपयोग किया जाना चाहिए।
पास्कल में, स्थिति "200 से कम" थी। पुनरावृत्ति लूप में एक संरचना होती है जो पास्कल में देखी गई संरचना से अपेक्षाकृत भिन्न होती है। हम शीघ्र ही कह सकते हैं कि इसकी संरचना पास्कल की भाषा से भिन्न है। आइए बताते हैं कि यह कैसे काम करता है। यदि आप समझते हैं, तो हमारे पास कोष्ठकों में तीन भाग हैं।
(1) कार्यक्रम डेमो; (2) वर ए, बी: बूलियन; (3) शुरू (4) a:=not((1 प्रोग्राम TRUE आउटपुट करेगा।
मैं पूरे कार्यक्रम का विश्लेषण नहीं करूंगा, लेकिन मैं इसमें प्रयुक्त अभिव्यक्तियों का विश्लेषण दूंगा।
आइए पंक्ति 4 से शुरू करें: नहीं ((1 नहीं (TRUE xor FLASE) -> नहीं (TRUE) -> FALSE
पंक्ति 5: a या (2+1=3) -> FALSE या (3=3) -> FALSE या TRUE -> TRUE
पंक्ति 6: (b xor a) और (नहीं (a या FALSE)) -> (TRUE xor FALSE) और (नहीं (FALSE या FALSE)) -> TRUE और नहीं (FLASE) -> TRUE और TRUE -> TRUE
अब सशर्त बयानों के बारे में बात करने का समय है। सशर्त बयानये ऐसे कथन हैं जिनका उपयोग प्रोग्राम निष्पादन के अनुक्रम को प्रभावित करने के लिए किया जा सकता है। यह पहला विकल्प है:
पहला भाग इंगित करता है कि काम शुरू होने से पहले क्या किया जाना चाहिए। कोड के ब्लॉक को निष्पादित करने से पहले, यह इस स्थिति की जाँच करता है। हमें न केवल इस दौरान, बल्कि समय और समय पर भी इन स्थितियों का ध्यान रखना चाहिए, ताकि इससे बचा जा सके कि हमारा कार्यक्रम अनंत लूप में है और कभी भी इसका निष्पादन समाप्त नहीं होता है। इसलिए प्रोग्रामिंग करते समय सावधान रहें! यह वही है जो आप चाहते हैं और चाहते हैं। इन "पैरामीटर" को परिभाषित करने के बाद, हमारे पास कोड का एक ब्लॉक है जिसे निष्पादित किया जाएगा। उपरोक्त मामले में, हमारे पास एक वेक्टर के लिए एक पठन कथन है।
यही है, अगर हम एक वेक्टर घोषित करते हैं। जब यह 10 हो जाता है, तो यह उस स्थिति को पढ़े बिना निष्पादन समाप्त कर देता है। यदि हम 10 पदों के साथ घोषित इस वेक्टर की स्थिति 10 तक पहुँचने का प्रयास करते हैं, तो हमें एक स्मृति त्रुटि मिलेगी। तो आप लोगों के लिए एक और टिप . बूलियन्स का आविष्कार श्री बूले ने बुनियादी कार्यों को बनाने के लिए किया था, जो दूसरों के साथ मिलकर अन्य कार्यों को बहुत जटिल कर सकते हैं।
अगर तब या
मान लीजिए हम एक प्रोग्राम लिख रहे हैं जो दो संख्याओं को पढ़ता है और यदि उनमें से दूसरा शून्य के बराबर नहीं है, तो भागफल और शेष को पहली संख्या को दूसरे से विभाजित करके प्रिंट करें।
(1) कार्यक्रम डेमो; (2) वर ए, बी: पूर्णांक; (3) शुरू (4) पढ़ना (ए, बी); (5) यदि b0 तो writeln(a div b," ", a mod b); (6) अंत। पंक्तियाँ 1-4 हम पहले से ही परिचित हैं।
पंक्ति 5 में एक नया यदि कथन है। (प्रारूप है: "if स्थितिफिर ऑपरेटर")
यदि शर्त TRUE का मूल्यांकन करती है, तो कथन निष्पादित किया जाएगा। अर्थात्, यदि b गैर-शून्य है, तो एक div b और एक mod b आउटपुट होगा।
अगर उसके बाद "और" लिखें ऑपरेटर2", तो यदि स्थिति झूठी का मूल्यांकन करती है, तो कथन 2 निष्पादित किया जाएगा। उदाहरण के लिए:
यदि b0 तो writeln(a div b," ", a mod b) और writeln ("0 से विभाजित नहीं कर सकता"); (यदि "बी" शून्य के बराबर नहीं है, तो एक डिव बी, "", एक मॉड बी प्रिंट करें, अन्यथा प्रिंट करें "आप 0 से विभाजित नहीं कर सकते")
ध्यान दें कि और कभी भी अर्धविराम से पहले नहीं होता है।
इस उदाहरण में, केवल एक कथन निष्पादित किया गया है या निष्पादित नहीं किया गया है। अक्सर यह आवश्यक होता है कि कई कथनों को निष्पादित/निष्पादित किया जाए। एकाधिक कथनों को इसमें मिलाकर करना आसान है कोड ब्लॉक, प्रारंभ और अंत कथनों द्वारा गठित।
उदाहरण के लिए:
(1) कार्यक्रम डेमो; (2) वर ए, बी: पूर्णांक; (3) शुरू (4) पढ़ना (ए, बी); (5) अगर b0 तो (6) शुरू (7) writeln ("निजी:", ए डिव बी); (8) writeln ("शेष:", एक मॉड बी); (9) अन्य अंत लिखें ln ("0 से विभाजित नहीं कर सकता"); (10) अंत।
ऐसा करने के लिए, आपको केवल प्रारंभ और अंत के बीच आवश्यक कथनों को संलग्न करना होगा।
