प्राकृतिक भाषा से C ++ अभिव्यक्ति तक

Question

नियत कार्य:

निम्नलिखित प्राकृतिक भाषा के भावों को C ++ अभिव्यक्तियों में अनुवादित करें। मान लें कि सभी चर गैर-ऋणात्मक संख्याएं या बूलियन हैं (मूल्य के सही या गलत होने पर)।

प्राकृतिक भाषा:

या तो ए और बी दोनों झूठे हैं या सी सच है, लेकिन दोनों नहीं।

मेरा समाधान:

(a==0 && b==0)xor(c==1)

प्रोफेसरों का समाधान:

(!a && !b) != c

प्रशन:

1. मुझे लगता है कि मैं "नहीं-ए" और "नहीं-बी" कहकर पहले ब्रैकेट को थोड़ा समझता हूं, मुझे लगता है कि ए और बी को गलत होना चाहिए, बशर्ते शुरुआत में गैर-शून्य माना जाता है। सही?

2. लेकिन उस हिस्से के बारे में जो "सी के लिए असमान" कहता है?

3. मुझे प्रोफेसरों के समाधान की समझ नहीं है, क्या कोई मेरे लिए इसे तोड़ सकता है?

सहायता के लिए धनयवाद!

Comments

सामान्य तौर पर मैं बोली जाने वाली भाषा बूलियन अभिव्यक्तियों को कोड में अनुवाद करने से सावधान रहूंगा। एक सामान्य गलती a == b or cइसके बजाय "ए बराबर बी या सी" का अनुवाद करना है a == b or a ==c। समस्या यह है कि बोला जाने वाला

— लानेज अभेद्य है

Answer 1

मुझे लगता है कि होगा a, bऔर cकर रहे हैं bool।

आइए कुछ सत्य सारणी बनाएं:

| a | !a | a==1 | a==0 |
| 0 |  1 |   0  |   1  |
| 1 |  0 |   1  |   0  |

जैसा कि आप देख सकते हैं, aऔर a==1बराबर हैं, और !aऔर a==0भी बराबर हैं, तो हम फिर से लिखने कर सकते हैं (a==0 && b==0)xor(c==1)के रूप में (!a && !b) xor c।

अब कुछ और सत्य सारणी:

| a | b | a xor b | a != b |
| 0 | 0 |    0    |    0   |
| 0 | 1 |    1    |    1   |
| 1 | 0 |    1    |    1   |
| 1 | 1 |    0    |    0   |

के a!=bबराबर है a xor b, इसलिए हम फिर (!a && !b) xor cसे लिख सकते हैं (!a && !b)!=c। जैसा कि आप देखते हैं, आपके समाधान पूरी तरह से समकक्ष हैं, बस अलग-अलग 'संकेतों' के साथ लिखा गया है।

---

UPD : उल्लेख करना भूल गए। ऐसे कारण हैं कि प्रोफेसर का समाधान ठीक उसी तरह से दिखता है।

प्रोफेसर का समाधान अधिक मुहावरेदार है। जबकि आपका समाधान तकनीकी रूप से सही है, यह एक मुहावरेदार C ++ कोड नहीं है।

पहला छोटा मुद्दा प्रकारों का उपयोग है। आपका समाधान बीच int- बीच में रूपांतरण पर निर्भर करता है और boolजब आप एक नंबर या उपयोग के लिए बूलियन मान की तुलना करते हैं xor, जो 'बिट-वार एक्सक्लूसिव' या 'ऑपरेटर एक्टिंग ऑन intएस ' भी है। आधुनिक सी ++ में सही प्रकार के मूल्यों का उपयोग करने के लिए बहुत अधिक सराहना की जाती है और इस तरह के रूपांतरणों पर भरोसा नहीं करना चाहिए क्योंकि वे कभी-कभी स्पष्ट और कठिन नहीं होते हैं। के लिए boolइस तरह के मूल्यों trueऔर falseके बजाय 1और 0क्रमशः। तकनीकी रूप से s संख्याओं के रूप में संगृहीत !=होने के xorकारण भी यह अधिक उपयुक्त है bool, लेकिन तार्किक रूप से आपके पास कोई संख्या नहीं है, बस तार्किक मान हैं।

