if statement - यदि स्थिति A का मिलान किया जाता है, तो C की कार्रवाई करने के लिए शर्त B का मिलान किया जाना चाहिए




if-statement language-agnostic (8)

आप इस तरह से कथन को सरल बना सकते हैं:

if ((A && B) || (!A)) // or simplified to (!A || B) as suggested in comments
{
    do C
}

अन्यथा एक अलग फ़ंक्शन में 'C' के लिए कोड डालें और इसे कॉल करें:

DoActionC()
{
    ....
    // code for Action C
}
if (condition A)
{
    if(condition B)
      {
         DoActionC(); // call the function
      }
    else
      ...
}
else
{
   DoActionC(); // call the function
}

मेरा सवाल यह है कि:

if (/* condition A */)
{
    if(/* condition B */)
      {
         /* do action C */
      }
    else
      /* ... */
}
else
{
   /* do action C */
}

क्या केवल दो बार के बजाय एक बार कार्रवाई सी कोड लिखना संभव है?

इसे सरल कैसे करें?


आपके पास दो विकल्प हैं:

  1. एक फ़ंक्शन लिखें जो "एक्शन सी" करता है।

  2. अपने तर्क को पुनर्व्यवस्थित करें ताकि बयानों के दौरान आपके पास इतने सारे नेस्टेड न हों। अपने आप से पूछें कि किन स्थितियों के कारण "एक्शन सी" होता है। मुझे ऐसा लग रहा है कि ऐसा तब होता है जब या तो "स्थिति बी" सही होती है या "स्थिति ए" झूठी होती है। हम इसे "NOT A OR B" के रूप में लिख सकते हैं। सी कोड में इसका अनुवाद करते हुए, हम प्राप्त करते हैं

    if (!A || B) {
        action C
    } else {
        ...
    }
    

इस तरह के भावों के बारे में अधिक जानने के लिए, मैं सुझाव देता हूं कि "बूलियन बीजगणित", "तर्क को विधेय", और "विधेय की गणना करें"। ये गहरे गणितीय विषय हैं। आपको यह सब सीखने की जरूरत नहीं है, बस मूल बातें।

आपको "शॉर्ट सर्किट मूल्यांकन" के बारे में भी सीखना चाहिए। इस वजह से, भावों का क्रम आपके मूल तर्क की नकल करने के लिए महत्वपूर्ण है। जबकि B || !A B || !A तार्किक रूप से समतुल्य है, इस स्थिति का उपयोग करते हुए "एक्शन C" निष्पादित होगा जब B A के मान की परवाह किए बिना सत्य है।


उह, इसने मुझे भी उलझा दिया, लेकिन जैसा कि कोड-अपरेंटिस द्वारा बताया गया है कि हमें do action C या नेस्टेड- else ब्लॉक चलाने की आवश्यकता else , इस प्रकार कोड को सरल बनाया जा सकता है:

if (not condition A or condition B) {
    do action C
} else {
    ...
}

इस प्रकार हम 3 मामलों को मार रहे हैं:

  1. नेस्टेड do action C को आपके प्रश्न के तर्क के लिए आवश्यक condition A और condition B को true - इस तर्क में, यदि हम 2- nd टर्म में if -ateatement तक पहुँचते हैं, तो हम जानते हैं कि condition A की condition A true इस प्रकार हमें सभी का मूल्यांकन करने की आवश्यकता है क्या यह condition B true
  2. आपके प्रश्न के तर्क में नेस्टेड--ब्लॉक को condition A आवश्यकता condition A को true होना चाहिए और condition B को false होना चाहिए - इस तर्क में else तक पहुँचने का एकमात्र तरीका यह होगा कि condition A true और condition B false
  3. आपके प्रश्न के तर्क में बाहरी else की condition A लिए condition A की false होना आवश्यक है - इस तर्क में यदि condition A की condition A झूठी है, तो हम भी do action C

मुझे यहाँ सीधा करने के लिए कोड-अपरेंटिस के लिए सहारा। मैं उनके उत्तर को स्वीकार करने का सुझाव दूंगा , क्योंकि उन्होंने बिना संपादन के इसे सही ढंग से प्रस्तुत किया: /


कोड को टेक्स्ट की तरह दिखने के लिए, बूलियन झंडे का उपयोग करें। यदि तर्क विशेष रूप से अस्पष्ट है, तो टिप्पणी जोड़ें।

