एमआईटी पाठ्यक्रम "कंप्यूटर सिस्टम सुरक्षा"। व्याख्यान 10: प्रतीकात्मक निष्पादन, भाग 3

मैसाचुसेट्स इंस्टीट्यूट ऑफ टेक्नोलॉजी। व्याख्यान पाठ्यक्रम # 6.858। "कंप्यूटर सिस्टम की सुरक्षा।" निकोलाई ज़ेल्डोविच, जेम्स मिकेंस। 2014 साल

कंप्यूटर सिस्टम सुरक्षा सुरक्षित कंप्यूटर सिस्टम के विकास और कार्यान्वयन पर एक कोर्स है। व्याख्यान खतरे के मॉडल को कवर करते हैं, हमले जो सुरक्षा से समझौता करते हैं, और हाल के वैज्ञानिक कार्यों के आधार पर सुरक्षा तकनीक। विषयों में ऑपरेटिंग सिस्टम (OS) सुरक्षा, सुविधाएँ, सूचना प्रवाह प्रबंधन, भाषा सुरक्षा, नेटवर्क प्रोटोकॉल, हार्डवेयर सुरक्षा और वेब अनुप्रयोग सुरक्षा शामिल हैं।

व्याख्यान 1: "परिचय: खतरे के मॉडल" भाग 1 / भाग 2 / भाग 3
व्याख्यान 2: "हैकर हमलों का नियंत्रण" भाग 1 / भाग 2 / भाग 3
व्याख्यान 3: "बफर ओवरफ्लो: शोषण और संरक्षण" भाग 1 / भाग 2 / भाग 3
व्याख्यान 4: "पृथक्करण का पृथक्करण" भाग 1 / भाग 2 / भाग 3
व्याख्यान 5: "सुरक्षा प्रणालियाँ कहाँ से आती हैं?" भाग 1 / भाग 2
व्याख्यान 6: "अवसर" भाग 1 / भाग 2 / भाग 3
व्याख्यान 7: "मूल ग्राहक सैंडबॉक्स" भाग 1 / भाग 2 / भाग 3
व्याख्यान 8: "नेटवर्क सुरक्षा मॉडल" भाग 1 / भाग 2 / भाग 3
व्याख्यान 9: "वेब अनुप्रयोग सुरक्षा" भाग 1 / भाग 2 / भाग 3
व्याख्यान 10: "प्रतीकात्मक निष्पादन" भाग 1 / भाग 2 / भाग 3

अब, नीचे शाखा के बाद, हम अभिव्यक्ति t = y देखते हैं। चूँकि हम एक समय में एक पथ पर विचार कर रहे हैं, इसलिए हमें t के लिए एक नया चर नहीं लाना है। हम बस यह कह सकते हैं कि t = y के बाद से t अब 0 नहीं है।

हम नीचे जाना जारी रखते हैं और उस बिंदु पर पहुंचते हैं जहां हम दूसरी शाखा में पहुंचते हैं। इस मार्ग पर आगे बढ़ने के लिए हमें कौन सी नई धारणा बनानी चाहिए? यह एक धारणा है कि t <y।

टी क्या है? यदि आप सही शाखा को देखते हैं, तो हम उस t = y को देखेंगे। और हमारी तालिका में, टी = वाई और वाई = वाई। यह तार्किक रूप से इस प्रकार है कि हमारा प्रतिबंध y <y की तरह दिखता है, जो नहीं हो सकता है।



इस प्रकार, हमारे पास सब कुछ था जब तक हम इस बिंदु तक नहीं पहुंचे <y। जब तक हम गलत बयान नहीं करेंगे, तब तक हमारे पास सही होने के लिए सभी असमानताएं हैं। लेकिन यह काम नहीं करता है, क्योंकि सही शाखा के कार्य करते समय, हमारे पास एक तार्किक असंगति है।

हमारे पास वह है जिसे अक्सर पथ की स्थिति कहा जाता है। इस तरह से जाने के कार्यक्रम के लिए यह शर्त सही होनी चाहिए। लेकिन हम जानते हैं कि यह शर्त पूरी नहीं हो सकती है, इसलिए कार्यक्रम के लिए इस तरह से जाना असंभव है। इसलिए अब इस रास्ते को पूरी तरह से समाप्त कर दिया गया है, और हम जानते हैं कि इस सही रास्ते पर नहीं जाया जा सकता है।