दूसरा मुद्दा मुहावरे के बारे में भी है। यह यहाँ निहित है: a == 0। बूलियन अभिव्यक्तियों की तुलना बूलियन स्थिरांक से करना एक अच्छा अभ्यास नहीं माना जाता है। जैसा कि आप पहले से ही जानते हैं, a == trueपूरी तरह से बस के बराबर है a, और a == falseसिर्फ !aया not a(मैं बाद वाले को पसंद करता हूं)। इस कारण को समझने के लिए कि तुलना करना अच्छा नहीं है बस दो कोड स्निपेट की तुलना करें और निर्णय लें, जो स्पष्ट है:

if (str.empty() == false) { ... }

बनाम

if (not str.empty()) { ... }

Comments

जबकि तकनीकी रूप से सही है, यह उत्तर पूरी तरह से प्रकार और मुहावरेदार सी ++ के बारे में बात करने से बचता है, जो संभवतः इस अभ्यास का बिंदु था।

— कोनराड रुडोल्फ

@KonradRudolph, ओह, हाँ, मैं इसका उल्लेख करना पूरी तरह से भूल गया हूं। शायद मैं अपना जवाब संपादित करूंगा, धन्यवाद

— यूरी

Answer 2

बूलियन सोचो, बिट्स नहीं

संक्षेप में, आपके प्रोफेसर का समाधान बेहतर है (लेकिन अभी भी गलत है, सख्ती से बोलना, आगे नीचे देखें) क्योंकि यह बिटवाइज ऑपरेटरों के बजाय बूलियन ऑपरेटरों का उपयोग करता है और बूलियंस को पूर्णांक के रूप में मानता है। c==1"C सत्य है" को दर्शाने की अभिव्यक्ति गलत है क्योंकि यदि c एक संख्या हो सकती है (बताए गए असाइनमेंट के अनुसार) तो c के किसी भी गैर-शून्य मान को प्रतिनिधित्व माना जाना है true।

इस सवाल को देखें कि 0 या 1 के साथ बूलियन की तुलना करना बेहतर क्यों नहीं है, भले ही ऐसा करना सुरक्षित हो।

उपयोग न करने का एक बहुत अच्छा कारण यह xorहै कि यह बिट-वार एक्सक्लूसिव या ऑपरेशन है। यह अपने उदाहरण में काम करने के लिए होता है क्योंकि दोनों बाएं हाथ की ओर और दाहिने हाथ की ओर बूलियन अभिव्यक्ति है कि परिवर्तित करने के लिए 1 या 0 (फिर से देख रहे हैं 1 )।

बूलियन अनन्य-या वास्तव में है !=।

अभिव्यक्ति को तोड़ना

अपने प्रोफेसर के समाधान को बेहतर ढंग से समझने के लिए, बूलियन ऑपरेटरों को उनके "वैकल्पिक टोकन" समकक्षों के साथ बदलना आसान है, जो इसे बेहतर रिडेबल (imho) में बदल देता है और पूरी तरह से बराबर C ++ कोड: 'for' का उपयोग नहीं कर रहा है! ' और 'और' के लिए '&&' आपको मिलता है

    (not a and not b) != c

दुर्भाग्य से, इसके अलावा कोई तार्किक exclusive_orऑपरेटर नहीं है not_eq, जो इस मामले में सहायक नहीं है।

यदि हम प्राकृतिक भाषा की अभिव्यक्ति को तोड़ते हैं:

या तो ए और बी दोनों झूठे हैं या सी सच है, लेकिन दोनों नहीं।

बूलियन प्रस्ताव ए और बी के बारे में पहला वाक्य:

या तो ए या बी, लेकिन दोनों नहीं।

यह A != Bकेवल (बुलियन के लिए, किसी भी प्रकार ए और बी के लिए) में अनुवाद करता है।

तब प्रस्ताव A था

ए और बी दोनों झूठे हैं

जिसे कहा जा सकता है

a गलत है और b गलत है

जो (not a and not b)अंत में अनुवाद करता है , और अंत में

c सत्य है

जिसका बस अनुवाद किया जाता है c। उन्हें मिलाकर आप फिर से मिल जाते हैं (not a and not b) != c।

आगे की व्याख्या के लिए कि यह अभिव्यक्ति कैसे काम करती है, मैं उन सत्य तालिकाओं को टालता हूं जो दूसरों ने अपने उत्तर में दी हैं।

तुम दोनों गलत हो

