What does mean If(!a>=20) in C? - c

Question

#include<stdio.h>
void main()
{int a=12,b=7;
if(!a>=20) //this is the part can't identify
b>>1;
printf("b=%d",b);}
What does mean If(!a>=20) in C this programme?

Answer 1

The expression !a >= 20 is the same as (!a) >= 20.
And ! is the logical-not operator. If a is "true" (which all non-zero values are) then !a will be false.
And false is implicitly convertible to the int value 0 (and true to 1).
So what the expression is doing is checking if a is "true" or "false" and compare the 0 or 1 result of that with the integer value 20. And as both 0 and 1 are smaller than 20 the condition will be false.

Answer 2

Is this a interview question?
Or some tricky problem?
This c - code is not proffesionally indentend and missing of bracketing.
This is unusual way because if statement will never happend and in addition the code inside 'if' does nothing...
As mentioned above !a - will return integer - 0 for non-zeros values of 'a', and integer - 1 for zero value of 'a'...
b>>1 do a bit shifts, but result is not storing anywhere...
I guess that the proper form of code should looks like:
#include<stdio.h>
void main()
{
int a = 12,b = 7;
if(!(a >= 20))
b = b >> 1; // it will execute and produce b equal to 3
printf("b=%d", b);
}

Answer 3

It means the author was aiming for a convoluted form of if (a < 20) but missed.
The unary ! operator has higher precedence than >=, so the expression is parsed as (!a) >= 20. The result of !a is 0 if a is non-zero and 1 if a is zero, neither of which are greater than or equal to 20, so this expression will never be true regardless of the value of a.
It’s pretty clear the author meant to write !(a >= 20), which as I said earlier is the same as a < 20.

Answer 4

To understand any expression, there are sort of two ways of doing it.
For a sensible expression, that matches common idioms, that is well-balanced with the ways people speak and think, you can just sort of look at it and know what it does. If you see the expression
if(a >= 20)
then even if you don't know anything about C programming, as long as you know that > is "greater than", you can read this as "if a is greater than or equal to 20" and get a pretty good (and accurate!) idea of what it does.
But for a more complicated expression, that doesn't match a pattern you've seen before, and especially if it's badly written (or even deliberately confusingly written), you have to analyze it strictly logically, breaking it up into smaller parts, using the same rules the compiler will use. For an expression like this, the important rules have to do with precedence.
We've got
! a >= 20
Hopefully you know that ! is the logical negation operator: it turns false to true, and true to false.
So we're doing something with the variable a here, and we're negating something, and we're comparing something to see if it's greater than or equal, and we're comparing to 20. But how do these pieces fit together, exactly? Which parts of the expression are combined with which other parts?
Here there are really only two possibilities. We could be comparing a to see if it's greater than or equal to 20, and then negating the result. Or, we could be negating a, and comparing the negation of a to see if it's greater than or equal to 20.
To understand these various situations precisely, we can use some special notations to remove all ambiguity. To clearly express the notion of "comparing a to see if it's greater than or equal to 20, and then negating the result" we could write it using explicit parentheses:
! (a >= 20 )
or we could draw a "parse tree", showing graphically how the pieces fit together:
!
|
>=
/ \
a 20
Similarly, to clearly express the notion of "negating a, and comparing the negation to see if it's greater than or equal to 20" we could write it using explicit parentheses:
( ! a ) >= 20
or we could draw a different parse tree:
>=
/ \
! 20
|
a
But we still haven't answered the original question: for the "bare" expression
!a >= 20
which of these two interpretations holds? As I said, to answer it we need to look at the precedence of the operators. The C precedence table says that ! has higher precedence than >=. This means that ! "binds more tightly" than >=. So ! applies to a, and then >= applies to the result. This means that the interpretation we get is as if we had explicitly written
( ! a ) >= 20
So this means, "first logically negate 20". Now, in C, anything with the value 0 is "false", and anything with a nonzero value is "true". We know that a is 12, so that's "true". So !a is false, or 0.
Now we can compare to 20. Is 0 greater than or equal to 20? No, it is not. So the condition
if(!a >= 20)
will not do the controlled thing.
That answers your main question, but there are a few other things which it might be interesting to look at.
First, what is "the controlled thing"? You had
if(!a>=20)
b>>1;
which is kind of hard to read. Normally, when we write an if statement, we indent the controlled thing, to make it more obvious that it is, well, the controlled thing. So let's first write it as
if(!a >= 20)
b >> 1;
So now it's more clear that, if the condition is true, we'll do b >> 1. But we've determined that the condition is not true, So we're not going to do this thing.
What's odd is that even if we did do this thing, it wouldn't do anything. The expression
b >> 1
means, "take b's value and shift it to the right by 1 bit position". Okay, so we do that, but then: what do we do with the shifted result? Nothing! It disappears! This is like saying
b + 1;
Generally, you compute a new result, like b >> 1 or b + 1, so that you can do something with it, like print it out, or assign it to a new variable.
It would have made more sense if the code were written
if(!a >= 20)
b >>= 1;
or
if(!a >= 20)
b = b >> 1;
Now, in either case, we've got code that will, maybe, take b's value, shift it right by one bit, and store the modified value back in b.
But there's still the puzzle that the condition is always false, meaning that we never do the thing.
We decided that the expression
!a >= 20
meant "take a's logically negated value, and see if it's greater than or equal to 20." But logical negation is a "Boolean" operation, that only ever yields true or false. So, no matter what a's value is, the expression !a is always going to be either true or false. So it's always going to be either 1 or 0. So it's never going to be greater than (or equal to) 20.
And actually, things are doubly strange here, because most of the time, if you look at the whole class of true/false Boolean expressions, and the whole class of numeric expressions involving integer and floating-point values, these two classes are sort of like oil and water, they don't mix. You can take an integer and a Boolean value and add them together, or ask if one is greater than or equal to another, but its a strange thing to do, it's suspect, it doesn't usually make sense.
So this is a very strange, basically very stupid, expression to write, because it never does anything interesting. A more interesting expression would be
if(!(a >= 20))
Now, we're comparing a's value (which is a number) to 20. Then, we're taking the true-or-false result, that we got from comparing a to 20, and logically negating it, changing true to false or false to true. That's a much more sensible thing to do.
But in the end, even though it makes more sense, a condition like
if(!(a >= 20))
is still a little bit more complicated, a little bit more confusing, a little bit harder to read than it probably has to be. Instead of saying, "if it's not the case that a is greater than or equal to 20", why not just say, "if it is the case that a is less than 20"? That is, it would be 100% equivalent, and probably much less confusing, to just say
if(a < 20)