Introduction to Problem Solving — NCERT Solutions

Given: Four numbers are entered. Find the largest and the smallest.

Concept: Sequential comparison using conditional statements.

Algorithm:

BEGIN
  READ a, b, c, d

  // Find Largest
  SET largest ← a
  IF b > largest THEN  largest ← b  END IF
  IF c > largest THEN  largest ← c  END IF
  IF d > largest THEN  largest ← d  END IF

  // Find Smallest
  SET smallest ← a
  IF b < smallest THEN  smallest ← b  END IF
  IF c < smallest THEN  smallest ← c  END IF
  IF d < smallest THEN  smallest ← d  END IF

  PRINT "Largest  = ", largest
  PRINT "Smallest = ", smallest
END

Explanation:

• We assume the first number is both the largest and smallest initially.
• We then compare each remaining number and update largest or smallest if a bigger or smaller value is found.

Example: a=12, b=45, c=7, d=30 → Largest = 45, Smallest = 7

Given: Units consumed by a customer. Calculate the water bill using a slab-rate system plus fixed meter charges of ₹75.

Slab structure:

• Units 1–100: ₹5 per unit
• Units 101–250 (next 150 units): ₹10 per unit
• Units above 250: ₹20 per unit

Algorithm:

BEGIN
  READ units
  SET meter_charge ← 75

  IF units <= 100 THEN
    bill ← units × 5

  ELSE IF units <= 250 THEN
    bill ← (100 × 5) + ((units - 100) × 10)

  ELSE
    bill ← (100 × 5) + (150 × 10) + ((units - 250) × 20)

  END IF

  total_bill ← bill + meter_charge
  PRINT "Water Bill (without meter charge) = ₹", bill
  PRINT "Meter Charge                      = ₹", meter_charge
  PRINT "Total Water Bill                  = ₹", total_bill
END

Example: units = 300

• First 100 units: $100 \times 5 = ₹500$
• Next 150 units: $150 \times 10 = ₹1500$
• Remaining 50 units: $50 \times 20 = ₹1000$
• Bill = $500 + 1500 + 1000 = ₹3000$
• Total = $3000 + 75 = ₹3075$

Conditionals are statements in an algorithm or program that allow the execution of different sets of instructions based on whether a given condition is true or false.

They implement decision-making in a program.

Common forms:

• IF–THEN: Execute a block only if the condition is true.
• IF–THEN–ELSE: Execute one block if true, another if false.
• IF–ELSE IF–ELSE (ladder): Handle multiple mutually exclusive conditions.

When are conditionals required?

Conditionals are required when:

1. Different actions need to be performed based on different inputs or situations.

Example: Checking whether a student has passed or failed based on marks.

2. Validation of input is needed.

Example: Accepting only positive numbers.

3. Multiple cases need to be handled.

Example: Assigning grades A, B, C based on percentage ranges.

4. Branching in a program is needed so that not all steps are executed every time.

Example:

IF marks >= 33 THEN
  PRINT "Pass"
ELSE
  PRINT "Fail"
END IF

Without conditionals, a program would execute every statement sequentially regardless of the situation, making it impossible to handle varying inputs correctly.

Note: The actual flowchart symbol images are not visible in the OCR text. The standard NCERT matching is based on universally accepted flowchart symbols:

Matched Pairs:

1. Oval (Rounded Rectangle) → Start/Stop of the Process
2. Rectangle → Process Step
3. Diamond → Decision Making
4. Parallelogram → Data
5. Arrow → Flow of Control

Explanation:

• The oval marks the beginning and end of a flowchart.
• The rectangle represents any processing action (calculation, assignment).
• The diamond represents a yes/no question — a decision point.
• The parallelogram represents input or output of data.
• Arrows show the direction of flow between steps.

Analysis of the original algorithm:
The original algorithm assumes only one mode of transport (bus) and does not account for other real-life scenarios.

Improved Algorithm — Reach_School_Algorithm:

BEGIN
  a) Wake up
  b) Check if it is a school/college day
     IF holiday THEN
       STOP (no need to go)
     END IF
  c) Get ready (freshen up, have breakfast)
  d) Take lunch box
  e) Check the weather
     IF raining THEN
       Take umbrella / raincoat
     END IF
  f) Choose mode of transport:
     IF school bus is available THEN
       Take school bus
     ELSE IF personal vehicle is available THEN
       Travel by personal vehicle (car/bike)
     ELSE IF auto-rickshaw/cab is available THEN
       Take auto-rickshaw or cab
     ELSE
       Walk to school/college
     END IF
  g) Get off at the school/college stop or gate
  h) Reach school or college
  i) Check if you are on time
     IF late THEN
       Report to the teacher / take late entry pass
     END IF
