Algorithms with Selection and Repetition

A loop may run once for each item in a group, and a selection inside the loop may decide what to do with that item. Here the selection decides whether a package weight joins the running sum, so lighter packages leave total unchanged.

• A is not correct: the algorithm adds package weights rather than counting packages, so total never records how many packages the shipment holds.
• C is not correct: the running sum keeps every qualifying weight, so several heavy packages can contribute together; nothing in the algorithm compares one weight against another.
• D is not correct: packages whose weight is not greater than 10 fail the condition, and a branch whose condition is not satisfied does not run.

Repetition repeats a block while a condition stays true. A loop should eventually stop, and this usually happens because something in the loop changes the condition. Here each repetition raises count, and the loop ends once count reaches 3.

• A is not correct: the condition is tested before any repetition, and 0 is already less than 3, so the body runs at least once.
• B is not correct: stopping after two repetitions would leave count at 2, which is still less than 3, so the condition allows another repetition.
• D is not correct: once count reaches 3 the condition is no longer satisfied, so the body cannot run a fourth time.

This algorithm combines repetition and selection. The loop controls how many times the block runs, while the inner condition decides whether the counter changes on that repetition. Tracking both value and count in a small table keeps the two roles separate.

• A is not correct: the loop body does run, and the inner condition is satisfied on the later repetitions, so the counter does not stay at 0.
• B is not correct: two separate repetitions satisfy the inner condition, not one, because both 3 and 4 are greater than 2.
• D is not correct: 4 counts the repetitions of the loop, not the repetitions in which the inner condition was satisfied.

The algorithm never runs both branches. On each repetition the condition selects one path, so the amount added depends on the current value. The loop runs three times, and the final repetition is the one that takes the ELSE path.

• A is not correct: adding 2 on all three repetitions ignores the ELSE branch, which runs when value is no longer less than 3.
• B is not correct: no combination of the two amounts produces 7, because the three repetitions add 2, 2, and 5.
• C is not correct: this falls one short, because the last repetition takes the ELSE branch and adds 5 rather than a smaller amount.

Selection checks a Boolean condition, one that is either true or false, and then follows the path that matches the answer. The algorithm never runs both branches, so the badge leads either to entry or to denial.

• A is not correct: sequencing puts steps in order; it carries out every step in turn rather than choosing between an entry path and a denial path.
• C is not correct: declaration is not one of the three control-flow ideas in this topic, which are sequencing, selection, and repetition.
• D is not correct: compilation is not one of the control-flow ideas named here, and it does not choose which branch of an algorithm runs.

Repetition, also called iteration, repeats a block of steps while a condition stays true or until a goal is reached. A loop may run once for each item in a group, which is what processing one record at a time requires.

• A is not correct: selection chooses a path based on a Boolean condition; it decides what happens once, not how often a block of steps runs.
• C is not correct: assignment is not one of the control-flow ideas described in this topic, and by itself it does not repeat a block of steps.
• D is not correct: casting is not one of the control-flow ideas described here, so it cannot make the same steps run for every record.

Sequencing is the first control-flow idea, met in Unit 1 as the normal top-to-bottom flow of execution. Selection and repetition are added in Unit 2, but neither is needed when every step happens once in a fixed order.

• A is not correct: choosing one path based on a condition describes selection, and none of these steps is skipped depending on a Boolean condition.
• B is not correct: repeating a block while a condition remains true describes repetition, but each of these steps happens once rather than again and again.
• D is not correct: changing Java source code into bytecode is not a control-flow idea, and it does not decide the order of the steps.

An algorithm is the plan, not the code. Java is one way to write that plan down, and pseudocode is another. The daily admissions algorithm is written in pseudocode so that its selection and repetition can be read without exact Java syntax.

• B is not correct: pseudocode describes an algorithm without exact Java syntax, so it is not the Java source code that a compiler processes.
• C is not correct: planning in pseudocode helps a programmer see the logic, but nothing in this topic claims that it removes logic errors on its own.
• D is not correct: pseudocode is a way of describing an algorithm before writing Java, and this topic does not present it as a substitute for testing.

A trace records how an algorithm's state changes, and each repetition is given its own row. Reading a single row shows what changed during that one repetition, so a decrease of one matches processing one item.

• A is not correct: one item still remains after that repetition, so the row does not show a loop that has reached its exit condition.
• C is not correct: the row shows only how many items remain; it does not report the result of any condition tested inside the loop.
• D is not correct: the count of remaining items fell rather than rose, so nothing was added to the group during that repetition.

AND requires both conditions to be true, OR requires at least one, and NOT reverses a condition. A loop continues while its condition stays true, so the operator decides which combination keeps the scanner running.

• B is not correct: OR requires only one condition to be true, so the scanner would keep running with no documents left or with no storage.
• C is not correct: this condition reverses the document test, so it would allow scanning only when no documents remain.
• D is not correct: a full-storage check names the wrong state and leaves out documents entirely, so it cannot express a rule with two parts.

A loop should eventually stop, and this usually happens because something in the loop changes the condition. Here the condition tests itemsLeft, so the body must move that value toward the point where the test fails.

• A is not correct: resetting the value to 4 restores the starting state each repetition, so the condition stays satisfied and the loop never ends.
• B is not correct: raising itemsLeft moves the value away from 0, so the condition keeps allowing another repetition.
• D is not correct: leaving the value as it is changes nothing in the condition, so the test gives the same answer on every repetition.

A flowchart uses standard shapes, and arrows show the direction of control flow. To represent repetition, an arrow from a later step returns to an earlier decision. The decision is tested again, and the cycle continues until the exit condition is reached.

• B is not correct: ending both paths right after the decision leaves a flow that runs once, so no step is ever reached a second time.
• C is not correct: one straight path is sequencing, and it removes the decision instead of sending the flow back to it.
• D is not correct: a rounded terminator marks the start or end and a rectangle represents a process, so swapping them does not send the flow backward.