और अगर मैं नाइटपिक कर सकता हूं: मूल असाइनमेंट में कहा गया है कि ए, बी और सी गैर-नकारात्मक संख्या हो सकती है, लेकिन स्पष्ट रूप से यह नहीं बताया गया है कि यदि वे संख्याएं थीं, तो उन्हें मान 0 और 1 तक सीमित होना चाहिए। यदि कोई संख्या है तो trueप्रथागत के रूप में 0 का प्रतिनिधित्व नहीं करता है, तो निम्न कोड एक आश्चर्यजनक उत्तर देगा :

    auto c = 2; // "true" in some way
    auto a = 0; // "false"
    auto b = 0; // "false"

    std::cout << ((!a && !b) != c);

// this will output: 1 (!)
// fix by making sure that != compares booleans:

    std::cout << ((!a && !b) != (bool)c);

Comments

अच्छी तरह से उम्मीद है a, bऔर के cरूप में घोषित कर रहे हैं bool, जो मामले c == 1में सही है , हालांकि अत्याचार कोड। वैसे भी, यह वह उत्तर है जो मैंने लिखा होगा: ओपी का कोड प्रोफेसर के समकक्ष हो सकता है, लेकिन यह खराब सी ++ है।

— कोनराड रुडोल्फ

ओपी के असाइनमेंट टेक्स्ट से @KonradRudolph variables are non-negative numbers or boolean:। तो 1 से @dhavenith ने मुझे एक विवरण को पकड़ने के लिए कहा कि यहाँ अन्य लोग चूक गए (मेरे सहित, शुरू में)।

— फ्रॉड डे

महान, इस्सी। धन्यवाद! लेकिन क्या आप मुझे मेरे प्रोफेसर के समाधान के बारे में बता सकते हैं क्योंकि मैं इसे नहीं समझता।

— लिमोनाडे

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

— धवनिथ

Answer 3

मैं कुछ और शब्दों के साथ समझाने की कोशिश करूंगा: संख्याओं को मूल रूप से बूलियन मूल्यों में परिवर्तित किया जा सकता है:

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

स्रोत cppreference पर

इससे निम्नलिखित निष्कर्ष निकलते हैं:

• a == 0एक ही है !a, क्योंकि aएक बूलियन में परिवर्तित होता है और फिर उलटा होता है, जो बराबर होता है !(a != 0)। वही बी के लिए चला जाता है।

• c==1c बराबर होने पर ही सही (bool)cहोगा । रूपांतरण का उपयोग करने पर उपज तभी मिलेगी trueजब c != 0नहीं c == 1। तो यह काम कर सकता है , क्योंकि एक आमतौर पर प्रतिनिधित्व करने के लिए मूल्य 1 का उपयोग करता है true, लेकिन इसका कोई मतलब नहीं है।

• a != bबूलियन एक्सप्रेशन के रूप में a xor bकब aऔर क्या है b। यह सच है, जब एक मूल्य या दूसरा सच है, लेकिन दोनों नहीं। इस मामले में बाएं हाथ की तरफ (a==0 && b==0)बूलियन है, इसलिए दाहिने हाथ की तरफ cभी बूलियन में बदल जाती है, इस प्रकार, दोनों पक्षों को बूलियन अभिव्यक्तियों के रूप में व्याख्या की जाती है, इस प्रकार इस मामले में भी ऐसा !=ही है xor।

आप इन सभी की सत्यता की जांच कर सकते हैं जो अन्य उत्तर प्रदान करते हैं।

Answer 4

जैसा कि हम सत्य तालिकाओं से देख सकते हैं:

• !( not) और ==0एक ही परिणाम दे।
• !=और xorएक ही परिणाम दे।
• c==1 बस के रूप में ही है c

तो एक दूसरे के नीचे, दिखाता है कि ये 2 भाव समान परिणाम क्यों देते हैं:

(a==0 && b==0) xor (c==1)
(!a   && !b)   !=   c

---

सत्य सारणी:

नहीं

    |   | ! |
    | 0 | 1 |
    | 1 | 0 |

== 0

    |   |==0|
    | 0 | 1 |
    | 1 | 0 |

== 1

    |   |==1|
    | 0 | 0 |
    | 1 | 1 |

तथा

   | a | b | && |
   | 0 | 0 |  0 |
   | 0 | 1 |  0 |
   | 1 | 0 |  0 |
   | 1 | 1 |  1 |

बराबर नहीं

   | a | b | != |
   | 0 | 0 |  0 |
   | 0 | 1 |  1 |
   | 1 | 0 |  1 |
   | 1 | 1 |  0 |

XOR

   | a | b |xor|
   | 0 | 0 | 0 |
   | 0 | 1 | 1 |
   | 1 | 0 | 1 |
   | 1 | 1 | 0 |