bool do_action_C;

// Determine whether we need to do action C or just do the "..." action
// If condition A is matched, condition B needs to be matched in order to do action C
if (/* condition A */)
{
    if(/* condition B */)
      do_action_C = true; // have to do action C because blah
    else
      do_action_C = false; // no need to do action C because blarg
}
else
{
  do_action_C = true; // A is false, so obviously have to do action C
}

if (do_action_C)
  {
     DoActionC(); // call the function
  }
else
  {
  ...
  }

तर्क अवधारणा में, आप इस समस्या को हल कर सकते हैं:

f = ab +! a
च =?

एक सिद्ध समस्या के रूप में, इसका परिणाम f = !a + b । समस्या को साबित करने के कुछ तरीके हैं जैसे कि सत्य सारणी, कर्णघट मानचित्र आदि।

तो सी आधारित भाषाओं में आप निम्नानुसार उपयोग कर सकते हैं:

if(!a || b)
{
   // Do action C
}

पुनश्च: कर्णघट मानचित्र का उपयोग परिस्थितियों की अधिक जटिल श्रृंखला के लिए भी किया जाता है। यह बूलियन बीजगणित के भावों को सरल बनाने की एक विधि है।


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

match (a,b) with
| (true,false) -> ...
| _ -> action c

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


समस्या कथन:

यदि स्थिति A का मिलान किया जाता है, तो C की कार्रवाई करने के लिए शर्त B का मिलान किया जाना चाहिए

implication वर्णन करता implication : A का अर्थ है, एक तार्किक प्रस्ताव !A || B बराबर है !A || B (जैसा कि अन्य उत्तरों में बताया गया है):

bool implies(bool p, bool q) { return !p || q; }

if (implies(/* condition A */,
            /* condition B */))
{
    /* do action C */
}

हालांकि पहले से ही अच्छे उत्तर हैं, मैंने सोचा कि यह दृष्टिकोण किसी ऐसे व्यक्ति के लिए और भी सहज हो सकता है जो बूलियन बीजगणित के लिए नया है, फिर एक सत्य तालिका का मूल्यांकन करने के लिए।

पहली चीज़ जो आप करना चाहते हैं, वह है, सी। को निष्पादित करने के लिए आप किन परिस्थितियों में ऐसा करना चाहते हैं। इसके अलावा जब !a तो आपके पास (a & b) | !a (a & b) | !a

यदि आप कम से कम करना चाहते हैं तो आप जा सकते हैं। जैसे "सामान्य" अंकगणित में, आप बाहर गुणा कर सकते हैं।

(a & b) | !a = (a | !a) & (b | !a) (a & b) | !a = (a | !a) & (b | !a) । ए | ए हमेशा सच होता है, इसलिए आप इसे पार कर सकते हैं, जो आपको न्यूनतम परिणाम के साथ छोड़ देता है: b | !a b | !a । मामले में आदेश में फर्क पड़ता है, क्योंकि आप b को केवल तभी चेक करना चाहते हैं! अगर यह सही है (उदाहरण के लिए कब! एक nullpointer चेक है और b पॉइंटर पर एक ऑपरेशन है, जैसे @LordFarquaad ने अपनी टिप्पणी में बताया है, तो आप कर सकते हैं दो स्विच करना चाहते हैं।

अन्य मामले (/ * ... * /) को हमेशा निष्पादित किया जाएगा जब c को निष्पादित नहीं किया जाता है, इसलिए हम इसे दूसरे मामले में डाल सकते हैं।

यह भी ध्यान देने योग्य है कि यह संभवत: एक्शन सी को एक विधि में डालने का एक तरीका है।

जो हमें निम्नलिखित कोड के साथ छोड़ देता है:

if (!A || B)
{
    doActionC()  // execute method which does action C
}
else
{
   /* ... */ // what ever happens here, you might want to put it into a method, too.
}

इस तरह से आप अधिक ऑपरेंड वाले शब्दों को भी कम कर सकते हैं, जो जल्दी से सत्य तालिकाओं के साथ बदसूरत हो जाता है। एक और अच्छा तरीका है कर्णघट मानचित्र। लेकिन मैं अब इसमें गहराई तक नहीं जाऊंगा।





boolean-logic