Course All lectures for HI purposes - Lecture: लॉजिकल ऑपरेटर्स

"नमस्कार, अमीगो! मैं तार्किक समस्याओं को हल करने से इतना दूर चला गया था कि मैंने ध्यान नहीं दिया कि आप अंदर आ गए हैं। यहां आपके लिए एक है: यदि मगरमच्छ उड़ते हैं, तो बर्फ सफेद होती है। एक उड़ने वाला मगरमच्छ है। निष्कर्ष क्या है?"

"उम ... तो हम निष्कर्ष निकालते हैं कि बर्फ सफेद है?"

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

"बूलियन तर्क? मुझे हाल ही में बूलियन प्रकार के बारे में बताया गया था..."

"हाँ, यहाँ एक सीधा संबंध है। बूलियन भाव केवल सत्य या असत्य हो सकते हैं। और जैसा कि होता है, इस प्रकार का तर्क उन भावों के बारे में है जो सत्य या असत्य हैं, और ऐसे भावों का संयोजन है। उदाहरण के लिए, व्यंजक 18 < 25 हमेशा सत्य होता है, और 7 <5 हमेशा गलत होता है। अभिव्यक्ति (i <10) i के मान पर निर्भर करती है। और यदि अभिव्यक्ति मूल्यांकन करती है, उदाहरण के लिए, सत्य के लिए, तो हम कार्यक्रम को कुछ करने के लिए कह सकते हैं। "

"आह, मैं समझ गया। बूलियन भाव हमें न केवल तार्किक निष्कर्ष निकालने की अनुमति देते हैं, बल्कि कार्यक्रमों में कांटे भी बनाते हैं।"

"बिल्कुल सही। मुख्य बात यह सीखना है कि उन्हें कैसे लिखना है। उदाहरण के लिए, जावा में आप केवल जाकर एक्सप्रेशन नहीं लिख सकते। 18 < age <65यह वाक्य-विन्यास गलत होगा और प्रोग्राम संकलित नहीं होगा।

"लेकिन आप इसे इस तरह लिख सकते हैं:

(18 < age) AND (age < 65)

बेशक, हम वास्तव में अंग्रेजी शब्द का प्रयोग नहीं करते हैं AND। इसके बजाय, आपको बूलियन ऑपरेटर की आवश्यकता है । यानी 'AND' को अलग तरह से दर्शाया जाता है।

"जावा में तीन तार्किक ऑपरेटर हैं: AND(&&), OR(||), NOT(!)।

अच्छी खबर यह है कि आप किसी भी जटिलता के तार्किक भावों के निर्माण के लिए कोष्ठकों का उपयोग कर सकते हैं।

बुरी खबर यह है कि जावा डेवलपर्स ने शब्दों के बजाय सी भाषाand से नोटेशन का उपयोग करने का फैसला किया , orऔर not।

आवरण पर देखें:

तार्किक संचालिका	अपेक्षा	असलियत
`AND` (∧)	`and`	`&&`
`OR` (∨)	`or`	`\|\|`
`NOT` (¬)	`not`	`!`

"यह वास्तव में उतना बुरा नहीं है... बहुत कॉम्पैक्ट है। मैंने उन्हें लगभग याद कर लिया है।"

"ठीक है, यह अद्भुत है। जावा में तार्किक ऑपरेटरों का उपयोग करने के कुछ उदाहरण यहां दिए गए हैं:

अभिव्यक्ति	व्याख्या	व्याख्या
`(0 < a) && (a < 100)`	`(0 < a) and (a < 100)`	`(0 < a) AND (a < 100)`
`(!a) && (!b)`	`(not a) and (not b)`	`(NOT a) AND (NOT b)`
`!(!a \|\| !b)`	`not((not a) or (not b))`	`NOT((NOT a) OR (NOT b))`

तुलना ऑपरेटरों और बूलियन चर का उपयोग करने के उदाहरण

"याद रखें, अमीगो, जहाँ भी आप एक तार्किक अभिव्यक्ति लिख सकते हैं, आप एक तार्किक चर लिख सकते हैं।"

"यह कैसा रहा?"

"मेरा मतलब है कि आप तार्किक अभिव्यक्ति को विभिन्न तरीकों से लिख सकते हैं। उदाहरण के लिए:

कोड	व्याख्या
`int age = 35; if (age >= 18 && age <= 65) System.out.println("You can work");`	यदि आयु का मान `18`और के बीच है `65`, तो वाक्यांश "आप काम कर सकते हैं" प्रदर्शित होता है।
`int age = 35; boolean isYoung = (age < 18); if (!isYoung && age <= 65) System.out.println("You can work");`	हमने एक `isYoung`चर बनाया और अभिव्यक्ति के पहले भाग को उसमें स्थानांतरित कर दिया। हमने बस `age >= 18`से बदल दिया `age < 18`।
`int age = 35; boolean isYoung = (age < 18); boolean isOld = (age > 65); if (!isYoung && !isOld) System.out.println("You can work");`	हमने एक पुराना चर बनाया और अभिव्यक्ति के दूसरे भाग को इसमें स्थानांतरित कर दिया। इसके अतिरिक्त `age <= 65`द्वारा प्रतिस्थापित किया गया था `age > 65`।

"ये तीन उदाहरण समतुल्य हैं। केवल दूसरे उदाहरण में हमने अभिव्यक्ति के भाग को ifकथन से एक अलग बूलियन चर ( isYoung) में स्थानांतरित किया। तीसरे उदाहरण में, हमने अभिव्यक्ति के दूसरे भाग को दूसरे चर ( isOld) में स्थानांतरित किया। वैसे, बूलियन चर का डिफ़ॉल्ट मान है false।"

"मुझे वह याद रहेगा। मुझे उम्मीद है।"

तार्किक अंकगणित

"अब आइए संक्षेप में तार्किक संक्रियाओं से गुजरते हैं। वे बहुत ही सरल और तार्किक (यह अन्यथा कैसे हो सकता है!) नियमों का पालन करते हैं।

"पहले, देखते हैं कि ORऑपरेटर कैसे काम करता है। इसे ||or disjunction के रूप में भी जाना जाता है ।

अभिव्यक्ति	परिणाम
`true \|\| true`	`true`
`true \|\| false`	`true`
`false \|\| true`	`true`
`false \|\| false`	`false`

a || b"क्या अब आप यह निष्कर्ष निकाल सकते हैं कि तालिका के आधार पर व्यंजक का परिणाम क्या है?"

"अच्छा ऐसा है!" किसी व्यंजक का मान तब होता है trueजब व्यंजक में कम से कम एक पद हो true। यदि दोनों हैं false, तो परिणाम है false।

"यह सही है। चूँकि आप इतने स्मार्ट हैं, तालिका पर एक और नज़र डालें और कल्पना करें कि यह false0 है और true1 है। जब आप इसे इस तरह देखते हैं, तो क्या ||ऑपरेटर का व्यवहार आपको सामान्य अंकगणित से कुछ भी याद दिलाता है?"

"उम... ठीक है, यह कुछ जोड़ जैसा है... लेकिन जब आप जोड़ करते हैं, 1 + 1 1 के बराबर नहीं होता है।"

||"एक अर्थ है जिसमें यह बराबर है अगर हम केवल 0 और 1 के साथ काम कर रहे हैं। लेकिन अभी इससे परेशान न हों। महत्वपूर्ण बात यह है कि आपने ऑपरेशन और जोड़ के बीच समानता पर ध्यान दिया। इसका मतलब है कि आप जीत गए'' इस तथ्य से आश्चर्य नहीं होना चाहिए कि इस संक्रिया को अक्सर 'तार्किक जोड़' कहा जाता है।

"समझ गया।"

"अब AND, उर्फ &&, उर्फ संयोजन संचालिका, मंच पर आती है।

अभिव्यक्ति	परिणाम
`true && true`	`true`
`true && false`	`false`
`false && true`	`false`
`false && false`	`false`

"जैसा कि मैं इसे समझता हूं, अभिव्यक्ति का नतीजा trueकेवल तभी होता है जब अभिव्यक्ति बनाने वाले दोनों मूल्य होते हैं true। अन्यथा, यह हमेशा होता है false।"

"शाबाश, अमीगो! तुम स्पंज की तरह यह सब सोख रही हो। क्या तुम अंकगणित में एक और समानता देखते हो?"

"गुणन!"

"बिल्कुल सही। तो यहाँ हमारे पास एक 'तार्किक गुणन' है।"

"आगे हम NOTसंकारक को देखते हैं, उर्फ !, उर्फ तार्किक व्युत्क्रम ।

अभिव्यक्ति	परिणाम
`!true`	`false`
`!false`	`true`

"ठीक है, यहाँ सब कुछ काफी सरल है। ऑपरेटर बदल जाता है trueऔर falseइसके विपरीत।"

"बिल्कुल सही। यहाँ आपके लिए कुछ उपयोगी अभिव्यक्तियाँ हैं:"

अभिव्यक्ति	परिणाम
`m && !m`	`false`
`m \|\| !m`	`true`
`!(a && b)`	`!a \|\| !b`
`!(a \|\| b)`	`!a && !b`