सामग्री पर जाएँ
Topos Uranos

सारांश

पाठ लूप ने पुनरावृत्ति लिखना सिखाया; यह पाठ उसे सही ढंग से लिखना और यह जानना सिखाता है कि वह सही क्यों है। यह उन पैटर्नों से शुरू होता है जिनसे अधिकांश लूप बनते हैं (काउंटर, संचायक, अधिकतम और न्यूनतम, सेंटिनल और फ़्लैग), और हर पैटर्न इस बात से परिभाषित होता है कि उसका चर हर चक्कर के बाद क्या अर्थ रखता है। यह अवलोकन केंद्रीय अवधारणा तक ले जाता है: निश्चर, यानी चरों के बारे में एक कथन जो पहले चक्कर से पहले और हर चक्कर के बाद सत्य रहता है, और जो लूप से बाहर निकलने की शर्त के साथ मिलकर परिणाम को निष्पन्न करता है। यह चक्करों की संख्या पर आगमन है, और इसके सहारे लूप उलटे क्रम में डिज़ाइन होता है: पहले वह जो अंत में सत्य होना चाहिए, फिर निश्चर, और सबसे अंत में बॉडी। समाप्ति को वैरिएंट से सिद्ध किया जाता है, जिसका परिचय पाठ समस्या से एल्गोरिदम तक में दिया जा चुका है, और यह पाठ तीन ऐसे लूप दिखाता है जो समाप्त नहीं होते: एक वास्तविक संख्या वाली शर्त के साथ, एक बिना चिह्न वाले काउंटर के साथ, और एक जिसका चिह्नयुक्त काउंटर ओवरफ़्लो होता है, जो अपरिभाषित व्यवहार है। अंत में Visual Studio Code के डिबगर से पहला परिचय होता है, जो प्रोग्राम को किसी पंक्ति पर रोकता है और उसके चरों को चक्कर-दर-चक्कर दिखाता है।

अधिगम उद्देश्य

  1. किसी लूप में काउंटर, संचायक, अधिकतम और सेंटिनल के पैटर्न पहचानना, और नए लूप डिज़ाइन करने के लिए उनका उपयोग करना।
  2. किसी सरल लूप का निश्चर कहना और यह पुष्ट करना कि वह किसी भी चक्कर में बना रहता है।
  3. किसी लूप की समाप्ति को ऐसी पूर्णांक राशि से सिद्ध करना जो घटती है और नीचे से परिबद्ध है।
  4. Visual Studio Code के डिबगर से, एक ब्रेकपॉइंट और चरों के व्यू की मदद से, किसी लूप के निष्पादन का अनुसरण करना।

पैटर्न

किसी चर का अर्थ

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

  • काउंटर का मान यह है कि कितने डेटा संसाधित हो चुके हैं (या उनमें से कितने किसी शर्त को पूरा करते हैं)। उसे 0 से इनिशियलाइज़ किया जाता है, क्योंकि पहले चक्कर से पहले कोई भी डेटा संसाधित नहीं हुआ होता, और उसे ++count से अद्यतन किया जाता है, केवल तब जब गिनने लायक कुछ हो।
  • संचायक का मान संसाधित डेटा का संयुक्त फल है: उनका योग, उनका गुणनफल। उसे संक्रिया के तत्समक अवयव से इनिशियलाइज़ किया जाता है (योग के लिए 0, गुणनफल के लिए 1), क्योंकि एक भी डेटा न होने पर योग 0 होता है और गुणनफल 1।
  • अधिकतम का मान संसाधित डेटा में सबसे बड़ा है, और न्यूनतम का, सबसे छोटा। एक भी डेटा न होने पर अधिकतम का अस्तित्व नहीं होता: इसीलिए उसे पहले डेटा से इनिशियलाइज़ किया जाता है, किसी मनमाने ढंग से चुनी गई संख्या से नहीं।
  • सेंटिनल इनपुट का एक ऐसा मान है जो डेटा नहीं, बल्कि इस बात का संकेत है कि डेटा समाप्त हो गया। यह पैटर्न लूप से पहले एक बार और बॉडी के अंत में एक बार फिर पढ़ने की माँग करता है, जैसा पाठ लूप ने शून्य तक जोड़ते समय किया था, ताकि शर्त हर मान की जाँच उसके संसाधित होने से पहले करे, और सेंटिनल कभी डेटा के रूप में न गिना जाए।
  • फ़्लैग एक bool है जो बताता है कि संसाधित डेटा के बीच कोई बात कभी एक बार भी हुई या नहीं। उसे false से इनिशियलाइज़ किया जाता है और वह बात पहली बार होने पर true हो जाता है; बाद का कोई भी चक्कर उसे फिर false नहीं करता।

सभी पुर्ज़ों वाला एक उदाहरण

