Selection in Computational Thinking, Problem-Solving and Programming

students, imagine a self-checkout machine at a supermarket 🛒. It scans an item, checks whether it is fruit, a bottled drink, or a packaged snack, and then decides what price to show. That decision-making step is an example of selection. In programming, selection lets a program choose between different actions based on a condition. This lesson explains the main ideas and terminology behind selection, shows how it is used in problem-solving, and connects it to the wider IB Computer Science HL topic of computational thinking.

What selection means in programming

Selection is a control structure that makes a program choose a path. The choice depends on whether a condition is true or false. A condition is a logical test such as $x > 10$, $age \ge 18$, or $password = \text{correctPassword}$.

The most common selection statements are:

• Single selection: do something if a condition is true.
• Double selection: choose between two actions, often using if-else.
• Multiple selection: choose from several actions, often using if-else if-else or switch/case.

Selection is important because many real-world problems are not solved by one fixed sequence of steps. A navigation app might choose one route if traffic is heavy and another route if roads are clear. A game might increase difficulty if the player scores highly. A school system might accept a student into a course only if prerequisites are met. These are all examples of decision-making based on data.

In pseudocode, a simple selection structure might look like this:

$$\text{IF } x > 0 \text{ THEN output } \text{\"positive\"}$$

This means the program checks a condition. If the condition is true, it runs a block of instructions.

Core terminology and how it works

To understand selection well, students, it helps to know the key terms used in programming and IB Computer Science HL.

Condition

A condition is a logical expression that evaluates to either true or false. Conditions often use comparison operators such as $=$, $\ne$, $<$, $>$, $\le$, and $\ge$.

Examples:

• $score \ge 50$
• $temperature < 0$
• $username = \text{\"admin\"}$

Conditions can also use logical operators:

• AND means both conditions must be true.
• OR means at least one condition must be true.
• NOT reverses the truth value.

Examples:

• $age \ge 18 \text{ AND } id\_present = \text{true}$
• $rain = \text{true} \text{ OR } wind = \text{true}$
• $\text{NOT } loggedIn$

Branch

A branch is one possible path in a selection structure. If a program uses an if-else statement, it has two branches: one when the condition is true and one when it is false.

Nesting

Selection statements can be placed inside other selection statements. This is called nesting. For example, a school app might first check whether a student is enrolled, and then check whether they are eligible for a club.

Boolean expression

A Boolean expression is an expression that results in true or false. Since selection depends on true/false decisions, Boolean expressions are central to selection.

Pseudocode

Pseudocode is an informal way of writing algorithms. IB often uses pseudocode to focus on logic rather than a specific programming language. Selection in pseudocode should be clear and unambiguous.

Forms of selection with examples

Selection can appear in different forms depending on how many choices are needed.

Single selection

Single selection runs one block only when a condition is true.

Example:

$$\text{IF } temperature > 30 \text{ THEN display } \text{\"Hot day\"}$$

This could be used in a weather app. If the temperature is above $30^\circ\text{C}$, the app shows a warning.

Double selection

Double selection gives two possible outcomes.

Example in pseudocode:

$$\text{IF } marks \ge 50 \text{ THEN display } \text{\"Pass\" ELSE display } \text{\"Fail\"}$$

This is useful when every condition leads to one of two results. A calculator app might use this to decide whether a result is valid or whether an error message should appear.

Multiple selection

Multiple selection handles more than two possible choices.

Example:

• If $score \ge 90$, grade is A.
• Else if $score \ge 80$, grade is B.
• Else if $score \ge 70$, grade is C.
• Otherwise, grade is D.

A well-written multiple selection should test conditions in the correct order. In the grading example, the highest threshold must be checked first. If the code checks $score \ge 70$ before $score \ge 90$, then a score of $95$ would match the first lower condition and receive the wrong grade.

Switch/case selection

Some languages also use a switch/case structure. This is useful when one variable can match several fixed values, such as menu choices or day numbers.

Example:

• If $day = 1$, show Monday.
• If $day = 2$, show Tuesday.
• If $day = 3$, show Wednesday.

This is often cleaner than a long series of if statements when many exact matches are needed.

Selection in algorithmic thinking and problem-solving

Selection is a key part of algorithmic thinking because algorithms often need to adapt to different inputs. An algorithm is not just a list of steps; it is a set of steps designed to work for different situations.

When solving a problem, a programmer usually:

1. Decomposes the problem into smaller parts.
2. Abstracts the important details.
3. Designs an algorithm.
4. Uses selection where decisions are needed.
5. Tests and evaluates the solution.

For example, consider a library system. The system may need to decide whether a member can borrow a book:

• If the member is active and has no overdue books, allow borrowing.
• Otherwise, block borrowing and show a message.

This decision is based on data values stored in the system. Selection helps turn raw data into actions.

Another real-world example is online shopping 🛍️. A website may:

• apply a discount if the customer has a voucher,
• charge shipping if the order total is below a certain amount,
• or recommend related products if the user has viewed similar items.

These decisions make software more useful and personalized.

Writing correct selection logic

Good selection logic must be precise. Small mistakes can cause incorrect results, even when the code looks fine.

Ordering matters

In some cases, the order of conditions changes the outcome. Suppose a student grade system checks:

1. $score \ge 50$
2. $score \ge 80$

A score of $85$ matches the first condition, so the program may assign the wrong grade. The correct order is to check the highest threshold first.

Use clear conditions

Vague conditions can make programs hard to understand. Instead of writing something like “if the user is good,” use a measurable condition such as $attempts \le 3$ or $balance > 0$.

Handle all cases

Programs should consider what happens when none of the expected conditions are true. This is why an else branch is useful. It acts as a default path.

Example:

$$\text{IF } x > 0 \text{ THEN \"positive\" ELSE \"not positive\"}$$

Without a default branch, a program may produce no output or behave unexpectedly.

Test boundary values

Boundary values are values at the edge of a condition. If the rule is $age \ge 18$, test $17$, $18$, and $19$. This helps confirm the code behaves correctly at the exact decision point.

Evaluating solutions that use selection

In IB Computer Science HL, it is not enough to write a selection structure. You also need to evaluate whether it is the best choice for the problem.

Questions to consider include:

• Does the selection structure match the problem requirements?
• Are all possible cases handled?
• Is the logic easy to read and maintain?
• Could a switch/case be simpler than many if-else statements?
• Are conditions placed in the correct order?

For example, if a vending machine has only a few fixed button choices, switch/case may be easier to maintain. But if the machine needs to compare ranges of values, if-else is more suitable.

This kind of evaluation is part of solution design. A strong solution is not only correct; it is also efficient, readable, and appropriate for the task.

Conclusion

Selection is one of the most important ideas in computational thinking because it gives programs the ability to make decisions. students, without selection, a program would follow the same path every time, no matter what input it receives. By using conditions, Boolean expressions, and branching structures such as if, if-else, and switch/case, programmers can build systems that react to data, handle different cases, and solve real-world problems. Selection connects directly to abstraction, decomposition, algorithm design, and evaluation, making it a central part of IB Computer Science HL. ✅

Study Notes

• Selection is a control structure that lets a program choose between paths based on a condition.
• A condition evaluates to true or false and often uses comparison operators like $=$, $<$, $>$, $\le$, and $\ge$.
• Logical operators such as AND, OR, and NOT are used to combine or change conditions.
• Single selection runs one block if a condition is true.
• Double selection provides two branches, usually using if-else.
• Multiple selection is used when there are several possible outcomes.
• Switch/case is useful for fixed-value choices.
• Correct ordering matters when conditions overlap, such as grade boundaries.
• Selection is important in algorithmic thinking because many programs must react differently to different inputs.
• Good solutions handle all possible cases, including a default case.
• Testing boundary values such as $17$, $18$, and $19$ helps check whether selection works correctly.
• Selection supports real-world systems like payment checks, grading systems, login systems, and online shopping recommendations.
• In IB Computer Science HL, selection is evaluated for correctness, readability, and suitability to the problem.