# V686\. Pattern A \|\| \(A && \.\.\.\) was detected\. The expression is excessive or contains a logical error\.

The analyzer has detected an expression that can be simplified\. In some cases, it may also mean that such an expression contains a logical error\.

Here is an example of suspicious code:

```cpp
int k,n,j;
...
if (n || (n && j))
```

This expression is redundant\. If "n\=\=0", the condition is always false\. If "n\!\=0", the condition is always true\. That is, the condition does not depend on the 'j' variable and therefore can be simplified:

```cpp
if (n)
```

Sometimes such redundancy may indicate a typo\. Imagine, for instance, that the condition must actually be like this one:

```cpp
if (k || (n && j))
```

Now, the following is a more realistic example which actually caused us to implement this diagnostic:

```cpp
const char *Name = ....;
if (Name || (Name && Name[0] == 0))
```

Here we have both an error and redundancy\. The condition must be executed if the string referred to by the 'Name' pointer is empty\. An empty string can be referred to by a null pointer\.

Because of a mistake, the condition will be executed whenever Name \!\= nullptr\. This is the fixed code:

```cpp
if (!Name || (Name && Name[0] == 0))
```

We've got rid of the error, but we can also eliminate unnecessary check:

```cpp
if (!Name || Name[0] == 0)
```