जो मुझे DataGenetics वेबसाइट पर मिला। कृपया इस लेख की सभी त्रुटियों को निजी संदेशों में भेजें।

इस समस्या में, जेल में 100 कैदी हैं, प्रत्येक की संख्या 1 से 100 तक है। जेलर कैदियों को रिहा होने का मौका देने का फैसला करता है, वह उन्हें परीक्षण की शर्तें बताता है, और यदि सभी कैदी परीक्षा पास करते हैं, फिर उन्हें रिहा कर दिया जाएगा। यदि उनमें से कम से कम एक परीक्षण में विफल हो जाता है, तो सभी कैदी मर जाएंगे।

काम

जेलर जाता है गुप्त कमरेऔर ढक्कन के साथ 100 बक्से तैयार करता है। प्रत्येक पेटी पर वह 1 से 100 तक अंक अंकित करता है। फिर वह कैदियों की संख्या के अनुसार 100 कागज की गोलियां लाता है, और इन गोलियों की संख्या 1 से 100 तक करता है। उसके बाद, वह 100 गोलियों को फेरबदल करता है और प्रत्येक बॉक्स में एक टैबलेट रखता है, ढक्कन बंद करना। कैदी यह नहीं देखते कि जेलर इन सभी कार्यों को कैसे करता है।

प्रतियोगिता शुरू होती है, जेलर प्रत्येक कैदी को बक्सों के साथ एक-एक करके कमरे में ले जाता है और कैदियों से कहता है कि उन्हें एक ऐसा बॉक्स खोजना होगा जिसमें कैदी की संख्या के साथ एक प्लेट होगी। कैदी बक्सों को खोलकर अपने नंबर वाली प्लेट ढूंढने की कोशिश कर रहे हैं। प्रत्येक को 50 बक्से तक खोलने की अनुमति है; यदि प्रत्येक कैदी को अपना नंबर मिल जाए, तो कैदियों को रिहा कर दिया जाएगा, यदि उनमें से कम से कम एक को 50 प्रयासों में अपना नंबर नहीं मिला, तो सभी कैदी मर जाएंगे।

कैदियों को रिहा करने के लिए, सभी कैदियों को सफलतापूर्वक परीक्षण पास करना होगा।

तो क्या मौका है कि कैदियों को माफ कर दिया जाएगा?

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

कैदियों के लिए सबसे अच्छी रणनीति क्या है?

अतिरिक्त प्रश्न:

यदि कैदियों का कोई मित्र (परीक्षण में भाग लेने वाला नहीं) परीक्षण शुरू होने से पहले गुप्त कक्ष में प्रवेश करने में सक्षम होगा, तो सभी बक्से में सभी गोलियों की जांच करें और (वैकल्पिक रूप से, लेकिन आवश्यक नहीं) दो बक्से से दो गोलियां स्वैप करें (इस मामले में, कॉमरेड को दोनों को अपने कार्यों के परिणाम के बारे में कैदियों को सूचित करने का अवसर नहीं मिलेगा), तो उसे कैदियों के भागने की संभावना बढ़ाने के लिए क्या रणनीति अपनानी चाहिए?

समाधान असंभव है?

पहली नज़र में, यह कार्य लगभग निराशाजनक लगता है। ऐसा लगता है कि प्रत्येक कैदी के लिए अपना टैबलेट खोजने का मौका सूक्ष्म रूप से छोटा है। इसके अलावा, कैदी ट्रायल के दौरान एक-दूसरे के साथ सूचनाओं का आदान-प्रदान नहीं कर सकते हैं।

एक कैदी का ऑड्स 50:50 है। कुल 100 बक्से हैं और वह अपने चिन्ह की तलाश में 50 बक्से तक खोल सकता है। यदि वह बेतरतीब ढंग से बक्से खोलता है और सभी बक्से में से आधे को खोलता है, तो उसे अपनी गोली बक्से के खुले आधे हिस्से में मिलेगी, या उसका टैबलेट बंद 50 बक्से में रहेगा। उसकी सफलता की संभावना ½ है।

चलो दो कैदी लेते हैं। यदि दोनों यादृच्छिक रूप से बक्से चुनते हैं, तो उनमें से प्रत्येक के लिए संभावना ½ होगी, और दो ½x½=¼ के लिए।
(दो कैदियों के लिए, चार में से एक मामले में सफलता मिलेगी)।

तीन कैदियों के लिए ऑड्स ½ × ½ × ½ = हैं।

100 कैदियों के लिए, ऑड्स हैं: ½ × ½ × … ½ × ½ (100 बार गुणा करें)।

यह बराबर है

जनसंपर्क 0.000000000000000000000000000008

तो यह बहुत छोटा मौका है। इस परिदृश्य में, सबसे अधिक संभावना है, सभी कैदी मर जाएंगे।

अविश्वसनीय उत्तर

यदि प्रत्येक कैदी यादृच्छिक रूप से बक्से खोलता है, तो उनके परीक्षा पास करने की संभावना नहीं है। ऐसी रणनीति है जहां कैदी 30% से अधिक बार सफल होने की उम्मीद कर सकते हैं। यह आश्चर्यजनक रूप से अविश्वसनीय परिणाम है (यदि आपने इसके बारे में नहीं सुना है गणितीय समस्यापहले)।

सभी 100 कैदियों के लिए 30% से अधिक! हाँ, यह दो कैदियों के लिए अवसरों से भी अधिक है, बशर्ते कि वे बक्से को यादृच्छिक रूप से खोलें। लेकिन यह कैसे संभव है?

यह स्पष्ट है कि प्रत्येक कैदी के लिए, संभावना 50% से अधिक नहीं हो सकती (आखिरकार, कैदियों के बीच संचार का कोई तरीका नहीं है)। लेकिन यह मत भूलो कि जानकारी बक्से के अंदर प्लेटों के स्थान पर संग्रहीत है। अलग-अलग कैदियों द्वारा कमरे में आने के बीच कोई भी टैबलेट में फेरबदल नहीं करता है, इसलिए हम उस जानकारी का उपयोग कर सकते हैं।

फेसला

पहले, मैं आपको समाधान बताऊंगा, फिर मैं समझाऊंगा कि यह क्यों काम करता है।

रणनीति बेहद आसान है। कैदियों में से पहला अपने कपड़ों पर लिखे नंबर के साथ बॉक्स खोलता है। उदाहरण के लिए, कैदी संख्या 78 78 नंबर के साथ बॉक्स खोलता है। यदि वह बॉक्स के अंदर प्लेट पर अपना नंबर पाता है, तो यह बहुत अच्छा है! यदि नहीं, तो वह प्लेट पर "उसके" बॉक्स में नंबर को देखता है और फिर उस नंबर के साथ अगला बॉक्स खोलता है। दूसरा बॉक्स खोलने के बाद वह इस बॉक्स के अंदर टैबलेट का नंबर देखता है और इस नंबर के साथ तीसरा बॉक्स खोलता है। फिर हम बस इस रणनीति को शेष बक्सों में स्थानांतरित कर देते हैं। स्पष्टता के लिए, चित्र को देखें:

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

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

तो रणनीति क्यों काम करती है?

प्रत्येक बॉक्स में एक प्लेट होती है - और यह प्लेट अद्वितीय है। इसका मतलब है कि प्लेट एक ही नंबर वाले बॉक्स में है, या यह एक अलग बॉक्स की ओर इशारा करती है। चूंकि सभी प्लेट अद्वितीय हैं, इसलिए प्रत्येक बॉक्स को इंगित करने के लिए केवल एक प्लेट है (और उस बॉक्स तक पहुंचने का केवल एक ही रास्ता है)।

यदि आप इसके बारे में सोचते हैं, तो बक्से एक बंद गोलाकार श्रृंखला बनाते हैं। एक बॉक्स केवल एक श्रृंखला का हिस्सा हो सकता है, क्योंकि बॉक्स के अंदर अगले एक के लिए केवल एक पॉइंटर होता है और तदनुसार, पिछले बॉक्स में इस बॉक्स में केवल एक पॉइंटर होता है (प्रोग्रामर लिंक्ड सूचियों के साथ सादृश्य देख सकते हैं)।

यदि बॉक्स स्वयं को इंगित नहीं करता है (बॉक्स संख्या इसमें प्लेट संख्या के बराबर है), तो यह श्रृंखला में होगा। कुछ जंजीरों में दो बक्से हो सकते हैं, कुछ लंबे होते हैं।

चूंकि सभी कैदी अपने कपड़ों पर एक ही नंबर वाले बॉक्स से शुरू करते हैं, परिभाषा के अनुसार, उन्हें उस चेन पर रखा जाता है जिसमें उनकी नेमप्लेट होती है (केवल एक नेमप्लेट है जो इस बॉक्स की ओर इशारा करती है)।

इस श्रृंखला के साथ एक सर्कल में बक्से की खोज करते हुए, उन्हें अंततः अपनी प्लेट खोजने की गारंटी दी जाती है।

एकमात्र सवाल यह है कि क्या वे 50 चालों में अपना टैबलेट पाएंगे।

चेन की लंबाई

सभी कैदियों को परीक्षा पास करने के लिए, अधिकतम श्रृंखला की लंबाई 50 बक्से से कम होनी चाहिए। यदि श्रृंखला 50 बक्से से अधिक लंबी है, तो उन जंजीरों से संख्या वाले कैदी परीक्षण में असफल हो जाएंगे - और सभी कैदी मर जाएंगे।

यदि सबसे लंबी श्रृंखला की अधिकतम लंबाई 50 बक्सों से कम है, तो सभी कैदी परीक्षा पास करेंगे!

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

लंबी श्रृंखला हाथ बाधाओं

एक बार जब आप अपने आप को आश्वस्त कर लेते हैं कि सफल होने के लिए अधिकतम श्रृंखला की लंबाई 50 से कम या उसके बराबर होनी चाहिए, और किसी भी सेट में केवल एक लंबी श्रृंखला हो सकती है, तो हम चुनौती को पार करने की संभावना की गणना कर सकते हैं:

