# Exercise 2-8

Write a program to generate the product of the numbers in the range [1,10).

# Solution

The question asks as to compute the product of the numbers within the asymmetric range **[1,10)**. In other words, the product of numbers within the range of 1 to 10, excluding 10. i.e.

1 x 2 x 3 ... x 7 x 8 x 9

**Observation**: this is the same as 9 factorial (9!). This is the same logic as computing n factorial.

Here outlines my solution strategy at the top level.

**Descriptions:**

**Fact:**the product of 3 x 4 x 5 (ascending syntax) is the same as 5 x 4 x 3 (descending syntax). So for simplicity, we restrict ourself by only writing in an ascending syntax. i.e. use**[3,6)**, and avoid**[5,1)**. This is the same as making the assumption of**n >= m**.**Fact:**Case 1, if**(n-m)=0**, e.g. the asymmetric range is**[3,3)**, this is equivalent of saying the range is between 3 and 3 (excluding 3). Because this range is null, the product is also null (zero). No loops required.**Fact:**Case 2, if**(n-m)=1**, e.g. the asymmetric range is**[3,4)**, this is equivalent of saying the range is between 3 and 4 (excluding 4). The range is therefore just the number 3 (i.e.**m**). Likewise, the product is also 3 (i.e.**m**). No loops required.**Fact:**Case 3, if**(n-m)>=1**, e.g. the asymmetric range is**[3,7)**, this is equivalent of saying the range is between 3 and 7 (excluding 7). i.e. we are looking for the product of 3 x 4 x 5 x 6. To compute this we must use loops. The main focus of this post is case 3.

## Case 3 Solution Strategy

After spending an entire Sunday afternoon on this question, I eventually spotted a pattern which I believe is consistent and can be leveraged in the forming of our algorithm. To demonstrate this pattern, I have put together some diagrams in PowerPoint and presented as snapshot images below. For clarity, we are going to focus on this particular (arbitrary) asymmetric range as our core example: **[3, 7)**.

**Observations:**

- The number of elements is always
**(n-m)**. there are 4 elements in this case. - The number of loops required is always
**(n-m-1)**. We need 3 loops in this case. (numLoops = 3). - The number of loops required also equals to the number of (multiplication) operator.
- Knowing the number of loops required enable us to form the loop
**invariant i [0,numLoops)**.

Now, let’s try and observe more patterns – what happens at each loop? (See diagram below)

**Observations:**

- 4 major variables are required.
- The
**integer invariant i**that controls whether the loop is to go ahead or terminate. - The
**integer variable a**– the lower number of the product (a x b). - The
**integer variable b**– the higher number of the product (a x b). - The i
**nteger variable c**– the product of (a x b). - At the beginning of the very first loop, initialise values of a and b.
- At the end of each loop, the re-initialise values of a and b.

The final product of **[m,n)** is the value of **c** at the end of the very last loop.

For completeness, let’s do a drill down into the loops in greater depth. Bear in mind that for **[3,7)**, the **numLoops** is **n-m-1=3.** We need 3 loops. The loop go ahead if the invariant i has not reached **numLoops** – it starts at 0 (zero), and get increment by 1 at end of each loop.

Invariant **i = 0 **(Loop)

Invariant i = 1 (Loop)

**Invariant ****i = 2** (Loop)

Invariant i = 3 (No Loop)

At the end of the loop, output the final result. The product of the numbers within the **asymmetric range [m,n)** is the value of **c** at the end of the very last loop. The following table summarises this looping process.

Invariant i |
a |
b |
c |

0 | 3 | 4 | 12 |

1 | 12 | 5 | 60 |

2 | 60 | 6 | 360 |

## Full Program

We should now have all the fundamentals in the making of our program. This is my version of the program. (There are many ways to do this however!)