दूसरे तरीके के बारे में क्या? आइए एक अलग तरीके से बाईं शाखा के माध्यम से जाने की कोशिश करें। इस पथ के लिए क्या स्थितियां होंगी? फिर से, हमारा प्रतीकात्मक राज्य t = 0 से शुरू होता है, और X और Y चर x और y के बराबर होते हैं।



अब इस मामले में पथ प्रतिबंध क्या दिखता है? हम बाईं शाखा को True और सही शाखा को False के रूप में निरूपित करते हैं और मान को t = x मानते हैं। शर्तों के तार्किक प्रसंस्करण के परिणामस्वरूप t = x, x> y और t <y, हम प्राप्त करते हैं कि हम एक साथ x> y और x <y हैं।



यह स्पष्ट है कि पथ की यह स्थिति असंतोषजनक है। हमारे पास ऐसा x नहीं है जो y से बड़ा और छोटा दोनों हो। एक चर X के लिए कोई असाइनमेंट नहीं है जो दोनों बाधाओं को संतुष्ट करता है। इस प्रकार, यह हमें बताता है कि दूसरा तरीका भी असंतोषजनक है।

यह पता चला है कि इस समय हमने कार्यक्रम में उन सभी संभावित रास्तों की खोज की जो हमें इस राज्य की ओर ले जा सकते हैं। हम वास्तव में स्थापित कर सकते हैं और सत्यापित कर सकते हैं कि कोई भी संभव तरीका नहीं है जो हमें गलत कथन की ओर ले जाएगा।
श्रोता: इस उदाहरण में, आपने दिखाया कि आपने सभी संभावित शाखाओं के साथ एक कार्यक्रम की प्रगति का अध्ययन किया। लेकिन प्रतीकात्मक निष्पादन के फायदों में से एक यह है कि हमें सभी संभावित घातीय रास्तों का अध्ययन करने की आवश्यकता नहीं है। तो इस उदाहरण में इससे कैसे बचा जाए?

प्रोफेसर: यह बहुत अच्छा सवाल है। इस मामले में, आप चरित्र निष्पादन के बीच समझौता करते हैं और आप कितने विशिष्ट बनना चाहते हैं। तो इस मामले में, हम प्रतीकात्मक निष्पादन का उपयोग नहीं कर रहे हैं क्योंकि हमने पहली बार दोनों शाखाओं पर एक साथ कार्यक्रम प्रवाह को देखा था। लेकिन इसके लिए धन्यवाद, हमारी सीमाएं बहुत सरल हो गई हैं।

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

यह उन क्षेत्रों में से एक है जहां प्रतीकात्मक निष्पादन के संबंध में बहुत सारे प्रयोग किए गए हैं, उदाहरण के लिए, एक साथ कई पथ प्रदर्शन करना। व्याख्यान सामग्री में आप उत्तराधिकारियों से मिले और रणनीतियों का एक सेट जो प्रयोगकर्ताओं ने खोज को अधिक ठोस बनाने के लिए उपयोग किया।

उदाहरण के लिए, उनमें से एक चीज यह है कि वे एक के बाद एक रास्ता तलाशते हैं, लेकिन इसे पूरी तरह से आँख बंद करके नहीं करते हैं। वे प्रत्येक कदम के बाद पथ की स्थितियों की जांच करते हैं। मान लीजिए कि हमारे कार्यक्रम में, "झूठा" कहने के बजाय, कार्यक्रमों का एक जटिल पेड़ होगा, एक नियंत्रण प्रवाह ग्राफ।