कुछ और गणित

तो हमें एक लंबी श्रृंखला की संभावना का पता लगाने की क्या ज़रूरत है?

लंबाई l की एक श्रृंखला के लिए, संभावना है कि बक्से इस श्रृंखला के बाहर होंगे:

संख्याओं के इस संग्रह में (l-1) है! संकेतों को व्यवस्थित करने के तरीके।

शेष संकेत स्थित हो सकते हैं (100-एल)! तरीके (यह मत भूलो कि श्रृंखला की लंबाई 50 से अधिक नहीं है)।

इसे देखते हुए, श्रृंखला वाले क्रमपरिवर्तन की संख्या सटीक लंबाईएल: (>50)

यह पता चला है कि प्लेटों को व्यवस्थित करने के 100 (!) तरीके हैं, ताकि लंबाई की एक श्रृंखला के अस्तित्व की संभावना 1/ली के बराबर हो। वैसे, यह परिणाम बक्सों की संख्या पर निर्भर नहीं करता है।

जैसा कि हम पहले से ही जानते हैं, केवल एक ही मामला हो सकता है जिसमें लंबाई> 50 के साथ एक श्रृंखला हो, इसलिए सफलता की संभावना की गणना इस सूत्र द्वारा की जाती है:

नतीजा

31.18% - संभावना है कि सबसे लंबी श्रृंखला का आकार 50 से कम होगा और प्रत्येक कैदी 50 प्रयासों की सीमा को देखते हुए अपनी प्लेट ढूंढ पाएगा।

सभी कैदियों के अपनी प्लेट ढूंढ़ने और परीक्षा पास करने की प्रायिकता 31.18% है

नीचे एक ग्राफ दिया गया है जो लंबाई l (x-अक्ष पर) की सभी श्रृंखलाओं के लिए संभावनाओं (y-अक्ष पर) दिखा रहा है। लाल का अर्थ है सभी "विफलताएं" (यहां दिया गया वक्र केवल 1/ली प्लॉट है)। हरा रंगका अर्थ है "सफलता" (ग्राफ़ के इस भाग के लिए गणना थोड़ी अधिक जटिल है, क्योंकि निर्धारित करने के कई तरीके हैं अधिकतम लंबाई <50). Общая вероятность складывается из зеленых столбцов в 31.18% шанс на спасение.

हार्मोनिक नंबर (लेख का यह हिस्सा गीक्स के लिए है)

गणित में, nवाँ हार्मोनिक संख्या प्राकृतिक श्रृंखला की पहली n क्रमागत संख्याओं के व्युत्क्रमों का योग है।

आइए सीमा की गणना करें यदि 100a बक्से के बजाय हमारे पास एक मनमाना है एक बड़ी संख्या कीबॉक्स (मान लें कि हमारे पास कुल 2n बॉक्स हैं)।

यूलर-माशेरोनी स्थिरांक एक स्थिरांक है जिसे एक हार्मोनिक श्रृंखला के आंशिक योग और एक संख्या के प्राकृतिक लघुगणक के बीच अंतर की सीमा के रूप में परिभाषित किया गया है।

जैसे-जैसे कैदियों की संख्या बढ़ती है, अगर ओवरसियर कैदियों को आधे डिब्बे खोलने की अनुमति देता है, तो मोक्ष की संभावना 30.685% हो जाती है।

(यदि आप कोई निर्णय लेते हैं जिसमें कैदी बेतरतीब ढंग से बक्से का अनुमान लगाते हैं, तो जैसे-जैसे कैदियों की संख्या बढ़ती है, बचने की संभावना शून्य हो जाती है!)

अतिरिक्त प्रश्न

किसी और को अतिरिक्त प्रश्न याद है? हमारे मददगार कॉमरेड हमारे बचने की संभावना बढ़ाने के लिए क्या कर सकते हैं?

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

इस रणनीति के परिणामस्वरूप, लंबी जंजीरें नहीं होंगी और सभी कैदियों को उनकी निशानी और मुक्ति पाने की गारंटी दी जाती है। तो, दो संकेतों की अदला-बदली करके, हम मोक्ष की संभावना को 100% तक कम कर देते हैं!

याद रखें कि एक घनाभ (या एक साधारण बॉक्स) का आयतन उसकी लंबाई, चौड़ाई और ऊंचाई के गुणनफल के बराबर होता है। यदि आपका बॉक्स आयताकार या वर्गाकार है, तो आपको केवल इसकी लंबाई, चौड़ाई और ऊंचाई जानने की जरूरत है। मात्रा प्राप्त करने के लिए, माप के परिणामों को गुणा करना आवश्यक है। संक्षिप्त रूप में गणना सूत्र अक्सर निम्नानुसार प्रस्तुत किया जाता है: वी \u003d एल एक्स डब्ल्यू एक्स एच।
समस्या उदाहरण: "यदि बॉक्स की लंबाई 10 सेमी है, चौड़ाई 4 सेमी है, और ऊंचाई 5 सेमी है, तो इसका आयतन क्या है?"
वी = एल एक्स डब्ल्यू एक्स एच
वी = 10cmx4cmx5cm
वी \u003d 200 सेमी 3
बॉक्स की "ऊंचाई" को "गहराई" के रूप में संदर्भित किया जा सकता है। उदाहरण के लिए, किसी कार्य में निम्न जानकारी हो सकती है: "बॉक्स की लंबाई 10 सेमी, चौड़ाई 4 सेमी और गहराई 5 सेमी है।"

2
बॉक्स की लंबाई को मापें। यदि आप ऊपर से बॉक्स को देखेंगे, तो यह आपकी आंखों के सामने एक आयत के रूप में दिखाई देगा। बॉक्स की लंबाई इस आयत की सबसे लंबी भुजा होगी। इस पक्ष की माप के परिणाम को "लंबाई" पैरामीटर के मान के रूप में रिकॉर्ड करें।
माप लेते समय माप की एक ही इकाई का उपयोग करना सुनिश्चित करें। यदि आपने एक भुजा को सेंटीमीटर में मापा है, तो दूसरी भुजा को भी सेंटीमीटर में मापा जाना चाहिए।

3
बॉक्स की चौड़ाई को मापें। बॉक्स की चौड़ाई को ऊपर से दिखाई देने वाले आयत के दूसरे, छोटे, पक्ष द्वारा दर्शाया जाएगा। यदि आप लंबाई और चौड़ाई में मापे गए बॉक्स के किनारों को नेत्रहीन रूप से जोड़ते हैं, तो वे "जी" अक्षर के रूप में दिखाई देंगे। अंतिम माप के मान को "चौड़ाई" के रूप में रिकॉर्ड करें।
चौड़ाई हमेशा बॉक्स की छोटी तरफ होती है।

4
बॉक्स की ऊंचाई को मापें। यह अंतिम पैरामीटर है जिसे आपने अभी तक नहीं मापा है। यह बॉक्स के ऊपरी किनारे से नीचे तक की दूरी को दर्शाता है। इस माप के मान को "ऊंचाई" के रूप में रिकॉर्ड करें।
आप बॉक्स को किस तरफ रखते हैं, इस पर निर्भर करते हुए, आपके द्वारा "लंबाई", "चौड़ाई" या "ऊंचाई" के रूप में निर्दिष्ट विशिष्ट पक्ष भिन्न हो सकते हैं। हालाँकि, इससे कोई फर्क नहीं पड़ता, आपको केवल तीन अलग-अलग पक्षों से माप की आवश्यकता है।

5
तीन मापों के परिणामों को एक साथ गुणा करें। जैसा कि पहले ही उल्लेख किया गया है, आयतन की गणना का सूत्र इस प्रकार है: V = लंबाई x चौड़ाई x ऊँचाई; इसलिए, आयतन प्राप्त करने के लिए, आपको बस तीनों पक्षों को गुणा करना होगा। गणना में आपके द्वारा उपयोग की जाने वाली इकाइयों को निर्दिष्ट करना सुनिश्चित करें ताकि आप यह न भूलें कि वास्तव में मूल्यों का क्या अर्थ है।

6
वॉल्यूम इकाइयों को इंगित करते समय, तीसरी शक्ति " 3 " को इंगित करना न भूलें। परिकलित आयतन में एक संख्यात्मक अभिव्यक्ति होती है, लेकिन माप की इकाइयों के सही संकेत के बिना, आपकी गणना निरर्थक होगी। मात्रा इकाइयों को सही ढंग से प्रतिबिंबित करने के लिए, उन्हें घन में निर्दिष्ट किया जाना चाहिए। उदाहरण के लिए, यदि सभी पक्षों को सेंटीमीटर में मापा जाता है, तो वॉल्यूम इकाइयों को "cm3" के रूप में निर्दिष्ट किया जाएगा।
एक समस्या का एक उदाहरण: "यदि एक बॉक्स की लंबाई 2 मीटर, चौड़ाई 1 मीटर और ऊंचाई 3 मीटर है, तो इसका आयतन क्या है?"
वी = एल एक्स डब्ल्यू एक्स एच
वी = 2m x 1m x 4m
वी \u003d 8 मीटर 3
नोट: आयतन की घन इकाई निर्दिष्ट करने से आप यह समझ सकते हैं कि ऐसे कितने घन डिब्बे के अंदर रखे जा सकते हैं। यदि हम पिछले उदाहरण का उल्लेख करते हैं, तो इसका मतलब है कि आठ घन मीटर एक बॉक्स में रखे गए हैं।

अन्य आकृतियों के बक्सों के आयतन की गणना

सिलेंडर का आयतन ज्ञात कीजिए। बेलन एक गोल नली होती है जिसके दोनों सिरों पर वृत्त होते हैं। एक बेलन का आयतन निर्धारित करने के लिए, सूत्र का उपयोग किया जाता है: V = x r 2 x h, जहाँ = 3.14, r बेलन की गोल भुजा की त्रिज्या है, और h इसकी ऊँचाई है।
एक शंकु, या एक गोल आधार के साथ एक पिरामिड का आयतन निर्धारित करने के लिए, एक ही सूत्र का उपयोग किया जाता है, लेकिन 1/3 से गुणा किया जाता है। अर्थात्, शंकु के आयतन की गणना सूत्र द्वारा की जाती है: V = 1/3 (π x r 2 x h)

2
पिरामिड का आयतन ज्ञात कीजिए। पिरामिड एक ऐसी आकृति होती है जिसका आधार समतल होता है और भुजाएँ शीर्ष पर एक बिंदु पर परिवर्तित होती हैं। पिरामिड की मात्रा निर्धारित करने के लिए, आपको इसके आधार और ऊंचाई के क्षेत्र के उत्पाद का 1/3 भाग लेना होगा। यानी गणना सूत्र इस प्रकार है: पिरामिड का आयतन = 1/3 (आधार क्षेत्र x ऊँचाई)।
ज्यादातर मामलों में, पिरामिड का एक वर्ग या आयताकार आधार होता है। ऐसी स्थिति में, आधार के क्षेत्रफल की गणना आधार की लंबाई को चौड़ाई से गुणा करके की जाती है।

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

एक प्रोग्राम लिखें जो कीबोर्ड से दर्ज किए गए दो पूर्णांकों की तुलना करता है। प्रोग्राम को इंगित करना चाहिए कि कौन सी संख्या अधिक है, या, यदि संख्याएँ समान हैं, तो एक उपयुक्त संदेश प्रदर्शित करें।

दो पूर्णांक टाइप करें और एंटर दबाएं।
-> 34 67
34 67 से कम

Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; प्रक्रिया मुख्य है ए, बी: पूर्णांक; पुट_लाइन शुरू करें ("एक पंक्ति में दो पूर्णांक दर्ज करें और एंटर दबाएं।"); डाल ("->"); प्राप्त); प्राप्त करें (बी); - 2 नंबर दर्ज करें यदि ए> बी तो पुट (आइटम =>; ए, चौड़ाई =>; 1); पुट ("से अधिक"); पुट (आइटम => बी, चौड़ाई => 1); एल्सिफ ए< B then Put(Item =>ए, चौड़ाई => 1); पुट ("से कम"); पुट (आइटम => बी, चौड़ाई => 1); और पुट ("दर्ज किए गए नंबर बराबर हैं!"); अगर अंत; मुख्य अंत;

तीन पूर्णांक दिए गए हैं। उनमें से सबसे बड़ा खोजें (कार्यक्रम को बिल्कुल एक पूर्णांक आउटपुट करना चाहिए)। इस समस्या में सबसे बड़ी संख्या को एक संख्या के रूप में समझा जाता है जो किसी अन्य से कम नहीं है।

• 
  -> 1 2 3
  अधिकतम तीन नंबर: 3

• Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; प्रक्रिया मुख्य ए, बी, सी है: पूर्णांक; अधिकतम: पूर्णांक; पुट_लाइन शुरू करें ( "एक पंक्ति में तीन पूर्णांक दर्ज करें और एंटर दबाएं।") ; पुट ("->"); प्राप्त); प्राप्त करें (बी); प्राप्त करें (सी); --तीन पूर्णांक दर्ज करेंअधिकतम: = ए; --चूकहम मानते हैं कि संख्या ए अधिकतम हैअगर बी> अधिकतम तो --यदि B अधिकतम से बड़ा है, तोअधिकतम: = बी; --अधिकतम संख्या B . हैअगर अंत ; अगर सी> अधिकतम तो --यदि C अधिकतम से बड़ा है, तोअधिकतम: = सी; --अधिकतम संख्या C . हैअगर अंत ; डाल( "अधिकतम तीन नंबर:"और पूर्णांक"छवि (अधिकतम)); मुख्य अंत;

  Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; प्रक्रिया मुख्य ए, बी, सी है: पूर्णांक; अधिकतम: पूर्णांक; पुट_लाइन शुरू करें ("एक पंक्ति में तीन पूर्णांक दर्ज करें और एंटर दबाएं।"); डाल ("->"); प्राप्त); प्राप्त करें (बी); प्राप्त करें (सी); --तीन पूर्णांक अधिकतम दर्ज करें:= ए; - डिफ़ॉल्ट रूप से, हम मानते हैं कि संख्या ए अधिकतम है यदि बी> अधिकतम तो - यदि बी अधिकतम से बड़ा है, तो अधिकतम: = बी; --अधिकतम संख्या बी अंत है अगर; यदि सी > अधिकतम तो -- यदि सी अधिकतम से अधिक है, तो अधिकतम: = सी; --अधिकतम संख्या सी अंत के बराबर है अगर; पुट ("अधिकतम तीन संख्याएँ:" और पूर्णांक "छवि (अधिकतम)); मुख्य अंत;

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

• त्रिभुज की तीनों भुजाओं में टाइप करें और एंटर दबाएं।
  -> 3 4 5
  3, 4, 5 भुजाओं वाला एक त्रिभुज मौजूद है।

त्रिभुज तीन बिंदु होते हैं जो एक ही रेखा पर नहीं होते हैं। त्रिभुज का अस्तित्व तभी होता है जब उसकी किन्हीं दो भुजाओं का योग तीसरे से अधिक हो।

• Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; -- पूर्णांक पढ़ने के लिए Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; -- तार प्रदर्शित करने के लिएप्रक्रिया मुख्य ए, बी, सी है: पूर्णांक; पुट_लाइन शुरू करें ( "एक त्रिभुज की तीन भुजाएँ दर्ज करें और Enter दबाएँ। दर्ज करें।") ; पुट ("->"); प्राप्त); प्राप्त करें (बी); प्राप्त करें (सी); --त्रिभुज की भुजाएं पढ़ेंयदि a + b > c और फिर b + c > a और फिर c + a > b तो -- सभी शर्तों को एक लाइन में जांचेंडाल( "पक्षों के साथ त्रिभुज"और पूर्णांक"छवि (ए) और "," और पूर्णांक "छवि (बी) और "," और पूर्णांक "छवि (सी) और "मौजूद है") ;अन्यथा रखो( "पक्षों के साथ त्रिभुज"और पूर्णांक"छवि (ए) और "," और पूर्णांक "छवि (बी) और "," और पूर्णांक "छवि (सी) और "मौजूद नहीं है"); अंत अगर; अंत मुख्य;

  Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; - Ada.Text_IO के साथ पूर्णांक पढ़ने के लिए; Ada.Text_IO का उपयोग करें; - स्ट्रिंग्स प्रक्रिया को प्रिंट करने के लिए मुख्य है a, b, c: Integer; start Put_Line ("त्रिकोण की तीन भुजाएँ दर्ज करें और Enter दबाएँ। दर्ज करें।"); डाल ("->"); प्राप्त); प्राप्त करें (बी); प्राप्त करें (सी); -- त्रिभुज भुजाएँ पढ़ें यदि a + b > c और फिर b + c > a और फिर c + a > b तो -- एक पंक्ति में सभी स्थितियों की जाँच करें Put("पक्षों के साथ त्रिभुज" और पूर्णांक"छवि (ए) और " , "और पूर्णांक" छवि (बी) और "," और पूर्णांक "छवि (सी) और "मौजूद है"); अन्य रखो ("पक्षों के साथ त्रिभुज" और पूर्णांक "छवि (ए) और "," और पूर्णांक "छवि ( बी) और "," और पूर्णांक "छवि (सी) और "मौजूद नहीं है"); अगर अंत; मुख्य अंत;

तीन पूर्णांक दिए गए हैं। निर्धारित करें कि उनमें से कितने मेल खाते हैं। प्रोग्राम को संख्याओं में से एक को आउटपुट करना चाहिए: 3 (यदि सभी समान हैं), 2 (यदि दो समान हैं), या 0 (यदि सभी अलग हैं)।

• तीन पूर्णांक टाइप करें और एंटर दबाएं।
  -> 1 2 3
  0

• Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; प्रक्रिया मुख्य है ए, बी, सी: पूर्णांक; पुट_लाइन शुरू करें ( "तीन पूर्णांक दर्ज करें और एंटर दबाएं।") ; पुट ("->"); प्राप्त); प्राप्त करें (बी); प्राप्त करें (सी); अगर ए = बी और फिर ए = सी तो --यदि तीनों संख्याएँ मेल खाती हैंरखो (आइटम => 3, चौड़ाई => 1); एल्सिफ ए = बी या ए = सी या बी = सी तो --यदि दो अंक मेल खाते हैंरखो (आइटम => 2, चौड़ाई => 1); वरना --यदि एक वही नंबरनहींरखो (आइटम => 0, चौड़ाई => 1); अगर अंत ; एंडमेन;

  Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; प्रक्रिया मुख्य है ए, बी, सी: पूर्णांक; पुट_लाइन शुरू करें ("तीन पूर्णांक दर्ज करें और एंटर दबाएं।"); डाल ("->"); प्राप्त); प्राप्त करें (बी); प्राप्त करें (सी); अगर ए = बी और फिर ए = सी तो - यदि तीनों नंबर पुट से मेल खाते हैं (आइटम => 3, चौड़ाई => 1); एल्सिफ ए = बी या ए = सी या बी = सी तो - यदि दो नंबर पुट से मेल खाते हैं (आइटम => 2, चौड़ाई => 1); अन्य - यदि कोई समान संख्याएँ नहीं हैं पुट (आइटम => 0, चौड़ाई => 1); अगर अंत; एंडमेन;

शतरंज का किश्ती क्षैतिज या लंबवत चलता है। दिया गया दो विभिन्न कोशिकाएं बिसात, निर्धारित करें कि क्या किश्ती एक चाल में पहली सेल से दूसरी सेल में जा सकता है। प्रोग्राम इनपुट के रूप में 1 से 8 तक प्रत्येक के लिए चार नंबर प्राप्त करता है, कॉलम नंबर और पंक्ति संख्या निर्दिष्ट करता है, पहले पहले सेल के लिए, फिर दूसरे सेल के लिए। कार्यक्रम को "हाँ" प्रिंट करना चाहिए यदि किश्ती की चाल के साथ पहली सेल से दूसरे स्थान पर जाना संभव है, या अन्यथा "नहीं"।

