Prompt input until a mimimum number of values is entered - c++

Question

I am writing a small program in which I have to search for smallest and largest element entered.
The thing is I have made an array 10 elements wide and the user should enter at least 5 element.
If the user enter less than 5 elements I want to prompt insufficient elements.
This is the code I have written but it's not working:
#include <iostream>
using namespace std;
int main()
{
int arr[10], largest, smallest, i = 1, j = 1;
cout << "Enter the values in array at least 5 and maximum 10 " << endl;
for (int i = 0; i < 10; i++)
{
cin >> arr[i];
}
while (arr[i] >= 5)
{
largest = arr[0];
smallest = arr[0];
if (largest <= arr[j])
{
largest = arr[j];
}
if (smallest > arr[j])
{
smallest = arr[j];
}
j++;
i++;
}
getch();
return 0;
}

Answer 1

This code demonstrates how you'd find the min and max of a std::vector. The same principles apply to arrays. This piece of code does not allow a variable number of inputs.
#include <algorithm> // std::min_element() & std::max_element
#include <iostream>
#include <random>
#include <vector>
int main() {
// Set up; Fills vector with 10 random digits in range [1, 10]
std::mt19937 prng(std::random_device{}());
std::uniform_int_distribution<int> dist(1, 10);
std::vector<int> numbers(10);
for (unsigned int i = 0; i < numbers.size(); ++i) {
numbers[i] = dist(prng);
}
// Find minimum and maximum, the easy way
auto min = std::min_element(numbers.begin(), numbers.end());
auto max = std::max_element(numbers.begin(), numbers.end());
// Find minimum and maximum, the hard way
int minIdx = 0;
int maxIdx = 0;
for (unsigned int i = 0; i < numbers.size(); ++i) {
if (numbers[i] < numbers[minIdx]) minIdx = i;
if (numbers[i] > numbers[maxIdx]) maxIdx = i;
}
// Print all numbers to verify
for (auto i : numbers) {
std::cout << i << ' ';
}
// This print goes with the std::min_element approach
std::cout << "\nMin: " << *min << "\nMax: " << *max << '\n';
// This print goes with the for loop approach
std::cout << "\nMin: " << numbers[minIdx] << "\nMax: " << numbers[maxIdx]
<< '\n';
}
Output:
1 5 2 10 2 8 6 7 6 7
Min: 1
Max: 10
Min: 1
Max: 10
In both methods, WHERE the min and max are stored are what's recorded. The first method returns an iterator, and the for-loop method records the index. It's more valuable to know where your min and max are versus just knowing the value.
The deal with a variable number of inputs and requiring a minimum is that things get complicated very quickly. The easiest, but not greatest (subjective) approach is to use a sentinel value. It's something the user must type to indicate that they are done typing. The wrinkle here that throws that out a bit is the fact that the user can enter the number 10. So I kind of pull out some bigger guns to handle this. A nice thing about the big guns is that they don't require a sentinel value. The user can just press Enter.
The code below uses a C-array like you, and it is a lot more tedious because of it. std::vectors know their size, and you can just add elements to it. With a C-array, you have to track the size separately, make sure it's always correct, etc. I lose the ability to use range-based for loops since the array may be only partially utilized.
#include <algorithm> // std::min_element() & std::max_element
#include <iostream>
#include <iterator>
#include <random>
#include <string>
int main() {
constexpr int capacity = 10;
int numbers[capacity];
int size = 0;
std::string tmp;
while (size < capacity && std::getline(std::cin, tmp)) {
if (tmp == "" && size >= 5) {
break;
}
if (tmp == "" && size < 5) {
std::cerr << "Need at least 5 elements.\n";
continue;
}
std::size_t pos;
int num;
try {
num = std::stoi(tmp, &pos);
} catch (...) {
std::cerr << "Exception thrown.\n";
continue;
}
if (pos != tmp.length()) {
std::cerr << "Bad Value.\n";
continue;
}
if (num >= 0 && num <= 10) {
numbers[size] = num;
++size;
}
}
// Find minimum and maximum, the easy way
auto min = std::min_element(std::begin(numbers), std::begin(numbers) + size);
auto max = std::max_element(std::begin(numbers), std::begin(numbers) + size);
// Find minimum and maximum, the hard way
int minIdx = 0;
int maxIdx = 0;
for (int i = 0; i < size; ++i) {
if (numbers[i] < numbers[minIdx]) minIdx = i;
if (numbers[i] > numbers[maxIdx]) maxIdx = i;
}
// Print all numbers to verify
for (int i = 0; i < size; ++i) {
std::cout << numbers[i] << ' ';
}
// This print goes with the std::min_element approach
std::cout << "\nMin: " << *min << "\nMax: " << *max << '\n';
// This print goes with the for loop approach
std::cout << "\nMin: " << numbers[minIdx] << "\nMax: " << numbers[maxIdx]
<< '\n';
}
You can tell how much extra work is required just for basic ASCII input. If you make some assumptions, a lot of the code can be cut out, but where user input is concerned, those assumptions are rarely safe, and are more of a convenience for quick testing or learning purposes.