आपको यह पुष्टि करने के लिए प्रतीक्षा करने की आवश्यकता नहीं है कि जब तक आप यह सुनिश्चित करने के लिए बहुत अंत तक नहीं पहुँच जाते कि यह मार्ग संभव है। उस क्षण में, जब आप स्थिति t <y पर पहुंचते हैं, तो आप पहले से ही जानते हैं कि यह पथ असंतोषजनक है, और आप उस दिशा में कभी नहीं जाएंगे। इसलिए, कार्यक्रम की शुरुआत में गलत शाखाओं को काटने से अनुभवजन्य कार्य की मात्रा कम हो जाती है। मार्ग का उचित अन्वेषण भविष्य में कार्यक्रम की विफलता की संभावना को रोकता है। आज उपयोग किए जाने वाले कई व्यावहारिक उपकरण मुख्य रूप से पथ के प्रारंभिक सेट को प्राप्त करने के लिए यादृच्छिक परीक्षण से शुरू होते हैं, जिसके बाद वे पड़ोस में पथ का पता लगाने के लिए शुरू करेंगे। वे प्रत्येक पथ के लिए कार्यक्रम के संभावित निष्पादन के लिए कई विकल्पों की प्रक्रिया करते हैं, यह सोचकर कि इन रास्तों पर क्या होता है।

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



लेकिन जिस समय आप एक ही समय में सभी रास्ते बनाने की कोशिश कर रहे होते हैं, तो प्रतिबंध शुरू हो जाते हैं जो कि असाध्य हो जाते हैं। इसलिए, आप जो कर सकते हैं वह एक समय में एक कार्य करते हैं, जबकि आप एक समारोह में सभी पथों को एक साथ सीख सकते हैं। यदि आप बड़े ब्लॉक बनाने की कोशिश करते हैं, तो सामान्य तौर पर आप सभी संभावित तरीकों का पता लगा सकते हैं।

सबसे महत्वपूर्ण बात यह है कि प्रत्येक शाखा के लिए आप अपने प्रतिबंधों की जांच करते हैं और निर्धारित करते हैं कि क्या यह शाखा वास्तव में दोनों तरीकों से जा सकती है। यदि वह दोनों रास्तों का पालन नहीं कर सकती है, तो आप उस दिशा में नहीं चलते हुए समय और प्रयास बचाते हैं, जहाँ वह नहीं जा सकती। इसके अलावा, मैं उन विशिष्ट रणनीतियों को याद नहीं करता जिनका उपयोग वे ऐसे तरीके खोजने के लिए करते हैं जो बहुत अच्छे परिणाम उत्पन्न करने की अधिक संभावना रखते हैं। लेकिन प्रारंभिक चरण में गलत शाखाओं को काट देना बहुत महत्वपूर्ण है।

अब तक, हम मुख्य रूप से "टॉय कोड" के बारे में बात कर रहे हैं, पूर्णांक चर के बारे में, शाखाओं के बारे में, बहुत ही सरल चीजों के बारे में। लेकिन क्या होता है जब आपके पास एक अधिक जटिल कार्यक्रम होता है? विशेष रूप से, क्या होता है जब आपके पास एक कार्यक्रम होता है जिसमें एक गुच्छा शामिल होता है?



ऐतिहासिक रूप से, कूल्हे का ढेर सभी सॉफ्टवेयर विश्लेषण का अभिशाप रहा है, क्योंकि फोरट्रान के समय की स्वच्छ और सुरुचिपूर्ण चीजें पूरी तरह से फट जाती हैं जब आप उन्हें सी प्रोग्राम का उपयोग करके चलाने की कोशिश करते हैं जिसमें आप बाएं और दाएं मेमोरी आवंटित करते हैं। आपके पास ओवरले और सभी गड़बड़ियां हैं जो कि प्रोग्राम के साथ आवंटित मेमोरी के साथ और अंकगणितीय बिंदुओं के साथ जुड़ी हुई हैं। यह उन क्षेत्रों में से एक है जहाँ प्रतीकात्मक निष्पादन कार्यक्रमों के बारे में तर्क करने की एक उत्कृष्ट क्षमता है।

तो हम यह कैसे करते हैं? आइए एक पल के लिए शाखाओं और नियंत्रण प्रवाह के बारे में भूल जाएं। हमारे यहां एक सरल कार्यक्रम है। यह कुछ मेमोरी को आवंटित करता है, इसे शून्य करता है, और पॉइंटर x से एक नया पॉइंटर वाई प्राप्त करता है। तब वह y को कुछ लिखती है और जांचती है कि क्या पॉइंटर y में स्टोर किया गया मान पॉइंटर x में स्टोर किए गए मान के बराबर है?