• 
  4 4
  5 5
  नहीं

• ) ; डाल() ; प्राप्त); प्राप्त करें (बी); डाल() ; प्राप्त करें (सी); डी मिलता है); अगर ए = सी या बी = डी तो रखो ("हाँ"); और रखो ("नहीं"); अगर अंत ; एंडमेन;

  Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य उपप्रकार है चेकबोर्ड पूर्णांक श्रेणी 1.8 है; ए, बी, सी, डी: चेकबोर्ड; start Put_Line ("दो कक्षों के लिए कॉलम और पंक्ति संख्या दर्ज करें:"); Put ("पहले सेल के लिए कॉलम और पंक्ति संख्या दर्ज करें और दबाएं:"); प्राप्त); प्राप्त करें (बी); Put ("दूसरी सेल के लिए कॉलम और पंक्ति संख्या दर्ज करें और दबाएं:"); प्राप्त करें (सी); डी मिलता है); अगर ए = सी या बी = डी तो रखो ("हाँ"); और रखो ("नहीं"); अगर अंत; एंडमेन;

शतरंज का राजा क्षैतिज, लंबवत और तिरछे चलता है, लेकिन केवल 1 वर्ग। शतरंज की बिसात पर दो अलग-अलग कोशिकाओं को देखते हुए, यह निर्धारित करें कि क्या राजा एक चाल में पहली सेल से दूसरी सेल में जा सकता है। प्रोग्राम इनपुट के रूप में 1 से 8 तक प्रत्येक के लिए चार नंबर प्राप्त करता है, कॉलम नंबर और पंक्ति संख्या निर्दिष्ट करता है, पहले पहले सेल के लिए, फिर दूसरे सेल के लिए। कार्यक्रम को "हाँ" प्रिंट करना चाहिए यदि राजा के कदम से पहले सेल से दूसरे तक पहुंचना संभव है, या अन्यथा "नहीं"।

• दो कक्षों के लिए स्तंभ और पंक्ति संख्या दर्ज करें:
  पहले सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 4 4
  दूसरे सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 5 5
  हां

• "दो कक्षों के लिए स्तंभ और पंक्ति संख्या दर्ज करें:") ; डाल( "पहले सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं:") ; प्राप्त); प्राप्त करें (बी); डाल( "दूसरे सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं:") ; प्राप्त करें (सी); डी मिलता है); अगर एब्स (ए - सी)<= 1 and then abs (B - D) <= 1 then - एब्स () कमांड एब्सोल्यूट लौटाता है -- संख्या का मान (मापांक)पुट ("हाँ"); और रखो ("नहीं"); अगर अंत ; मुख्य अंत;

  Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य उपप्रकार है चेकबोर्ड पूर्णांक श्रेणी 1.8 है; ए, बी, सी, डी: चेकबोर्ड; start Put_Line ("दो कक्षों के लिए कॉलम और पंक्ति संख्या दर्ज करें:"); Put ("पहले सेल के लिए कॉलम और पंक्ति संख्या दर्ज करें और दबाएं:"); प्राप्त); प्राप्त करें (बी); Put ("दूसरी सेल के लिए कॉलम और पंक्ति संख्या दर्ज करें और दबाएं:"); प्राप्त करें (सी); डी मिलता है); अगर पेट (ए - सी)<= 1 and then abs(B - D) <= 1 then -- команда abs() возвращает абсолютное --значение (модуль) числа Put("ДА"); else Put("НЕТ"); end if; end main;

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

• दो कक्षों के लिए स्तंभ और पंक्ति संख्या दर्ज करें:
  पहले सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 4 4
  दूसरे सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 5 5
  हां

• Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य उपप्रकार है चेकबोर्ड पूर्णांक श्रेणी 1 ..8 है; ए, बी, सी, डी: चेकबोर्ड; पुट_लाइन शुरू करें ( "दो कक्षों के लिए स्तंभ और पंक्ति संख्या दर्ज करें:") ; डाल( "पहले सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं:") ; प्राप्त); प्राप्त करें (बी); डाल( "दूसरे सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं:") ; प्राप्त करें (सी); डी मिलता है); अगर एब्स (ए - सी) = एब्स (बी - डी) तो पुट ("हां"); और रखो ("नहीं"); अगर अंत ; मुख्य अंत;

  Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य उपप्रकार है चेकबोर्ड पूर्णांक श्रेणी 1.8 है; ए, बी, सी, डी: चेकबोर्ड; start Put_Line ("दो कक्षों के लिए कॉलम और पंक्ति संख्या दर्ज करें:"); Put ("पहले सेल के लिए कॉलम और पंक्ति संख्या दर्ज करें और दबाएं:"); प्राप्त); प्राप्त करें (बी); Put ("दूसरी सेल के लिए कॉलम और पंक्ति संख्या दर्ज करें और दबाएं:"); प्राप्त करें (सी); डी मिलता है); अगर एब्स (ए - सी) = एब्स (बी - डी) तो पुट ("हाँ"); और रखो ("नहीं"); अगर अंत; मुख्य अंत;

शतरंज की रानी तिरछे, क्षैतिज या लंबवत चलती है। शतरंज की बिसात की दो अलग-अलग कोशिकाओं को देखते हुए, यह निर्धारित करें कि क्या रानी एक चाल में पहली सेल से दूसरी सेल में जा सकती है।

इनपुट डेटा प्रारूप:
प्रोग्राम इनपुट के रूप में 1 से 8 तक प्रत्येक के लिए चार नंबर प्राप्त करता है, कॉलम नंबर और पंक्ति संख्या निर्दिष्ट करता है, पहले पहले सेल के लिए, फिर दूसरे सेल के लिए।
आउटपुट स्वरूप:
कार्यक्रम को हाँ आउटपुट करना चाहिए यदि रानी की चाल से पहले सेल से दूसरे तक पहुंचना संभव है, या अन्यथा नहीं।

उदाहरण 1:
दो कक्षों के लिए स्तंभ और पंक्ति संख्या दर्ज करें:
पहले सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 1 1
दूसरे सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 2 2
हां

उदाहरण 2:
दो कक्षों के लिए स्तंभ और पंक्ति संख्या दर्ज करें:
पहले सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 1 1
दूसरे सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 2 3
नहीं

• Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य उपप्रकार है चेकबोर्ड पूर्णांक श्रेणी 1 ..8 है; ए, बी, सी, डी: चेकबोर्ड; पुट_लाइन शुरू करें ( "दो कक्षों के लिए स्तंभ और पंक्ति संख्या दर्ज करें:") ; डाल( "पहले सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं:") ; प्राप्त); प्राप्त करें (बी); डाल( "दूसरे सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं:") ; प्राप्त करें (सी); डी मिलता है); अगर एब्स (ए - सी) = एब्स (बी - डी) या ए = डी या बी = सी तो पुट ("हां"); और रखो ("नहीं"); अगर अंत ; एंडमेन;

  Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य उपप्रकार है चेकबोर्ड पूर्णांक श्रेणी 1.8 है; ए, बी, सी, डी: चेकबोर्ड; start Put_Line ("दो कक्षों के लिए कॉलम और पंक्ति संख्या दर्ज करें:"); Put ("पहले सेल के लिए कॉलम और पंक्ति संख्या दर्ज करें और दबाएं:"); प्राप्त); प्राप्त करें (बी); Put ("दूसरी सेल के लिए कॉलम और पंक्ति संख्या दर्ज करें और दबाएं:"); प्राप्त करें (सी); डी मिलता है); अगर एब्स (ए - सी) = एब्स (बी - डी) या ए = डी या बी = सी तो पुट ("हाँ"); और रखो ("नहीं"); अगर अंत; एंडमेन;

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

उदाहरण 1:
दो कक्षों के लिए स्तंभ और पंक्ति संख्या दर्ज करें:
पहले सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 1 1
दूसरे सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 1 4
नहीं

उदाहरण 2:
दो कक्षों के लिए स्तंभ और पंक्ति संख्या दर्ज करें:
पहले सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 1 1
दूसरे सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं: 8 8
नहीं

• Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; प्रक्रिया मुख्य उपप्रकार है चेकबोर्ड पूर्णांक श्रेणी 1 ..8 है; ए, बी, सी, डी: पूर्णांक; पुट_लाइन शुरू करें ( "दो कक्षों के लिए स्तंभ और पंक्ति संख्या दर्ज करें:") ; डाल( "पहले सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं:") ; प्राप्त); प्राप्त करें (बी); डाल( "दूसरे सेल के लिए कॉलम और रो नंबर दर्ज करें और दबाएं:") ; प्राप्त करें (सी); डी मिलता है); यदि एब्स (ए - सी) = 2 और फिर एब्स (बी - डी) = 1 तो पुट ("हाँ"); एल्सिफ एब्स (ए - सी) = 1 और फिर एब्स (बी - डी) = 2 फिर पुट ("हाँ"); और रखो ("नहीं"); अगर अंत ; मुख्य अंत;

  Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; प्रक्रिया मुख्य उपप्रकार है चेकबोर्ड पूर्णांक श्रेणी 1.8 है; ए, बी, सी, डी: पूर्णांक; start Put_Line ("दो कक्षों के लिए कॉलम और पंक्ति संख्या दर्ज करें:"); Put ("पहले सेल के लिए कॉलम और पंक्ति संख्या दर्ज करें और दबाएं:"); प्राप्त); प्राप्त करें (बी); Put ("दूसरी सेल के लिए कॉलम और पंक्ति संख्या दर्ज करें और दबाएं:"); प्राप्त करें (सी); डी मिलता है); अगर एब्स (ए - सी) = 2 और फिर एब्स (बी - डी) = 1 तो पुट ("हाँ"); एल्सिफ एब्स (ए - सी) = 1 और फिर एब्स (बी - डी) = 2 फिर पुट ("हाँ"); और रखो ("नहीं"); अगर अंत; मुख्य अंत;

