Se a condição A for correspondida, a condição B precisará ser correspondida para executar a ação C

Minha pergunta é:

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

É possível escrever apenas o código de ação C uma vez em vez de duas vezes?

Como simplificá-lo?

Seu primeiro passo nesse tipo de problema é sempre criar uma tabela lógica.

A | B | Result
-------------------
T | T | do action C
T | F | ...
F | T | do action C
F | F | do action C

Depois de fazer a mesa, a solução é clara.

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

Observe que essa lógica, embora mais curta, pode ser difícil para futuros programadores manterem.

Você tem duas opções:

1. Escreva uma função que execute a "ação C".

2. Reorganize sua lógica para que você não tenha tantas instruções if aninhadas. Pergunte a si mesmo que condições causam a "ação C". Parece-me que acontece quando a "condição B" é verdadeira ou a "condição A" é falsa. Podemos escrever isso como "NÃO A OU B". Traduzindo isso para o código C, obtemos

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

Para aprender mais sobre esse tipo de expressão, sugiro pesquisar "álgebra booleana", "lógica de predicados" e "cálculo de predicados". Estes são tópicos matemáticos profundos. Você não precisa aprender tudo, apenas o básico.

Você também deve aprender sobre "avaliação de curto-circuito". Por esse motivo, a ordem das expressões é importante para duplicar exatamente sua lógica original. Embora B || !Aseja logicamente equivalente, usar isso como condição irá executar a "ação C" quando Bfor verdadeira, independentemente do valor de A.

Você pode simplificar a declaração assim:

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

Caso contrário, coloque o código para 'C' em uma função separada e chame-o:

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

Em um idioma com correspondência de padrões, você pode expressar a solução de uma maneira que reflita mais diretamente a tabela de verdade na resposta da PerguntaC.

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

Se você não estiver familiarizado com a sintaxe, cada padrão é representado por um | seguido pelos valores para combinar com (a, b) e o sublinhado é usado como curinga para significar "quaisquer outros valores". Como o único caso em que queremos fazer algo diferente da ação c é quando a é verdadeiro eb é falso, declaramos explicitamente esses valores como o primeiro padrão (verdadeiro, falso) e, então, fazemos o que deve ser feito nesse caso. Em todos os outros casos, passamos ao padrão "curinga" e executamos a ação c.

A declaração do problema:

Se a condição A for correspondida, a condição B precisará ser correspondida para executar a ação C

descreve a implicação : A implica B , uma proposição lógica equivalente a !A || B(como mencionado em outras respostas):

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

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

Ugh, isso também me deixou tropeçado, mas, como indicado pelo Code-Apprentice , garantimos que precisamos do action Cou executamos o elsebloco aninhado , portanto, o código pode ser simplificado para:

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

É assim que chegamos aos 3 casos:

1. O aninhado do action Cna lógica da sua pergunta é necessário condition Ae condition Bdeve ser true- Nessa lógica, se atingirmos o ^2º termo no ifdemonstrativo, sabemos que condition Aé, trueportanto, tudo o que precisamos avaliar é o seguinte condition B:true
2. O elsebloco aninhado na lógica da sua pergunta precisava condition Aser truee condition Bser false- A única maneira de alcançar o elsebloco nessa lógica seria se condition Afosse truee condition Bfossefalse
3. O elsebloco externo na lógica da sua pergunta precisa condition Aser false- Nesta lógica, se condition Afor falso, tambémdo action C

Suportes ao Code-Apprentice por me endireitar aqui. Sugiro aceitar sua resposta , pois ele a apresentou corretamente sem editar: /

No conceito de lógica, você pode resolver esse problema da seguinte maneira:

f = ab +! a
f =?

Como um problema comprovado, isso resulta em f = !a + b. Existem algumas maneiras de provar o problema, como tabela de verdade, mapa de Karnaugh e assim por diante.

Portanto, em idiomas baseados em C, você pode usar o seguinte:

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

PS: Karnaugh Map também é usado para séries mais complicadas de condições. É um método de simplificar expressões de álgebra booleana.

Embora já existam boas respostas, pensei que essa abordagem poderia ser ainda mais intuitiva para alguém que é novo na álgebra booleana do que para avaliar uma tabela da verdade.

A primeira coisa que você quer fazer é procurar, sob quais condições você deseja executar C. É esse o caso quando (a & b). Também quando!a . Então você tem (a & b) | !a.

Se você quiser minimizar, pode continuar. Assim como na aritmética "normal", você pode multiplicar.

(a & b) | !a = (a | !a) & (b | !a). a | ! a é sempre verdade, então você pode simplesmente riscar, o que deixa o resultado minimizado:b | !a . Caso a ordem faça diferença, porque você deseja marcar b apenas se! A for verdadeiro (por exemplo, quando! A é uma verificação de ponteiro nulo eb é uma operação no ponteiro como @LordFarquaad apontado em seu comentário), você pode quer mudar os dois.

O outro caso (/ * ... * /) é sempre será executado quando c não for executado, portanto, podemos apenas colocá-lo no caso else.

Também vale mencionar que provavelmente faz sentido de qualquer maneira colocar a ação c em um método.

O que nos deixa com o seguinte código:

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.
}

Dessa forma, você também pode minimizar os termos com mais operandos, o que rapidamente fica feio com as tabelas verdadeiras. Outra boa abordagem são os mapas de Karnaugh. Mas não vou aprofundar isso agora.

Para tornar o código mais parecido com texto, use sinalizadores booleanos. Se a lógica for especialmente obscura, adicione comentários.

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
  {
  ...
  }

if((A && B ) || !A)
{
  //do C
}
else if(!B)
{
  //...
}

Eu extrairia C para um método e sairia da função o mais rápido possível em todos os casos. elsecláusulas com uma única coisa no final quase sempre devem ser invertidas, se possível. Aqui está um exemplo passo a passo:

Extrato C:

if (A) {
   if (B)
      C();
   else
      D();
} else
   C();

Inverta primeiro ifpara se livrar do primeiro else:

if (!A) {
   C();
   return;
}

if (B)
   C();
else
   D();

Livre-se do segundo else:

if (!A) {
   C();
   return;
}

if (B) {
   C();
   return;
} 

D();

E então você pode perceber que os dois casos têm o mesmo corpo e podem ser combinados:

if (!A || B) {
   C();
   return;
}

D();

Coisas opcionais para melhorar seriam:

• depende do contexto, mas se !A || Bfor confuso, extraia-o para uma ou mais variáveis ​​para explicar a intenção

• qualquer dos C()ou D()é o caso não excepcional deve ir passado, por isso, se D()é a exceção, então invertido a ifuma última vez

O uso de sinalizadores também pode resolver esse problema

int flag = 1; 
if ( condition A ) {
    flag = 2;
    if( condition B ) {
        flag = 3;
    }
}
if(flag != 2) { 
    do action C 
}