#include <iostream> using namespace std; int main() { cout << "***********************************************************\n" << "*** This program computes the product of the numbers ***\n" << "*** in the asymmetric range [m,n). ***\n" << "*** (Limitation: please ensure m is not larger than n) ***\n" << "*** e.g. [3,7) contains elements 3, 4, 5, 6 (but not 7) ***\n" << "***********************************************************"; cout << endl; // Ask user to supply the startNumber cout << "Enter m: "; int m; cin >> m; // Ask user to supply the endNumber cout << "Enter n: "; int n; cin >> n; // Algorithm to compute the product of numbers within the asymmetric range [m,n) const int startNumber = m ; const int endNumber = n; const int numElements = endNumber - startNumber; const int numLoops = numElements - 1; int c; if (numElements == 0) {c = 0;} else if (numElements == 1) {c = startNumber;} else { int a = startNumber; int b = startNumber + 1; cout << " i, a, b, c " << endl; for (int i = 0; i != numLoops; ++i) { c = a * b; cout << i << ", " << a << ", " << b << ", " << c << endl; a = c; ++b; } } cout << "Asymmetric range: [" << startNumber << "," << endNumber << ")" << endl; cout << "Number of elements: " << numElements << endl; cout << "Number of loops required: " << numLoops << endl; cout << "Product of numbers within the asymmetric range = " << c << endl; return 0; }

# Result

The program is meant to be robust and be able to deal with any asymmetric range **[m,n)** as long as (**n>=m**). Case 1-3 are mainly for prove of concepts. Case 4 is the solution to the question (find product of numbers within the range **[1,10)**.

- Case 1 – when
**(n-m)=0**. e.g. [3,3) - Case 2 – when
**(n-m)=1**. e.g. [3,4) - Case 3 – when
**(n-m)>1**. e.g. [3,7) - Case 4 – when
**(n-m)>1**. e.g. [1,10)

## Case 1 – Asymmetric Range [3,3)

*********************************************************** *** This program computes the product of the numbers *** *** in the asymmetric range [m,n). *** *** (Limitation: please ensure m is not larger than n) *** *** e.g. [3,7) contains elements 3, 4, 5, 6 (but not 7) *** *********************************************************** Enter m: 3 Enter n: 3 Asymmetric range: [3,3) Number of elements: 0 Number of loops required: 0 Product of numbers within the asymmetric range = 0

## Case 2 – Asymmetric Range [3,4)

*********************************************************** *** This program computes the product of the numbers *** *** in the asymmetric range [m,n). *** *** (Limitation: please ensure m is not larger than n) *** *** e.g. [3,7) contains elements 3, 4, 5, 6 (but not 7) *** *********************************************************** Enter m: 3 Enter n: 4 Asymmetric range: [3,4) Number of elements: 1 Number of loops required: 0 Product of numbers within the asymmetric range = 3

## Case 3 – Asymmetric Range [3,7)

*********************************************************** *** This program computes the product of the numbers *** *** in the asymmetric range [m,n). *** *** (Limitation: please ensure m is not larger than n) *** *** e.g. [3,7) contains elements 3, 4, 5, 6 (but not 7) *** *********************************************************** Enter m: 3 Enter n: 7 i, a, b, c 0, 3, 4, 12 1, 12, 5, 60 2, 60, 6, 360 Asymmetric range: [3,7) Number of elements: 4 Number of loops required: 3 Product of numbers within the asymmetric range = 360

## Case 4- Asymmetric Range [1,10)

*********************************************************** *** This program computes the product of the numbers *** *** in the asymmetric range [m,n). *** *** (Limitation: please ensure m is not larger than n) *** *** e.g. [3,7) contains elements 3, 4, 5, 6 (but not 7) *** *********************************************************** Enter m: 1 Enter n: 10 i, a, b, c 0, 1, 2, 2 1, 2, 3, 6 2, 6, 4, 24 3, 24, 5, 120 4, 120, 6, 720 5, 720, 7, 5040 6, 5040, 8, 40320 7, 40320, 9, 362880 Asymmetric range: [1,10) Number of elements: 9 Number of loops required: 8 Product of numbers within the asymmetric range = 362880

## Compute the N factorial

Note that this program may also be used as a skeleton program for computing factorial. e.g. 5! = 1 x 2 x 3 x 4 x 5. In other words, to compute n! this is effectively the same as computing the internal product of the numbers within the asymmetric range (0, n+1).

# Conclusion

The product of the numbers within the asymmetric range [0,10) is 362880, as computed by the program (and verified by calculators). This program might also be used as a skeleton program for computing factorial.

Thank you so much. Appreciated!

Hi there ! Did you do the rest of the cases just for fun ?

Because I think the program for computing product of [1,10) is quite straightforward.

Thanks!