चॉकलेट में N×M स्लाइस में विभाजित एक आयत का रूप होता है। चॉकलेट को एक बार सीधी रेखा में दो भागों में तोड़ा जा सकता है। निर्धारित करें कि क्या वास्तव में K स्लाइस को इस तरह से चॉकलेट बार से तोड़ा जा सकता है। कार्यक्रम को इनपुट के रूप में तीन नंबर प्राप्त होते हैं: एन, एम, के। कार्यक्रम को दो शब्दों में से एक का उत्पादन करना चाहिए: "हां" या "नहीं"।

उदाहरण 1:
4
2
6
हां

उदाहरण 2:
क्षैतिज रूप से स्लाइस की संख्या: 2
लंबवत स्लाइस की संख्या: 10
कितने टुकड़े अलग करने हैं: 7
नहीं

• Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; प्रक्रिया मुख्य है एन, एम, के: पूर्णांक; पुट शुरू करें ( "क्षैतिज रूप से स्लाइस की संख्या:") ; प्राप्त करें (एन); डाल( "लंबवत स्लाइस की संख्या:") ; प्राप्त करें (एम); डाल( "कितने स्लाइस अलग करने हैं:") ; प्राप्त करें (के); अगर के> एम * एन तो --यदि किसी चॉकलेट बार को चॉकलेट बार से अधिक तोड़ने के लिए कहा जाए तोडाल ("नहीं"); एल्सिफ के रेम एन = 0 और फिर के>= एन तो - क्षैतिज रूप से तोड़ेंपुट ("हाँ"); एल्सिफ के रेम एम = 0 और फिर के>= एम तो - लंबवत रूप से तोड़ेंपुट ("हाँ"); और रखो ("नहीं"); अगर अंत ; एंडमेन;

  Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; प्रक्रिया मुख्य है एन, एम, के: पूर्णांक; स्टार्ट पुट ("क्षैतिज रूप से स्लाइस की संख्या:"); प्राप्त करें (एन); पुट ("लंबवत स्लाइस की संख्या:"); प्राप्त करें (एम); पुट ("कितने स्लाइस अलग करने हैं:"); प्राप्त करें (के); यदि K > M * N तो -- यदि चॉकलेट बार को स्वयं चॉकलेट बार से अधिक तोड़ने के लिए कहा जाए तो Put("NO"); एल्सिफ के रेम एन = 0 और फिर के> = एन फिर - क्षैतिज रूप से तोड़ें ("हाँ"); एल्सिफ के रेम एम = 0 और फिर के> = एम फिर - लंबवत रूप से तोड़ें ("हाँ"); और रखो ("नहीं"); अगर अंत; एंडमेन;

यशा N × M मीटर के कुंड में तैर कर थक गई। इस बिंदु पर, उन्होंने खुद को एक लंबी सीढ़ी (जरूरी नहीं कि निकटतम एक) से X मीटर और एक छोटी सी सीढ़ी से Y मीटर की दूरी पर पाया। पूल से बाहर निकलने के लिए यशा को न्यूनतम कितनी दूरी पर तैरना चाहिए? प्रोग्राम को इनपुट के रूप में संख्या N, M, X, Y प्राप्त होती है। प्रोग्राम को उन मीटरों की संख्या का उत्पादन करना चाहिए जिन्हें यशा को किनारे पर तैरने की आवश्यकता है।

• पूल चौड़ाई: 23
  पूल की लंबाई: 52
  यशा से लंबी तरफ की दूरी: 8
  यशा से छोटी तरफ की दूरी: 43
  पूल से बाहर निकलने के लिए आपको कम से कम तैरने की जरूरत है: 8

यह संभव है कि समस्या को हल करने के लिए आपको 2 चरों को स्वैप करना होगा। यह एल्गोरिथ्म कुछ इस तरह दिखता है:

ए, बी, टीएमपी: पूर्णांक; - चर घोषित करना। दो मुख्य और एक सहायक a:= 3; --वैरिएबल का आरंभीकरण a b:= 5; --वैरिएबल b का आरंभीकरण --एल्गोरिदम ही: tmp:= a; --अब tmp = 3 और a = 3 a:= b; --अब a = 5 और b = 5; बी: = टीएमपी; --अब बी = 3

• Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; प्रक्रिया मुख्य है एन, एम, एक्स, वाई: पूर्णांक; - एन - छोटा किनारा, एम - लंबा किनारा: -- X - लंबी भुजाओं में से किसी एक से दूरी -- Y - छोटी भुजाओं में से एक से दूरीटीएमपी: पूर्णांक; पुट शुरू करें ( "पूल चौड़ाई:") ; प्राप्त करें (एन); डाल( "पूल की लंबाई:") ; प्राप्त करें (एम); डाल( "यशा से एक लंबी तरफ की दूरी:") ; प्राप्त करें (एक्स); डाल( "यशा से छोटी तरफ की दूरी:") ; प्राप्त करें (वाई); अगर एन> एम तो - यदि इनपुट के दौरान पक्षों को मिलाया जाता है, तो हम उनके स्थान बदलते हैं:टीएमपी: = एम; - लंबाई M को अस्थायी चर में सहेजेंएम: = एन; --वेरिएबल M को एक नया मान असाइन करेंएन: = टीएमपी; - लंबाई M को वेरिएबल N . में पुनर्स्थापित करेंअगर अंत ; टीएमपी: = एक्स; --मान लें कि न्यूनतम दूरी X . हैअगर पेट (एन-एक्स)< X then --यदि दूसरे लंबे किनारे की दूरी X से कम है, तोटीएमपी: = एन - एक्स; --न्यूनतम दूरीदूसरी लंबी भुजा की दूरी के बराबरअगर अंत ; अगर आप< Tmp then --यदि छोटे किनारे की दूरी ऊपर पाई गई दूरी से कम है -- न्यूनतम, तबटीएमपी: = वाई; --न्यूनतम दूरी Y . हैअगर अंत ; अगर एब्स (एम - वाई)< Tmp then --यदि आप दूसरी शॉर्ट साइड के करीब तैरते हैं, तोटीएमपी: = पेट (एम - वाई); --न्यूनतम दूरी दूसरे छोटे किनारे की दूरी के बराबर हैअगर अंत ; डाल( "आपको पूल से बाहर निकलने के लिए कम से कम तैरने की जरूरत है:") ; पुट (आइटम => टीएमपी, चौड़ाई => 1); एंडमेन;

  Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; प्रक्रिया मुख्य है एन, एम, एक्स, वाई: पूर्णांक; - एन - शॉर्ट लेज, एम - लॉन्ग लेज: - एक्स - लॉन्ग लेज में से एक से दूरी - वाई - शॉर्ट लेजेस में से एक से दूरी टीएमपी: इंटीजर; पुट शुरू करें ("पूल की चौड़ाई:"); प्राप्त करें (एन); पुट ("पूल की लंबाई:"); प्राप्त करें (एम); पुट ("यशा से लंबी तरफ की दूरी:"); प्राप्त करें (एक्स); पुट ("यशा से छोटे किनारे तक की दूरी:"); प्राप्त करें (वाई); यदि N > M तो -- यदि इनपुट के दौरान किनारों को मिलाया जाता है, तो हम उनके स्थान बदलते हैं: Tmp:= M; - लंबाई M को अस्थायी चर M:= N में सहेजें; --वेरिएबल M N:= Tmp के लिए एक नया मान असाइन करें; - लंबाई एम को वेरिएबल एन एंड में पुनर्स्थापित करें यदि; टीएमपी: = एक्स; - मान लें कि न्यूनतम दूरी X है यदि एब्स (N - X)< X then --Если до второго длинного бортика расстояние меньше X, то Tmp:= N - X; --минимальное расстояние равно расстоянию до второго длинного бортика end if; if Y < Tmp then --Если до короткого бортика расстояние меньше найденного выше --минимального, то Tmp:= Y; --Минимальное расстояние равно Y end if; if abs(M - Y) < Tmp then --Если до второго короткого бортика плыть ближе, то Tmp:= abs(M - Y); --минимальное расстояние равно расстоянию до второго короткого бортика end if; Put("Нужно проплыть минимум, чтобы выбраться из бассейна: "); Put(Item =>टीएमपी, चौड़ाई => 1); एंडमेन;

इलेक्ट्रॉनिक घड़ी h:mm:ss प्रारूप (0:00:00 से 23:59:59 तक) में समय दिखाती है, यानी पहले घंटों की संख्या दर्ज की जाती है, फिर मिनटों की दो अंकों की संख्या अनिवार्य है , तो सेकंड की दो अंकों की संख्या अनिवार्य है। मिनट और सेकंड की संख्या, यदि आवश्यक हो, तो के लिए गद्देदार हैं दो अंकों की संख्याशून्य दिन की शुरुआत के बाद से N सेकंड बीत चुके हैं। आउटपुट जो घड़ी दिखाता है। इनपुट एक प्राकृतिक संख्या N है, जो 10 7 (10000000) से अधिक नहीं है। समस्या का उत्तर आउटपुट करें।

इनपुट उदाहरण 1:
3602
आउटपुट उदाहरण 1:
1:00:02

इनपुट उदाहरण 2:
129700
आउटपुट उदाहरण 2:
12:01:40