C के मूल ज्ञान के आधार पर, आप देख सकते हैं कि यह चेक नहीं किया गया है क्योंकि x रीसेट है और y = 25 है, इसलिए x एक अलग स्थान को इंगित करता है। अब तक, हमारे साथ सब कुछ ठीक है।
जिस तरह से हम ढेर को मॉडल करते हैं, और जिस तरह से ढेर को अधिकांश सिस्टम पर मॉडलिंग किया जाता है, सी में हीप प्रतिनिधित्व का उपयोग करता है, जहां यह सिर्फ एक विशाल पता आधार है, एक विशाल सरणी जिसमें आप अपना डेटा रख सकते हैं।
इसका मतलब है कि हम अपने कार्यक्रम को एक बहुत बड़े वैश्विक डेटासेट के रूप में प्रस्तुत कर सकते हैं, जिसे एमईएम कहा जाएगा। यह एक ऐसा सरणी है जो अनिवार्य रूप से मानों के पते को मैप करने वाला है। एक पता सिर्फ एक 64-बिट मूल्य है। और इस पते से कुछ पढ़ने के बाद क्या होगा? यह इस बात पर निर्भर करता है कि आप मेमोरी को कैसे मॉडल करते हैं

यदि आप इसे बाइट स्तर पर मॉडल करते हैं, तो आपको एक बाइट मिलती है। यदि आप इसे शब्द स्तर पर मॉडल करते हैं, तो आपको एक शब्द मिलता है। आपकी रुचि के प्रकार के आधार पर, और इस बात पर निर्भर करता है कि आप मेमोरी आवंटन के बारे में चिंतित हैं या नहीं, आप इसे थोड़ा अलग तरीके से मॉडल करेंगे, लेकिन आमतौर पर मेमोरी एड्रेस से वैल्यू तक सिर्फ एक सरणी होती है।



तो पता सिर्फ एक पूर्णांक है। एक तरह से, यह मायने नहीं रखता कि C पता के बारे में क्या सोचता है, यह सिर्फ 64-बिट या 32-बिट पूर्णांक है, जो आपकी मशीन पर निर्भर करता है। यह केवल एक मान है जो इस मेमोरी में अनुक्रमित है। और जिसे आप मेमोरी में डाल सकते हैं, आप उस मेमोरी से पढ़ सकते हैं।

इसलिए, सूचक अंकगणित जैसी चीजें पूर्णांक अंकगणित बन जाती हैं। व्यवहार में, कुछ कठिनाइयाँ हैं, क्योंकि C में, सूचक अंकगणितीय सूचक प्रकारों के बारे में जानते हैं, और वे आकार के अनुपात में बढ़ेंगे। तो, परिणामस्वरूप, हमें निम्नलिखित पंक्ति मिलती है:

y = x + 10;  आकार (इंट)



लेकिन क्या वास्तव में मायने रखता है जब आप स्मृति से लिखते हैं और पढ़ते हैं। सूचक के आधार पर कि 25 को y में लिखा जाना चाहिए, मैं मेमोरी की एक सरणी लेता हूं और इसे y के साथ अनुक्रमित करता हूं। और मैं इस स्मृति स्थान पर 25 लिखता हूं।

फिर मैं MEM [y] = MEM [x] स्टेटमेंट पर आगे बढ़ता हूं, मेमोरी में लोकेशन y से वैल्यू पढ़ता हूं, मेमोरी में लोकेशन x से वैल्यू पढ़ता हूं और उनकी एक-दूसरे से तुलना करता हूं। इसलिए मैं जांचता हूं कि वे मेल खाते हैं या नहीं।

यह एक बहुत ही सरल धारणा है, जो आपको ऐसे प्रोग्राम से स्विच करने की अनुमति देता है जो एक प्रोग्राम में हीप का उपयोग करता है जो इस विशाल वैश्विक सरणी का उपयोग स्मृति का प्रतिनिधित्व करता है। इसका मतलब है कि अब, जब ढेर को प्रबंधित करने वाले कार्यक्रमों के बारे में बात करते हैं, तो आपको वास्तव में उन कार्यक्रमों के बारे में बात करने की ज़रूरत नहीं है जो कि ढेर का प्रबंधन करते हैं। आप सरणियों के बारे में बात करने के लिए पूरी तरह से प्रबंधित करेंगे, और ढेर के बारे में नहीं।