वर्षा का एक रजिस्टर हर दिन गिरी बारिश को मिलीमीटर में दर्ज करता है। प्रोग्राम पहले एक देहली-मान पढ़ता है, और फिर कई दिनों के माप, जो एक ऋणात्मक संख्या पर समाप्त होते हैं; यह संख्या संभव माप नहीं है और सेंटिनल का काम करती है। प्रोग्राम लिखता है कि कितने माप हैं, उनका औसत, अधिकतम, कितने दिन देहली-मान से ऊपर रहे, और क्या कोई दिन बिना बारिश का था।

C++ प्रोग्राम
#include <iostream>#include <print>​int main(){    double threshold{};    std::cin >> threshold;    int count{0};          // काउंटर: संसाधित माप    int aboveCount{0};     // काउंटर: देहली-मान से ऊपर के माप    double total{0.0};     // संचायक: मापों का योग    double largest{0.0};   // अधिकतम: सार्थक केवल तब जब count > 0    bool dryDay{false};    // फ़्लैग: कोई दिन बिना बारिश का था    double value{};    std::cin >> value;    while (std::cin && value >= 0.0) {        if (count == 0 || value > largest) {            largest = value;        }        ++count;        total += value;        if (value > threshold) {            ++aboveCount;        }        if (value == 0.0) {            dryDay = true;        }        std::cin >> value;    }    if (count == 0) {        std::println("कोई माप नहीं है।");    } else {        std::println("माप: {}; औसत: {:.2f} मिमी", count, total / count);        std::println("अधिकतम: {:.1f} मिमी; {:.1f} मिमी से अधिक वाले दिन: {}", largest, threshold, aboveCount);        std::println("बिना बारिश के दिन थे: {}", dryDay ? "हाँ" : "नहीं");    }}
प्रोग्राम का इनपुट
104.5 0 12.5 21.5 7.5 -1
आउटपुट
माप: 5; औसत: 9.20 मिमीअधिकतम: 21.5 मिमी; 10.0 मिमी से अधिक वाले दिन: 2बिना बारिश के दिन थे: हाँ

चार निर्णय टिप्पणी के योग्य हैं। शर्त count == 0 || value > largest अलग से पढ़े बिना अधिकतम को पहले डेटा से इनिशियलाइज़ करती है: पहले चक्कर में काउंटर 0 होता है और असाइनमेंट हमेशा होता है; बाद के चक्करों में, केवल तब जब डेटा अधिकतम से बड़ा हो। तुलना value == 0.0 सटीक है, क्योंकि मान पढ़ा गया है, गणना से नहीं निकला: अंक 0 सटीक शून्य में बदलता है, और पाठ फ़्लोटिंग-पॉइंट संख्याएँ की == के विरुद्ध चेतावनी संक्रियाओं के परिणामों के बारे में है। लूप की शर्त में std::cin शामिल है, ताकि जो इनपुट बिना सेंटिनल के समाप्त हो जाए, वह भी लूप को समाप्त कर दे। और औसत की गणना तभी होती है जब माप हों: count के 0 होने पर total / count का मान 0/00/0 होता, जो फ़्लोटिंग पॉइंट में त्रुटि नहीं, बल्कि “संख्या नहीं” नामक मान है, जिसे प्रोग्राम बिना किसी चेतावनी के लिख देता।

उदाहरणचक्कर-दर-चक्कर चर

प्रमाण

  1. लूप से पहले: देहली-मान 10 है, दोनों काउंटर और संचायक 0 हैं, फ़्लैग असत्य है, और पहला माप, 4.5, पढ़ा जा चुका है। अधिकतम 0 है, पर जब तक count 0 है, इस मान का कोई अर्थ नहीं।

  2. पहला चक्कर: count 0 है, इसलिए 4.5 अधिकतम बन जाता है; काउंटर 1 तक और कुल योग 4.5 तक बढ़ता है। 0 पढ़ा जाता है।

  3. दूसरा चक्कर: 0 अधिकतम से बड़ा नहीं है, पर वह फ़्लैग उठा देता है। 12.5 पढ़ा जाता है।

  4. तीसरा चक्कर: 12.5 नया अधिकतम है और देहली-मान से ऊपर है: aboveCount 1 तक बढ़ता है। 21.5 पढ़ा जाता है।

  5. चौथा चक्कर: 21.5 नया अधिकतम है और वह भी देहली-मान से ऊपर है। 7.5 पढ़ा जाता है।

  6. पाँचवाँ चक्कर: 7.5 न अधिकतम बदलता है, न aboveCount; कुल योग 46 तक पहुँचता है। −1-1 पढ़ा जाता है।

  7. शर्त −1-1 की जाँच करती है, जो ऋणात्मक है: लूप उसे संसाधित किए बिना समाप्त हो जाता है। औसत 46/5=9.246 / 5 = 9.2 है।

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