• Ada.Long_Integer_Text_IO के साथ; Ada.Long_Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य उप प्रकार है Sub_LI Long_Integer श्रेणी 1 ..10000000 है; एन: सब_एलआई; एच, एम, एस: Long_Integer; शुरू हो जाओ (एन); एच: = एन / 3600; - हमें घड़ी मिलती है। विभाजन के शेष भाग को त्याग दिया जाता हैएन: = एन - एच * 3600; - शेष सेकंड प्राप्त करें (शून्य से घंटे)अगर एच> 24 तो --चूंकि घड़ी> 24 नहीं दिखा सकती है, हम सब कुछ एक पठनीय रूप में रखते हैंएच: = एच रेम 24; --24 से भाग देने पर शेष बचे हुए घंटों की सही संख्या देगाएल्सिफ एच = 24 फिर एच: = 0; अगर अंत ; एम: = एन / 60; --मिनट प्राप्त करेंएस: = एन रेम 60; --सेकंड प्राप्त करेंरखो (आइटम => एच, चौड़ाई => 1); डाल(":"); --आउटपुट घंटे और ":"अगर एम< 10 then --यदि मिनटों की संख्या 10 से कम है, तो एक अग्रणी 0 . आउटपुट करेंरखो (आइटम => 0, चौड़ाई => 1); अगर अंत ; रखो (आइटम => एम, चौड़ाई => 1); डाल(":"); --आउटपुट मिनट और ":"अगर हाँ< 10 then --यदि सेकंड की संख्या 10 से कम है, तो एक अग्रणी 0 . आउटपुट करेंरखो (आइटम => 0, चौड़ाई => 1); अगर अंत ; रखो (आइटम => एस, चौड़ाई => 1); --आउटपुट सेकंड्स एंड मेन;

  Ada.Long_Integer_Text_IO के साथ; Ada.Long_Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य उपप्रकार है Sub_LI Long_Integer रेंज 1..10000000 है; एन: सब_एलआई; एच, एम, एस: Long_Integer; शुरू हो जाओ (एन); एच: = एन / 3600; - हमें घड़ी मिलती है। विभाजन के शेष भाग को छोड़ दिया जाता है N:= N - h * 3600; -- शेष सेकंड (माइनस घंटे) प्राप्त करें यदि h > 24 तो --चूंकि घड़ियां > 24 नहीं पढ़ सकती हैं, सब कुछ मानव-पठनीय रूप में रखें h:= h रेम 24; -- 24 से भाग देने पर शेष घंटों की सटीक संख्या देगा elsif h = 24 फिर h:= 0; अगर अंत; एम: = एन / 60; --गेट मिनट एस:= एन रेम 60; - सेकंड प्राप्त करें (आइटम => एच, चौड़ाई => 1); डाल(":"); --आउटपुट घंटे और ":" अगर एम< 10 then --Если количество минут меньше 10, выводим ведущий 0 Put(Item =>0, चौड़ाई => 1); अगर अंत; रखो (आइटम => एम, चौड़ाई => 1); डाल(":"); --आउटपुट मिनट और ":" यदि< 10 then --Если количество секунд меньше 10, выводим ведущий 0 Put(Item =>0, चौड़ाई => 1); अगर अंत; रखो (आइटम => एस, चौड़ाई => 1); --आउटपुट सेकंड्स एंड मेन;

• तीन नंबर दिए गए हैं। उन्हें आरोही क्रम में व्यवस्थित करें।
• इनपुट उदाहरण:
  1 2 1
  नमूना आउटपुट:
  1 1 2

• Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य है ए, बी, सी: पूर्णांक; न्यूनतम, मध्य, अधिकतम: पूर्णांक; प्रारंभ प्राप्त करें (ए); प्राप्त करें (बी); प्राप्त करें (सी); --तलाश रहे हैं न्यूनतम मूल्य मिनट: = ए; अगर बी< min then min:= B; end if ; if C < min then min:= C; end if ; --तलाश रहे हैं अधिकतम मूल्य अधिकतम: = ए; यदि बी> अधिकतम तो अधिकतम: = बी; अगर अंत ; यदि सी> अधिकतम तो अधिकतम: = सी; अगर अंत ; --औसत मूल्य की तलाशमध्य: = ए; अगर बी> मिनट और बी< max then mid:= B; end if ; if C >मिनट और सी< max then mid:= C; end if ; Put(Item =>न्यूनतम, चौड़ाई => 1); लगाना(" "); रखो (आइटम => मध्य, चौड़ाई => 1); लगाना(" "); रखो (आइटम => अधिकतम, चौड़ाई => 1); एंडमेन;

  Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य है ए, बी, सी: पूर्णांक; न्यूनतम, मध्य, अधिकतम: पूर्णांक; शुरू हो जाओ (ए); प्राप्त करें (बी); प्राप्त करें (सी); --न्यूनतम मान की तलाश में:= ए; अगर बी< min then min:= B; end if; if C < min then min:= C; end if; --Ищем максимальное значение max:= A; if B >अधिकतम तो अधिकतम: = बी; अगर अंत; यदि सी> अधिकतम तो अधिकतम: = सी; अगर अंत; - औसत मूल्य मध्य की तलाश में: = ए; अगर बी> मिनट और बी< max then mid:= B; end if; if C >मिनट और सी< max then mid:= C; end if; Put(Item =>न्यूनतम, चौड़ाई => 1); लगाना(" "); पुट (आइटम => मध्य, चौड़ाई => 1); लगाना(" "); रखो (आइटम => अधिकतम, चौड़ाई => 1); एंडमेन;

दो बॉक्स हैं, पहला A1×B1×C1 है, दूसरा A2×B2×C2 है। निर्धारित करें कि क्या इनमें से एक बॉक्स को दूसरे के अंदर रखा जा सकता है, बशर्ते कि बॉक्स केवल किनारों के चारों ओर 90 डिग्री घुमाए जा सकें। प्रोग्राम इनपुट के रूप में नंबर A1, B1, C1, A2, B2, C2 प्राप्त करता है। कार्यक्रम को निम्नलिखित पंक्तियों में से एक का उत्पादन करना चाहिए:
- "बॉक्स बराबर हैं" यदि बॉक्स समान हैं,
- "पहला डिब्बा एक सेकंड से भी कम"यदि पहला डिब्बा दूसरे में रखा जा सकता है,
- "पहला डिब्बा एक सेकंड से अधिक"अगर दूसरा बॉक्स पहले वाले के अंदर रखा जा सकता है।

उदाहरण 1:
पहला बॉक्स आयाम: 1 2 3
दूसरा बॉक्स आयाम: 3 2 1
डिब्बे बराबर हैं

उदाहरण 2:
पहला बॉक्स आयाम: 2 2 3
दूसरा बॉक्स आयाम: 3 2 1
पहला डिब्बा दूसरे डिब्बे से बड़ा है

• Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य है A1, B1, C1, A2, B2, C2: पूर्णांक; न्यूनतम, अधिकतम, मध्य, tmp: पूर्णांक; प्रारंभ प्राप्त करें (ए 1); प्राप्त करें (बी 1); प्राप्त करें (सी 1); प्राप्त करें (ए 2); प्राप्त करें (बी 2); प्राप्त करें (सी 2); - चेहरों को लंबाई A1 => A2, B1 => B2, C1 => C2 के अनुरूप लाएं: --A1 और A2 सबसे लंबे हैं, C1 और C2 सबसे छोटे हैं - पहला बॉक्स "स्पिन" करें:न्यूनतम:=A1; मध्य:=B1; अधिकतम: = C1; अगर बी1< min then mid:= min; min:= B1; end if ; if C1 < min then max:= min; min:= C1; end if ; if mid >अधिकतम तो tmp:= मध्य; मध्य: = अधिकतम; अधिकतम: = टीएमपी; अगर अंत ; ए 1: = मिनट; बी1:=मध्य; सी 1: = अधिकतम; - दूसरा बॉक्स "स्पिन" करें:न्यूनतम:=ए2; मध्य:=बी2; अधिकतम: = C2; अगर B2< min then mid:= min; min:= B2; end if ; if C2 < min then max:= min; min:= C2; end if ; if mid >अधिकतम तो tmp:= मध्य; मध्य: = अधिकतम; अधिकतम: = टीएमपी; अगर अंत ; ए 2: = मिनट; बी 2: = मध्य; सी 2: = अधिकतम; - बक्सों के पत्राचार की जाँच करना और परिणाम प्रदर्शित करना:अगर A1 = A2 और फिर B1 = B2 और फिर C1 = C2 तो Put_Line ("बॉक्स बराबर हैं"); elsif A1 >= A2 और फिर B1 >= B2 और फिर C1 >= C2 फिर Put_Line( "पहला बॉक्स दूसरे से बड़ा है") ; एल्सिफ ए1<= A2 and then B1 <= B2 and then C1 <= C2 then Put_Line("पहला बॉक्स दूसरे से छोटा है") ; अगर अंत ; मुख्य अंत;

  Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य है A1, B1, C1, A2, B2, C2: पूर्णांक; न्यूनतम, अधिकतम, मध्य, tmp: पूर्णांक; प्रारंभ प्राप्त करें (ए 1); प्राप्त करें (बी 1); प्राप्त करें (सी 1); प्राप्त करें (ए 2); प्राप्त करें (बी 2); प्राप्त करें (सी 2); - किनारों को लंबाई A1 => A2, B1 => B2, C1 => C2: --A1 और A2 - सबसे लंबी, C1 और C2 - सबसे छोटी लंबाई के अनुरूप लाएं - पहला बॉक्स "ट्विस्ट" करें: मिनट := ए1 ; मध्य:=B1; अधिकतम: = C1; अगर बी1< min then mid:= min; min:= B1; end if; if C1 < min then max:= min; min:= C1; end if; if mid >अधिकतम तो tmp:= मध्य; मध्य: = अधिकतम; अधिकतम: = टीएमपी; अगर अंत; ए 1: = मिनट; बी1:=मध्य; सी 1: = अधिकतम; -- दूसरा बॉक्स "स्पिन" करें: मिनट:= A2; मध्य:=बी2; अधिकतम: = C2; अगर B2< min then mid:= min; min:= B2; end if; if C2 < min then max:= min; min:= C2; end if; if mid >अधिकतम तो tmp:= मध्य; मध्य: = अधिकतम; अधिकतम: = टीएमपी; अगर अंत; ए 2: = मिनट; बी 2: = मध्य; सी 2: = अधिकतम; - जांचें कि क्या बॉक्स मेल खाते हैं और परिणाम आउटपुट करते हैं: यदि A1 = A2 और फिर B1 = B2 और फिर C1 = C2 तो Put_Line ("बॉक्स बराबर हैं"); elsif A1 >= A2 और फिर B1 >= B2 और फिर C1 >= C2 फिर Put_Line ("पहला बॉक्स दूसरे से बड़ा है"); एल्सिफ ए1<= A2 and then B1 <= B2 and then C1 <= C2 then Put_Line("Первая коробка меньше второй"); end if; end main;

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

