Branching algorithms

A metro turnstile asks the same question every time: is there enough money on the card? If there is, the gate opens and the fare is deducted; if not, the screen says “Insufficient balance”. The turnstile’s algorithm is not linear: one of two different paths is chosen depending on the answer to a condition. Such algorithms are called branching algorithms. DİM algorithm tasks often give flowcharts with several diamonds, and in every exam of 2025–2026 two or three Python tasks were directly on the topic “Conditional statement” — the key to both is in this lesson.

Full and incomplete branching

• Full branching — both branches contain actions: “if the condition is true, do A, otherwise do B”.
• Incomplete branching — only one branch contains actions: “if the condition is true, do A”; when it is false the algorithm simply goes on.

if a > b then
    m = a
else
    m = b
end if

if x < 0 then
    x = −x
end if

Nested conditions

A branch may contain another diamond — this is nested branching. With it you can separate not two but three, four or more cases. For example, to find the largest of three numbers you first compare a and b, and then compare the winner with c. The same job can be done more simply with two incomplete branchings in a row: m = a; if b > m then m = b; if c > m then m = c. This “candidate” method is very useful in the written tasks too.

In the quadratic-equation flowchart the “No” branch leads to the next diamond — this is a ladder structure: the conditions are checked in turn, the branch of the first true condition runs, and the rest are skipped. In Python it is written with if … elif … else. The order of the conditions matters a lot: if “score ≥ 50” is checked before “score ≥ 90”, a student with 95 points falls into the first branch and never gets “excellent”. Rule: check the narrowest condition first.

Compound conditions: and, or, not

When simple conditions are joined by logical operations, you get a compound condition. “A and B” is true only when both conditions are true; “A or B” is true when at least one is true; “not A” is the opposite of A. In Python they are written and, or, not, and in database queries AND, OR, NOT. Order of operations: first “not”, then “and”, and last “or”; when in doubt, use brackets.

DİM tasks: a flowchart with several diamonds

In such a task the flowchart looks like a tree, but for the given input only one path through it is taken. In each diamond evaluate the condition with the current values, write the answer (“Yes” or “No”) and follow only that arrow — ignore the other branches. Most mistakes happen with strict and non-strict inequalities: 60 > 60 is false, while 60 ≥ 60 is true.

a = 24
b = 40
if a + b > 60:
    if a * 2 == b:
        a = a * 2
    else:
        a = b - a / 4
else:
    if a > b:
        a = a - b
    else:
        a = b / 5
print(a)

34.0

The reverse task: the initial value from the result

DİM sometimes asks about an algorithm in reverse: the result is known and the initial value of a is given as “?”. In a linear algorithm we call the initial value x, express every step through x and get an equation. In a branching algorithm a separate equation is solved for each branch, and then we check that the root really falls into that branch.

1. 1
   Name it

   Call the unknown initial value x.

2. 2
   Express

   After each command express the variables through x (a trace table with expressions instead of numbers).

3. 3
   Equate

   Set the expression of the result equal to the given value and solve the equation.

4. 4
   Check

   Substitute each root into the algorithm: are the branch conditions and restrictions (division by zero, natural numbers) satisfied?

5. 5
   Answer the question asked

   The question may ask for the sum, the product or the largest of the roots — read it again.

Branching gives an algorithm the power to “choose”. The next step is repeating the same commands, which is the topic of the lesson «Loop algorithms and trace tables». A loop’s condition is checked with the same kind of diamond as in this lesson, so reading diamonds fluently will be needed there too.

year = 2100
# print 366 for a leap year, otherwise 365

365