यहाँ एक और सरल प्रश्न है। मॉलोक फ़ंक्शन के बारे में क्या? आप केवल C में मॉलॉक कार्यान्वयन का उपयोग और उपयोग कर सकते हैं, सभी हाइलाइट किए गए पृष्ठों का ट्रैक रख सकते हैं, उन सभी चीज़ों पर नज़र रख सकते हैं, जिन्हें मुक्त किया गया है, बस एक निःशुल्क सूची है, और यह पर्याप्त है। यह पता चला है कि कई उद्देश्यों के लिए और कई प्रकार की त्रुटियों के लिए आपको जटिल होने के लिए मालॉक की आवश्यकता नहीं है।

वास्तव में, आप इस तरह से दिखने वाले मॉलॉक से स्विच कर सकते हैं: x = मॉलॉक (आकार) (इंट) * 100)।

पीओएस = 1
इंट मालोक (int n) {
आरवी = पीओएस
पीओएस + = एन;
}

जो बस कहता है: "मैं स्मृति में अगले खाली स्थान के लिए काउंटर को बचाने जा रहा हूं, और जब भी कोई मुझसे पता पूछता है, तो मैं उसे यह स्थान देता हूं और इस स्थिति को बढ़ाता हूं, और फिर आरवी वापस करता हूं।" इस मामले में, पारंपरिक अर्थों में मॉलोक को पूरी तरह से अनदेखा किया गया है।



इस मामले में, कोई मुक्त स्मृति नहीं है। फ़ंक्शन केवल मेमोरी से और आगे और आगे और आगे और आगे बढ़ना जारी रखता है, और यह वह जगह है जहां यह बिना किसी रिलीज के समाप्त होता है। वह वास्तव में इस बात का भी ध्यान नहीं रखती कि स्मृति के ऐसे क्षेत्र हैं जिनमें वह लिखने लायक नहीं है, क्योंकि ऑपरेटिंग सिस्टम के लिए विशेष महत्व के विशेष पते हैं।

यह ऐसा कुछ भी मॉडल नहीं करता है जो मॉलॉक फ़ंक्शन को जटिल बनाता है, लेकिन केवल एक निश्चित स्तर पर अमूर्तता है, जब आप कुछ प्रकार के जटिल कोड के बारे में बात करने की कोशिश करते हैं जो सूचक जोड़तोड़ करते हैं।

उसी समय, आप स्मृति को मुक्त करने के बारे में परवाह नहीं करते हैं, लेकिन आप इस बारे में चिंतित हैं कि क्या कार्यक्रम चल रहा है, उदाहरण के लिए, एक बफर के बाहर लिखें, इस मामले में यह मल्कोक फ़ंक्शन काफी अच्छा हो सकता है।



और यह वास्तव में बहुत, बहुत बार होता है जब आप वास्तविक कोड का प्रतीकात्मक निष्पादन करते हैं। एक बहुत ही महत्वपूर्ण कदम आपके पुस्तकालय के कार्यों को मॉडलिंग कर रहा है। जिस तरह से आप पुस्तकालय कार्यों का मॉडल तैयार करते हैं, एक तरफ विश्लेषण के प्रदर्शन और मापनीयता पर एक बड़ा प्रभाव पड़ेगा, लेकिन दूसरी ओर, यह सटीकता को भी प्रभावित करेगा।

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

तो यह हमेशा विश्लेषण और दक्षता की सटीकता के बीच एक संतुलन है। और अधिक जटिल मानक कार्यों के मॉडल, जैसे कि मॉलॉक मिलते हैं, उनका विश्लेषण कम मापनीय होता है। लेकिन कुछ त्रुटि वर्गों के लिए आपको इन सरल मॉडल की आवश्यकता होगी। इसलिए, सी में विभिन्न पुस्तकालयों का बहुत महत्व है, जिन्हें समझने के लिए आवश्यक है कि ऐसा कार्यक्रम वास्तव में क्या करता है।

