For some calculations, we want an algorithm that accepts only positive integers upto 100. Accept₁to100Algo INP

Exercise · Q18

Q. For some calculations, we want an algorithm that accepts only positive integers upto 100. Accept_1to100_Algo INPUT Number IF (0<= Number) AND (Number <= 100) ACCEPT Else REJECT

a) On what values will this algorithm fail?

b) Can you improve the algorithm?

Puducherry CbseNCERTSubjective· 3mImportance★★★★★est

100% · 36/36 Questions

🔒 Locked · start free trial →

You're viewing a preview — the full solution, concept, methods & PYQ mapping are locked.

Start your 14-day free trial to unlock the full solution →

Concept understanding — Algorithm Refinement

Algorithm Refinement: From Rough Idea to Precise Recipe

Imagine you are asked to "find the largest number in a list." Your first instinct might be: look at each number, remember the biggest one so far, and at the end say what it is. That is a rough, human-level description. It works, but it is vague. What does "look at each number" mean? How do you "remember" it? What if the list is empty?

Algorithm refinement is the process of taking that fuzzy, high-level idea and turning it into a precise, step-by-step procedure that a computer (or another person) can follow without any guesswork. You start with the what and gradually fill in the how.

The Intuition: Layers of Detail

Think of it like giving directions. A rough direction: "Go to the market." A refined one: "Walk straight for 200 metres, turn left at the red building, then enter the second shop on your right." Each step removes ambiguity.

For an algorithm, you begin with a natural-language description (like the one above). Then you refine it into pseudocode — a mix of plain English and simple programming logic. Finally, you might refine it further into actual code in a specific language.

The key insight: refinement is not about changing the idea. It is about making the idea unambiguous and executable.

The Precise Statement

Important

Algorithm refinement is the systematic process of transforming a high-level, abstract description of a computational procedure into a detailed, unambiguous, and implementable sequence of steps. Each refinement step adds precision, removes ambiguity, and brings the description closer to a form that can be directly executed by a machine.

A Concrete Example: Finding the Maximum

Let us refine the "find the largest number" idea through three levels.

Level 1: Natural Language (The Intuition)

Go through the list. Keep track of the biggest number you have seen so far. At the end, that is the answer.

Level 2: Pseudocode (The Refined Plan)

1. Let max = first element of the list
2. For each remaining element in the list:
     If element > max, then set max = element
3. Output max

Notice what has been made precise:

We explicitly initialise max to the first element.
We specify a loop over "remaining elements."
We state the comparison and update clearly.
We say what to output.

Level 3: Code (The Final Implementation)

def find_max(numbers):
    if not numbers:
        return None          # handle empty list
    max_val = numbers[0]
    for num in numbers[1:]:
        if num > max_val: …

Start your 14-day free trial to unlock the full solution →

a) Where it fails. The goal is positive integers up to 100, but the test (0 <= Number) AND (Number <= 100):

accepts 0, which is not positive (the lower bound should be 1);
accepts non-integers like 2.5 or 99.99 — nothing checks that Number is an integer.

(Negative numbers and values above 100 are correctly rejected.)

b) Improved algorithm:

Accept_1to100_Algo (improved)
INPUT Number
IF (Number is an integer) AND (1 <= Number) AND (Number <= 100)
     ACCEPT …

Start your 14-day free trial to unlock the full solution →

The check 0 <= Number <= 100 wrongly accepts 0 (not positive) and wrongly accepts fractions like 2.5 (not integers); the corrected condition is "Number is an integer AND 1 <= Number <= 100".

The idea (matching the condition to the specification). The specification is precise: accept positive integers up to 100, i.e. exactly the whole numbers 1, 2, …, 100. Verifying an algorithm means comparing what the condition actually admits against that set — every extra value admitted is a failure case.

a) On what values does it fail?

Input	Algorithm's verdict	Correct verdict	Failure?
0	0 <= 0 <= 100 → ACCEPT	reject (0 is not positive)	yes
2.5	0 <= 2.5 <= 100 → ACCEPT	reject (not an integer)	yes
99.99	ACCEPT	reject (not an integer)	yes
-5	0 <= -5 false → REJECT	reject	no
100	ACCEPT	accept	no
101	REJECT	reject	no

So the algorithm fails on 0 (the lower bound is wrong — it should start at 1) and on all non-integer values between 0 and 100 (there is no integrality check at all).

b) Improved algorithm

Accept_1to100_Algo (improved)
INPUT Number
IF (Number is an integer) AND (1 <= Number) AND (Number <= 100)
     ACCEPT
Else
     REJECT

Python verification

def accept(number):
    if number == int(number) and 1 <= number <= 100:
        return "ACCEPT"
    return "REJECT" …

Start your 14-day free trial to unlock the full solution →

←Previous questionQ17 — Following is an algorithm to classify numbers as “Single Digit”, “Doub…→Next chapterCh 5Getting Started with Python

Q.For some calculations, we want an algorithm that accepts only positive integers upto 100. Accept_1to100_Algo INPUT Number IF (0<= Number) AND (Number <= 100) ACCEPT Else REJECT

🎓Unlock everything free for 14 days

Q.For some calculations, we want an algorithm that accepts only positive integers upto 100.
Accept_1to100_Algo
INPUT Number
IF (0<= Number) AND (Number <= 100)
ACCEPT
Else
REJECT

Unlock everything free for 14 days