Short-circuit evaluation is based on lazy-evaluation (call-by-need
evaluation) of the arguments of some function or operator.
This is all described in various wikipedia articles.
The idea is that the function call defers requesting evaluation of its
arguments until they are actually needed, possibly never evaluating
them if the computation may proceed independently of their value.
The expression "short-circuit evaluation" has been used mostly, at
least initially, for boolean operations. For example, a conjunction
&&) will always return false, if one of the arguments is false.
So if the first argument evalates to false, there is no need to
evaluate the second.
But it is is true, and the second is false, you would think that it
was not necessary to evaluate the first. This is correct, but there is
not much you can do about it. You have to start with one of them, and
the order is usually taken from left to right. So you may start with
one that was not necessary.
Thus short-circuit evaluation also has the implicit idea that there
is an order of evaluation, and that an argument is not evaluated if
previously evaluated arguments show it is not needed.
Similarly, for a disjunction (
||), if the first argument evaluates
to true, there is no need to know the second argument to know the end
if ... then ... else ... conditional, seen as an operator (I am skipping details) is always evaluated in short-circuit, skipping the second or third argument evaluation depending on the value of the first.
The concept can be extended to arithmetics, for example by not evaluating $b()$ in $a()\times b()$ when $a()$ evaluates to $0$.
Short-circuit evaluation does not change the end-result of a program, under the consition that evaluation of arguments has no side-effect. However, it may save on computation time, to such an extent that some programs terminate with short-circuit evaluation, that would not terminate without it. This is typically the case if an argument that is ignored would otherwise cause an infinite computation (there is also the case where it would cause a run-time error, but this may be considered a side-effect).
In your example (assuming as usual left associativity), your answers
For example, considering case 1:
b() is evaluated, because
returns true as first argument of a conjunction. But
c() is not
b() returns false, so that
false. The end result is false.
I am sure you can work out correct answers for the other two cases
(currently wrong in the question).