Question

(Duplicate Elimination) Use a one-dimensional array to solve the following problem. Read in 20 numbers, each of which is between 10 and 100 , inclusive. As each number is read, validate it and store it in the array only if it isn't a duplicate of a number already read. After reading all the values, display only the unique values that the user entered. Provide for the "worst case" in which all 20 numbers are different. Use the smallest possible array to solve this problem.

Short answer

Initialize a 91-element array, read and validate each number, check for duplicates during input, store only unique values, and then display these unique values.

Step-by-step solution

Initialize an Array

Start by initializing an array that will hold the numbers entered by the user. Given the scenario of them being all unique, the largest number of unique values between 10 and 100 is 91. So, the array should be capable of holding 91 integers.

Read Numbers and Validate

Create a loop that runs 20 times to read in the numbers. For each number inputted by the user, validate it to ensure it falls within the range of 10 to 100 inclusive.

Check for Duplicates and Store Unique Values

Inside the loop, before storing the number in the array, check if it's already present in the array. If it is not present, store it. Otherwise, skip to the next input.

Display Unique Values

After all 20 numbers have been read, iterate over the array and display the numbers stored in it. Since the stored numbers are all unique, you don't need any extra checks at this point.

Smallest Possible Array Justification

Smallest possible array in this case is one that exactly holds all unique numbers that can be inputted. Since the numbers range from 10 to 100, there are 91 possible unique numbers and so the array must have a size of 91 to handle the 'worst case' scenario.

Key concepts

Understanding One-Dimensional Arrays

One-dimensional arrays in C++ are fundamental data structures that store a collection of elements of the same data type in a linear form. Think of it like a row of mailboxes, each with its own unique index, starting from zero. For tasks such as storing a limited set of elements that can be accessed easily based on their position, one-dimensional arrays come in handy.

To declare an array, you need to specify the data type of its elements and the number of elements it will hold. For instance, int numbers[91]; would declare an array named 'numbers' that can store up to 91 integers. It's important to note that the size of the array should be set based on the maximum number of elements that could be needed, as in the case of our problem where we could potentially have 91 unique values between 10 and 100, inclusive.

Accessing or modifying the array is done using the array's index, where numbers[0] refers to the first element and numbers[90] to the last, in a 91-element array. It's crucial to remember that array indices in C++ start with zero, so an array declared with 91 elements has valid indices from 0 to 90.

Number Validation Techniques

Validating input ensures that only acceptable data is processed by a program. In the context of array duplicate elimination, number validation is integrated to check whether entered numbers fall within the required range before considering them for storage.

To perform number validation, conditional statements are used. For example, if a user inputs a number, you could use a statement like if(number >= 10 && number <= 100) to ascertain that the number is within the inclusive range of 10 to 100. If the input doesn't satisfy the condition, it's typically ignored or the user is prompted to enter a valid number.

• Ensures data integrity by accepting only numbers that meet specific criteria.
• Prevents out of range errors which can occur when an input is outside the bounds expected by the program.
• Improves user experience by guiding users to provide inputs that the program can handle correctly.

Unique Values Storage in Arrays

Storing unique values is fundamental when the need arises to eliminate redundancy in a dataset. In a one-dimensional array, such as the one used to solve the duplicate elimination problem, you require a method to check for uniqueness before any insertion takes place.

One approach is to iterate over the array each time a new number is read, comparing the input with stored values. If a match is found, it indicates a duplicate, and the number is not added again. This comparison before storage is critical:

• It maintains the integrity of the dataset by ensuring no repeated elements.
• It's space-efficient since only unique items occupy the storage.
• Improves the accuracy of operations performed on the dataset post storage, as duplicates can lead to erroneous results in computations or analyses.

In our problem, once the validation confirms a number is within the correct range, the program must check the existing array content to verify if that number has not been previously stored, hence maintaining a collection of unique values.

To display the unique values, iterate through the array after the input phase is complete and print each element. Since all previously stored values are guaranteed unique, no further checks are necessary during this display phase.