इसलिए, हमने सरणियों के साथ कार्यक्रम के बारे में तर्क देकर ढेर के बारे में तर्क करने की समस्या को कम किया, लेकिन मैंने वास्तव में आपको नहीं बताया कि सरणियों के साथ कार्यक्रम के बारे में कैसे बात करें। यह पता चला है कि अधिकांश श्रीमती सॉल्वर सरणी सिद्धांत का समर्थन करते हैं।



विचार यह है कि अगर एक सरणी है, तो कुछ संकेतन हैं जो आपको इस सरणी को लेने और एक नया सरणी बनाने की अनुमति देते हैं, जहां स्थान i को मान ई में अपडेट किया जाता है। क्या यह स्पष्ट है?

इसलिए, यदि मेरे पास एक सरणी है, और मैं इस अपडेट ऑपरेशन को करता हूं, और फिर k का मान पढ़ने का प्रयास करता हूं, तो इसका मतलब है कि k का मान सरणी a में k के मूल्य के बराबर होगा, यदि k, i से भिन्न है, और यह e के बराबर होगा, यदि k मेरे बराबर है।

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



फिर मैं 5 से लोकेशन i और 7 से लोकेशन j लिखता हूं, जिसके बाद मैं k से पढ़ता हूं और जांचता हूं कि यह 5 है या नहीं। फिर इसे कुछ के लिए परिभाषा का उपयोग करके विस्तारित किया जा सकता है, उदाहरण के लिए: "यदि k i और k y है, जबकि k j से भिन्न है, तो हाँ, यह 5 होगा, अन्यथा यह नहीं होगा ५ ”है।

और व्यवहार में, एसएमटी सॉल्वर केवल कई बुलियन फॉर्मूलों तक इसका विस्तार नहीं करते हैं, वे एसएटी सॉल्वर और इंजन के बीच इस आगे और आगे की रणनीति का उपयोग करते हैं, जो इस काम को करने के लिए सरणी सिद्धांत के बारे में बात करने में सक्षम है।

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

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

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



अधिकांश व्यावहारिक उपकरण बिट वैक्टर के सिद्धांत का पालन करते हैं और यदि आवश्यक हो, तो मॉडल ढेर को सरणियों के सिद्धांत का उपयोग कर सकते हैं। सामान्य तौर पर, व्यावहारिक उपकरण सेट सिद्धांत जैसे अधिक जटिल सिद्धांतों से बचने की कोशिश करते हैं। ऐसा इसलिए है क्योंकि वे आम तौर पर कुछ मामलों में कम स्केलेबल होते हैं, यदि आप एक ऐसे कार्यक्रम से निपट नहीं रहे हैं जो वास्तव में काम करने के लिए इस तरह के उपकरण की आवश्यकता होती है।

श्रोता: प्रतीकात्मक प्रदर्शन के अध्ययन के अलावा, डेवलपर्स किस पर ध्यान केंद्रित करते हैं?

: — , . , , , , . , .

, , . , , , , , , , .

, — , , . , , — , JavaScript Python, . , .



, Python. , , : «, , , ». .

, , , , , .
, , , - , , .

, , , . , , Microsoft Word, , , .

, , , , .

, . , , - , - . , , . , .


पाठ्यक्रम का पूरा संस्करण यहां उपलब्ध है ।

, . ? ? , 30% entry-level , : VPS (KVM) E5-2650 v4 (6 Cores) 10GB DDR4 240GB SSD 1Gbps $20 ? ( RAID1 RAID10, 24 40GB DDR4).

VPS (KVM) E5-2650 v4 (6 करोड़) 10GB DDR4 240GB SSD 1Gbps दिसंबर तक मुफ्त में जब छह महीने की अवधि के लिए भुगतान करते हैं, तो आप यहां ऑर्डर कर सकते हैं ।

Dell R730xd 2 ? 2 Intel Dodeca-Core Xeon E5-2650v4 128GB DDR4 6x480GB SSD 1Gbps 100 $249 ! . c Dell R730xd 5-2650 v4 9000 ?