Python 3.2.1.14 LAB: Essentials of the while loop

3.2.1.14 LAB: Essentials of the while loop

Essentials of the While Loop

If you're taking PCAP - Programming Essentials In Python , you may have encountered this question 3.2.1.14 LAB: Essentials of the while loop.

Objectives

Familiarize the student with:

• using the while loop;
• finding the proper implementation of verbally defined rules;
• reflecting real-life situations in computer code.

Scenario

Listen to this story: a boy and his father, a computer programmer, are playing with wooden blocks. They are building a pyramid.

Their pyramid is a bit weird, as it is actually a pyramid-shaped wall - it's flat. The pyramid is stacked according to one simple principle: 

👉 each lower layer contains one block more than the layer above 👈.

The figure illustrates the rule used by the builders:

building blocks

Your task is to write a program which reads the number of blocks the builders have, and outputs the height of the pyramid that can be built using these blocks.

Note: the height is measured by the number of fully completed layers - if the builders don't have a sufficient number of blocks and cannot complete the next layer, they finish their work immediately.

Test your code using the data we've provided.

Test Data

Sample input: 6

Expected output: The height of the pyramid: 3

Sample input: 20

Expected output: The height of the pyramid: 5

Sample input: 1000

Expected output: The height of the pyramid: 44

Sample input: 2

Expected output: The height of the pyramid: 1

Solution Code

Solution #1

blocks = int(input("Enter the blocks : "))
height = 0
layers = 1
while layers <= blocks:
    height += 1
    blocks -= layers
    layers += 1
print("The height of the pyramid: ", height)

Solution #2

blocks = int(input("Enter number of blocks: "))
print(f'You can build a pyramid {int(0.5 * ((8 * blocks + 1)**0.5 - 1))} blocks high')
# This is how a pyramid formula is done

Solution #3

blocks = int(input("Enter number of blocks: "))

for n in range(blocks):
    if n*(n+1)/2 <= blocks: # This is how a pyramid formula is done
        height = n

print("The height of the pyramid is:", height)

=================================================================================

Follow the blog to be the first to know ❤

Solving the Pyramid Height with a while Loop

This lab turns a simple real-life story into code you can express with a while loop. A boy and his father build a flat, pyramid-shaped wall where each lower layer contains exactly one more block than the layer above it. Given a number of blocks, the program must output the height of the tallest pyramid that uses only fully completed layers; if there are not enough blocks to finish the next layer, the builders stop immediately. The challenge is finding the right implementation of that verbally defined rule.

The first solution tracks three variables: blocks for the total supply, height for the layers built so far, and layers for the size of the next layer. The loop condition while layers <= blocks checks that enough blocks remain to complete the upcoming layer. Inside the loop, height is increased by one, the required blocks are removed with blocks -= layers, and layers is incremented so the next layer demands one more block. This mirrors the real process: count a completed layer, consume its blocks, and grow the requirement by one.

Understanding the Layered Arithmetic

For six blocks the loops builds layers of 1, 2, and 3 blocks, consuming all six, which yields a height of 3. For twenty blocks the cumulative requirement 1 + 2 + 3 + 4 + 5 equals fifteen, leaving just enough for a fifth layer before the next layer of six exceeds the supply, so the height is 5. The post also shows alternative formulas. One uses the closed-form sum of the first n integers with the expression int(0.5 * ((8 * blocks + 1)**0.5 - 1)), and another tries successive values of n in a for loop to find the largest value where n * (n + 1) / 2 <= blocks. All approaches agree the height is the number of fully completed layers.

Key Takeaways

• The while loop repeats as long as layers <= blocks, so it stops when the next layer cannot be completed.
• Each layer uses one more block than the previous layer, so layers increases by one each pass.
• Subtracting blocks -= layers consumes the blocks spent on the current layer.
• The height counts only completely finished layers.
• Sample results: 6 blocks produce height 3, 20 produce 5, 2 produce 1, and 1000 produce 44.
• A while loop naturally models a process that repeats an unknown number of times.

Frequently Asked Questions

Why must the loop stop before the next layer can be completed?

Because the builders finish immediately when insufficient blocks remain, so the height never counts an incomplete layer.

What happens to leftover blocks?

The remaining blocks are ignored because the pyramid ends after the last fully completed layer.

Why does layers increase each loop?

Because each lower layer contains exactly one more block than the layer above it, so every successive layer demands a larger stack of blocks.

Can the answer also be found with a formula?

Yes. The cumulative sum of the first n integers, n * (n + 1) / 2, is used to find the largest n that fits within the available blocks.