• एक टेलीफोन वार्तालाप की लागत की गणना करें।
  प्रारंभिक डेटा दर्ज करें:
  शहर कोड -> 423
  अवधि (पूर्णांक मिनट) -> 3
  व्लादिवोस्तोक शहर
  प्रति मिनट मूल्य: 4 रूबल।
  कॉल की लागत: 12 रूबल।

• Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य हैकोड, लेन: पूर्णांक; शुरू करना Put_Line ("एक टेलीफोन वार्तालाप की लागत की गणना।") ; Put_Line ("प्रारंभिक डेटा दर्ज करें:") ; डाल ("नगर कोड ->") ; पाना (कोड ) ; डाल ("अवधि (पूर्णांक मिनट) ->") ; पाना (लेन ) ; मामलाकोड है जब 423 => Put_Line ("व्लादिवोस्तोक शहर") ; Put_Line ("एक मिनट की कीमत: 4 रूबल।") ; डाल ("कॉल लागत:") ; डाल (आइटम => लेन * 4 , चौड़ाई => 1 ) ; Put_Line (" रगड़ना।") ; जब 095 => Put_Line ("मास्को शहर") ; Put_Line ("एक मिनट की कीमत: 2 रूबल।") ; डाल ("कॉल लागत:") ; डाल (आइटम => लेन * 2 , चौड़ाई => 1 ) ; Put_Line (" रगड़ना।") ; जब 815 => Put_Line ("शहर: मरमंस्क") ; Put_Line ("एक मिनट की कीमत: 3 रूबल।") ; डाल ("कॉल लागत:") ; डाल (आइटम => लेन * 3 , चौड़ाई => 1 ) ; Put_Line (" रगड़ना।") ; जब 846 => Put_Line ("समारा शहर") ; Put_Line ("एक मिनट की कीमत: 1 रगड़।") ; डाल ("कॉल लागत:") ; डाल (मद => लेन, चौड़ाई => 1 ) ; Put_Line (" रगड़ना।") ; जब अन्य=> पुट ("डेटाबेस में इस कोड वाला कोई शहर नहीं है! पुनः प्रयास करें।") ; अंत मामला; अंतमुख्य;

  Ada.Integer_Text_IO के साथ; Ada.Integer_Text_IO का उपयोग करें; Ada.Text_IO के साथ; Ada.Text_IO का उपयोग करें; प्रक्रिया मुख्य कोड है, लेन: पूर्णांक; पुट_लाइन शुरू करें ("एक फोन कॉल की लागत की गणना।"); Put_Line ("प्रारंभिक डेटा दर्ज करें:"); पुट ("सिटी कोड ->"); कोड प्राप्त करें); पुट ("अवधि (पूर्णांक मिनट) ->"); प्राप्त करें (लेन); केस कोड तब होता है जब 423 => Put_Line ("शहर: व्लादिवोस्तोक"); Put_Line ("मूल्य प्रति मिनट: 4 रूबल।"); पुट ("कॉल लागत:"); पुट (आइटम => लेन * 4, चौड़ाई => 1); Put_Line ("रगड़।"); जब 095 => Put_Line ("शहर: मास्को"); Put_Line ("मूल्य प्रति मिनट: 2 रूबल।"); पुट ("कॉल लागत:"); पुट (आइटम => लेन * 2, चौड़ाई => 1); Put_Line ("रगड़।"); जब 815 => Put_Line ("शहर: मरमंस्क"); Put_Line ("मूल्य प्रति मिनट: 3 रूबल।"); पुट ("कॉल लागत:"); पुट (आइटम => लेन * 3, चौड़ाई => 1); Put_Line ("रगड़।"); जब 846 => Put_Line ("शहर: समारा"); Put_Line ("प्रति मिनट मूल्य: 1 रगड़।"); पुट ("कॉल लागत:"); पुट (आइटम => लेन, चौड़ाई => 1); Put_Line ("रगड़।"); जब अन्य => रखो ("डेटाबेस में इस कोड के साथ कोई शहर नहीं है! पुनः प्रयास करें।"); अंतिम मामला; एंडमेन;

अनुभाग संक्षेप में ऑपरेटरों का वर्णन करता है अगरऔर मामला, समारोह पेट ()और चर की अदला-बदली के लिए एक एल्गोरिथ्म।

परिभाषा.

यह एक षट्भुज है जिसके आधार दो हैं बराबर वर्ग, और पार्श्व फलक समान आयत हैं

साइड रिब- यह सामान्य पक्षदो आसन्न पक्ष फलक

प्रिज्म ऊँचाई- यह एक कट है आधारों के लंबवतप्रिज्म

प्रिज्म विकर्ण- आधारों के दो शीर्षों को जोड़ने वाला एक खंड जो एक ही फलक से संबंधित नहीं है

विकर्ण विमानवह तल है जो प्रिज्म के विकर्ण से होकर गुजरता है और उसका पार्श्व पसलियां

विकर्ण खंड - प्रिज्म और विकर्ण तल के प्रतिच्छेदन की सीमाएं। एक नियमित चतुर्भुज प्रिज्म का विकर्ण खंड एक आयत है

लंबवत खंड (ऑर्थोगोनल सेक्शन)- यह एक प्रिज्म का प्रतिच्छेदन है और इसके किनारे के किनारों पर लंबवत खींचा गया एक विमान है

एक नियमित चतुर्भुज प्रिज्म के तत्व

यह आंकड़ा दो नियमित चतुर्भुज प्रिज्म दिखाता है, जो संबंधित अक्षरों से चिह्नित होते हैं:

• आधार एबीसीडी और ए 1 बी 1 सी 1 डी 1 एक दूसरे के बराबर और समानांतर हैं
• साइड फेसएए 1 डी 1 डी, एए 1 बी 1 बी, बीबी 1 सी 1 सी और सीसी 1 डी 1 डी, जिनमें से प्रत्येक एक आयत है
• पार्श्व सतह- प्रिज्म के सभी पक्षों के क्षेत्रों का योग
• कुल सतह - सभी आधारों और पार्श्व फलकों के क्षेत्रफलों का योग (पक्ष की सतह और आधारों के क्षेत्रफल का योग)
• साइड रिब्स एए 1, बीबी 1, सीसी 1 और डीडी 1।
• विकर्ण बी 1 डी
• आधार विकर्ण BD
• विकर्ण खंड बी बी 1 डी 1 डी
• लंबवत खंड ए 2 बी 2 सी 2 डी 2।

एक नियमित चतुष्कोणीय प्रिज्म के गुण

• आधार दो बराबर वर्ग हैं
• आधार एक दूसरे के समानांतर हैं
• भुजाएँ आयताकार हैं।
• पार्श्व फलक एक दूसरे के बराबर हैं
• पार्श्व फलक आधारों के लंबवत होते हैं
• पार्श्व पसलियां एक दूसरे के समानांतर और बराबर होती हैं
• लंबवत खंड सभी तरफ की पसलियों के लंबवत और आधारों के समानांतर
• कोने लंबवत खंड- सीधा
• एक नियमित चतुर्भुज प्रिज्म का विकर्ण खंड एक आयत है
• लंबवत (ऑर्थोगोनल सेक्शन) आधारों के समानांतर

एक नियमित चतुष्कोणीय प्रिज्म के लिए सूत्र

समस्याओं के समाधान के निर्देश

विषय पर समस्याओं को हल करते समय " सही चतुष्कोणीय प्रिज्म " इसका आशय है:

सही प्रिज्म- एक प्रिज्म जिसके आधार पर स्थित है नियमित बहुभुज, और पार्श्व किनारे आधार तलों के लंबवत हैं। अर्थात्, एक नियमित चतुष्कोणीय प्रिज्म इसके आधार पर होता है वर्ग. (एक नियमित चतुष्कोणीय प्रिज्म के गुणों के ऊपर देखें) टिप्पणी. यह ज्यामिति (सेक्शन सॉलिड ज्योमेट्री - प्रिज्म) में कार्यों के साथ पाठ का हिस्सा है। यहां ऐसे कार्य हैं जो हल करने में कठिनाइयों का कारण बनते हैं। यदि आपको ज्यामिति में कोई समस्या हल करने की आवश्यकता है, जो यहाँ नहीं है - इसके बारे में फोरम में लिखें. निकालने की क्रिया को इंगित करने के लिए वर्गमूलसमस्या समाधान में प्रतीक का प्रयोग किया जाता है√ .

काम।

एक नियमित चतुष्कोणीय प्रिज्म में, आधार क्षेत्र 144 सेमी 2 है और ऊंचाई 14 सेमी है। प्रिज्म का विकर्ण और क्षेत्रफल ज्ञात कीजिए पूरी सतह.

फेसला.
एक नियमित चतुर्भुज एक वर्ग है।
तदनुसार, आधार की भुजा बराबर होगी

√144 = 12 सेमी.
आधार का विकर्ण कहाँ से आता है? आयताकार आयताके बराबर होगा
√(12 2 + 12 2 ) = √288 = 12√2

विकर्ण दायां प्रिज्मआधार के विकर्ण और प्रिज्म की ऊंचाई के साथ बनता है सही त्रिकोण. तदनुसार, पाइथागोरस प्रमेय के अनुसार, किसी दिए गए नियमित चतुष्कोणीय प्रिज्म का विकर्ण बराबर होगा:
((12√2) 2 + 14 2 ) = 22 सेमी

जवाब: 22 सेमी

काम

एक नियमित चतुष्कोणीय प्रिज्म का कुल क्षेत्रफल ज्ञात कीजिए यदि इसका विकर्ण 5 सेमी है और पार्श्व फलक का विकर्ण 4 सेमी है।

फेसला.
चूँकि एक नियमित चतुष्कोणीय प्रिज्म का आधार एक वर्ग है, तो पाइथागोरस प्रमेय द्वारा आधार की भुजा (a के रूप में निरूपित) पाई जाती है:

ए 2 + ए 2 = 5 2
2ए 2 = 25
ए = √12.5

पार्श्व फलक की ऊंचाई (एच के रूप में निरूपित) तब इसके बराबर होगी:

एच 2 + 12.5 \u003d 4 2
एच 2 + 12.5 = 16
ज 2 \u003d 3.5
एच = √3.5

कुल सतह क्षेत्र पार्श्व सतह क्षेत्र के योग के बराबर होगा और आधार क्षेत्र का दोगुना होगा

एस = 2a 2 + 4ah
एस = 25 + 4√12.5 * √3.5
एस = 25 + 4√43.75
एस = 25 + 4√ (175/4)
एस = 25 + 4√ (7*25/4)
एस \u003d 25 + 10√7 51.46 सेमी 2.

उत्तर: 25 + 10√7 51.46 सेमी 2.

मैनुअल ट्रांसमिशन वाली कारें, जिन्हें मैनुअल ट्रांसमिशन के रूप में संक्षिप्त किया जाता है, हाल ही में जब तक की राशि पूर्ण बहुमतअन्य वाहनों के बीच अलग-अलग .

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

इस लेख में पढ़ें

मैनुअल ट्रांसमिशन आरेख और विशेषताएं

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

हम और आगे बढ़ते हैं। "मैकेनिक्स" बॉक्स को स्टेप किया जाता है, यानी चरणों में टॉर्क बदल जाता है। कई मोटर चालक जानते हैं कि गियरबॉक्स में वास्तव में गियर और शाफ्ट होते हैं, लेकिन हर कोई यह नहीं समझता है कि इकाई कैसे काम करती है।

तो, एक चरण (यह एक संचरण भी है) एक दूसरे के साथ बातचीत करने वाले गियर (ड्राइविंग और संचालित गियर) की एक जोड़ी है। ऐसा प्रत्येक चरण एक या दूसरे कोणीय वेग के साथ रोटेशन प्रदान करता है, अर्थात इसका अपना गियर अनुपात होता है।

गियर अनुपात के तहत चालित गियर के दांतों की संख्या और ड्राइव गियर पर दांतों की संख्या के अनुपात के रूप में समझा जाना चाहिए। इस मामले में, बॉक्स के विभिन्न चरणों में अलग-अलग गियर अनुपात प्राप्त होते हैं। सबसे कम गियर (लो गियर) में सबसे बड़ा गियर अनुपात होता है, और सबसे अधिक ऊंचा कदम(अपशिफ्ट) में सबसे छोटा गियर अनुपात होता है।

यह स्पष्ट हो जाता है कि चरणों की संख्या एक विशेष बॉक्स (चार-स्पीड गियरबॉक्स, पांच-स्पीड, आदि) पर पहले 4-स्पीड पर गियर की संख्या के बराबर होती है। यांत्रिक बक्सेगियर धीरे-धीरे पृष्ठभूमि में फीका पड़ गया।

मैनुअल ट्रांसमिशन डिवाइस

इसलिए, हालांकि कुछ विशेषताओं के साथ ऐसे बॉक्स के कई डिज़ाइन हो सकते हैं, हालांकि, आरंभिक चरणदो मुख्य प्रकारों को प्रतिष्ठित किया जा सकता है:

• तीन-शाफ्ट गियरबॉक्स;
• दो-शाफ्ट बक्से;

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

आइए तीन-शाफ्ट मैकेनिकल बॉक्स से शुरू करें। इस बॉक्स में शामिल हैं:

• ड्राइव शाफ्ट, जिसे प्राथमिक भी कहा जाता है;
• मध्यवर्ती शाफ्ट गियरबॉक्स;
• संचालित शाफ्ट (माध्यमिक);

सिंक्रोनाइज़र वाले गियर शाफ्ट पर स्थापित होते हैं। गियरबॉक्स में गियरशिफ्ट मैकेनिज्म भी शामिल है। निर्दिष्ट घटक तत्वगियरबॉक्स हाउसिंग में स्थित है, जिसे गियरबॉक्स हाउसिंग भी कहा जाता है।

ड्राइव शाफ्ट का कार्य क्लच के साथ संबंध बनाना है। ड्राइव शाफ्ट में क्लच डिस्क के लिए स्लॉट हैं। टॉर्क के लिए, इनपुट शाफ्ट से निर्दिष्ट टॉर्क गियर के माध्यम से प्रेषित होता है, जो इसके साथ कठोर जुड़ाव में होता है।

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

इस तरह के इंस्टॉलेशन को ड्राइव शाफ्ट पर एंड बेयरिंग का उपयोग करके लागू किया जाता है। इस असर में संचालित शाफ्ट शामिल है। चालित शाफ्ट पर गियर (गियर ब्लॉक) के समूह में शाफ्ट के साथ एक कठोर जुड़ाव नहीं होता है और इसलिए इस पर स्वतंत्र रूप से घूमता है। इस मामले में, मध्यवर्ती शाफ्ट के गियर का समूह, संचालित शाफ्ट और ड्राइव शाफ्ट के गियर निरंतर जुड़ाव में हैं।

चालित शाफ्ट के गियर के बीच सिंक्रोनाइज़र (सिंक्रोनाइज़र कपलिंग) स्थापित किए जाते हैं। उनका कार्य संचालित शाफ्ट के गियर के कोणीय वेग को घर्षण बल के माध्यम से शाफ्ट के कोणीय वेग के साथ संरेखित करना है।

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

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

बॉक्स बॉडी (क्रैंककेस) एल्यूमीनियम या मैग्नीशियम मिश्र धातुओं से बना है, यह गियर और तंत्र के साथ-साथ कई अन्य भागों के साथ शाफ्ट स्थापित करने के लिए आवश्यक है। गियरबॉक्स हाउसिंग में गियर ऑयल (गियरबॉक्स ऑयल) भी है।

• यह समझने के लिए कि थ्री-शाफ्ट टाइप मैकेनिकल (मैनुअल) गियरबॉक्स कैसे काम करता है, आइए आम तोर पेआइए देखें कि यह कैसे काम करता है। जब गियरशिफ्ट लीवर तटस्थ स्थिति में होता है, तो इंजन से वाहन के ड्राइव पहियों तक टॉर्क का संचरण नहीं होता है।

चालक द्वारा लीवर को हिलाने के बाद, कांटा एक या दूसरे गियर के सिंक्रोनाइज़र क्लच को स्थानांतरित कर देगा। सिंक्रोनाइज़र तब संरेखित होगा कोणीय वेगवांछित गियर और संचालित शाफ्ट। फिर क्लच का गियर रिंग एक समान गियर रिंग के साथ संलग्न होगा, जो यह सुनिश्चित करेगा कि गियर संचालित शाफ्ट पर बंद है।

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

दो-शाफ्ट मैनुअल गियरबॉक्स: डिवाइस और ऑपरेशन का सिद्धांत

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

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

इसके अलावा, मुख्य गियर का ड्राइव गियर चालित शाफ्ट पर सख्ती से तय होता है, और सिंक्रोनाइज़र कपलिंग स्वयं संचालित शाफ्ट के गियर के बीच स्थित होते हैं। हम जोड़ते हैं, गियरबॉक्स के आकार को कम करने के साथ-साथ गियर की संख्या में वृद्धि करने के लिए, आधुनिक गियरबॉक्स में, एक संचालित शाफ्ट के बजाय अक्सर 2 या 3 शाफ्ट स्थापित किए जा सकते हैं।

ऐसे प्रत्येक शाफ्ट पर, मुख्य गियर का गियर सख्ती से तय होता है, जबकि इस तरह के गियर में संचालित गियर के साथ एक कठोर जुड़ाव होता है। यह पता चला है कि डिजाइन वास्तव में 3 मुख्य गियर लागू करता है।

मुख्य गियर ही, साथ ही गियरबॉक्स डिवाइस में अंतर, सेकेंडरी शाफ्ट से ड्राइव व्हील्स तक टॉर्क पहुंचाता है। इस मामले में, अंतर पहियों के इस तरह के रोटेशन को भी प्रदान कर सकता है जब ड्राइव के पहिये अलग-अलग कोणीय गति से घूमते हैं।

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

2-शाफ्ट बॉक्स के शिफ्ट मैकेनिज्म में एक लीवर होता है, जो केबल द्वारा चयनकर्ता लीवर और गियर शिफ्ट लीवर से जुड़ा होता है। ये लीवर सेंट्रल शिफ्ट रॉड से जुड़े होते हैं, जिसमें कांटे भी होते हैं।

• अगर हम दो-शाफ्ट मैनुअल गियरबॉक्स के संचालन के सिद्धांत के बारे में बात करते हैं, तो यह तीन-शाफ्ट गियरबॉक्स के सिद्धांत के समान है। अंतर यह है कि गियरशिफ्ट तंत्र कैसे काम करता है। संक्षेप में, लीवर कार की धुरी के सापेक्ष अनुदैर्ध्य और अनुप्रस्थ दोनों आंदोलनों को अंजाम दे सकता है। दौरान अनुप्रस्थ आंदोलनगियर चयन तब होता है, जब बल गियर चयनकर्ता केबल पर लगाया जाता है, जो गियर चयनकर्ता लीवर पर कार्य करता है।

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

अंत में, हम ध्यान दें कि यांत्रिक बक्से भी अलग - अलग प्रकारअतिरिक्त अवरोधक उपकरण हैं जो एक ही समय में दो गियर को शामिल करने या गियर के अप्रत्याशित विघटन को रोकते हैं।

यह भी पढ़ें

इंजन शुरू करने से पहले क्लच को दबाना: क्लच को कब दबाना है और किन मामलों में ऐसा करने की अनुशंसा नहीं की जाती है। सहायक संकेतऔर सिफारिशें।

चलने वाले इंजन पर मुश्किल गियर शिफ्टिंग के कारण। ट्रांसमिशन ऑयल और गियरबॉक्स में लेवल, सिंक्रोनाइजर्स और गियरबॉक्स गियर्स, क्लच पहनना।