END

Improvements made:

1. Added a check for holidays.
2. Added breakfast and personal preparation steps.
3. Added weather check.
4. Replaced a single transport option (bus) with multiple alternatives: school bus, personal vehicle, auto/cab, or walking.
5. Added a punctuality check on arrival.

Given: A number $n$ is entered. Calculate $n!$

Formula:
$$n! = n \times (n-1) \times (n-2) \times \cdots \times 2 \times 1, \quad 0! = 1$$

Concept: Iterative algorithm using a loop with an accumulator (product).

Pseudocode:

BEGIN
  READ n

  IF n < 0 THEN
    PRINT "Factorial is not defined for negative numbers"
  ELSE
    SET factorial ← 1
    SET i ← 1

    WHILE i <= n DO
      factorial ← factorial × i
      i ← i + 1
    END WHILE

    PRINT "Factorial of ", n, " = ", factorial
  END IF
END

Dry Run for n = 5:

Output: Factorial of 5 = 120 ✓

Given: A 3-digit number is entered. Check if it is an Armstrong number.

Condition: A number $n$ with digits $a$, $b$, $c$ is Armstrong if $a^3 + b^3 + c^3 = n$.

Algorithm (used to draw the flowchart):

BEGIN
  READ num
  SET temp ← num

  // Extract digits
  digit1 ← temp MOD 10          // units digit
  temp   ← temp DIV 10
  digit2 ← temp MOD 10          // tens digit
  digit3 ← temp DIV 10          // hundreds digit

  // Calculate sum of cubes
  sum_of_cubes ← (digit1³) + (digit2³) + (digit3³)

  // Check condition
  IF sum_of_cubes = num THEN
    PRINT num, " is an Armstrong number"
  ELSE
    PRINT num, " is NOT an Armstrong number"
  END IF
END

Flowchart Description (to be drawn):

1. Oval: START
2. Parallelogram: READ num
3. Rectangle: temp ← num
4. Rectangle: digit1 ← temp MOD 10; temp ← temp DIV 10; digit2 ← temp MOD 10; digit3 ← temp DIV 10
5. Rectangle: sum_of_cubes ← digit1³ + digit2³ + digit3³
6. Diamond: Is sum_of_cubes = num?

• YES → Parallelogram: PRINT "Armstrong number"
• NO → Parallelogram: PRINT "Not an Armstrong number"

7. Oval: STOP

Verification with 371:

• digit1 = 1, digit2 = 7, digit3 = 3
• sum = $1^3 + 7^3 + 3^3 = 1 + 343 + 27 = 371$ ✓ → Armstrong number

Verification with 123:

• digit1 = 3, digit2 = 2, digit3 = 1
• sum = $3^3 + 2^3 + 1^3 = 27 + 8 + 1 = 36 \neq 123$ → Not an Armstrong number

Verification of the original algorithm:

Errors found:

• Number 9 should be "Single Digit" but the algorithm gives "Double Digit" (condition should be <= 9, not < 9).
• Number 99 should be "Double Digit" but the algorithm gives "Big" (condition should be <= 99, not < 99).

Corrected Algorithm:

BEGIN
  INPUT Number

  IF Number <= 9 THEN
    PRINT "Single Digit"
  ELSE IF Number <= 99 THEN
    PRINT "Double Digit"
  ELSE
    PRINT "Big"
  END IF
END

Re-verification:

Part (a): On what values will this algorithm fail?

The algorithm uses the condition: (0 <= Number) AND (Number <= 100)

Failures:

1. Number = 0: The condition 0 <= 0 is True, so the algorithm accepts 0. But 0 is not a positive integer, so it should be rejected. ✗

2. Decimal/Float values (e.g., 3.5, 7.8): If the input is a real number, the condition may accept it (e.g., 3.5 satisfies 0 <= 3.5 <= 100), but the problem requires only integers. ✗

3. Number = 100: The condition accepts 100 (100 <= 100 is True). This is correct if 100 is to be included. ✓ (acceptable)

Summary of failure: The algorithm fails for 0 (accepts it incorrectly) and for non-integer (decimal) values (does not filter them out).

Part (b): Improved Algorithm:

BEGIN
  INPUT Number

  IF (Number = INT(Number))           // Check it is an integer
     AND (Number >= 1)                // Check it is positive (>= 1, not 0)
     AND (Number <= 100) THEN         // Check it is within range
    PRINT "ACCEPT"
  ELSE
    PRINT "REJECT"
  END IF
END

Improvements made:

1. Changed 0 <= Number to Number >= 1 so that 0 is rejected (only positive integers are accepted).
2. Added a check Number = INT(Number) to ensure only whole numbers (integers) are accepted and decimal values are rejected.

Verification: