Examining a given K element in an array - c++

Question

This assignment is about a ship race on a lake.
I have an N array, where I input wind speed.
I have to give a K number, which determines how many consecutive days have the speed of wind between 10 and 100.
If I find the K amount of consecutive elements, I have to console out the first element's index of this sequence.
The goal is to find which day the "race" can be started.
For example:
S[10] = {50,40,0,5,0,80,70,90,100,120}
K=3
The output has to be 6, because it is the 6th element of the array, where this sequence started.
I don't know any method how can I implement this examination.
I tried this:
for (int i=0; i<N-2; i++){
if (((10<=S[i]) && (S[i]<=100)) && ((10<=S[i+1]) && (S[i+1]<=100)) && ((10<=S[i+2]) && (S[i+2]<=100))){
canBeStarted = true;
whichDayItCanBeStarted = i;
}
}
cout << whichDayItCanBeStarted << endl;
But I realised that K can be any number, so I have to examine K elements at once.

Answer 1

Making use of the algorithms standard library
(Restriction: the following answer provides an approach valid for C++17 and beyond)
For a problem such as this one, rather than re-inventing the wheel, you might want to consider turning to the algorithms library in the standard library, making use of std::transform and std::search_n to
produce an integer -> bool transform over wind speeds to validity of said wind speeds, followed by
searching over the result of the transform for a number of (K) sub-sequent true (valid wind speed) elements,
respectively.
E.g.:
#include <algorithm> // std::search_n, std::transform
#include <cstdint> // uint8_t (for wind speeds)
#include <iostream> // std::cout
#include <iterator> // std::back_inserter, std::distance
#include <vector> // std::vector
int main() {
// Wind data and wind restrictions.
const std::vector<uint8_t> wind_speed{50U, 40U, 0U, 5U, 0U,
80U, 70U, 90U, 100U, 120U};
const uint8_t minimum_wind_speed = 10U;
const uint8_t maximum_wind_speed = 100U;
const std::size_t minimum_consecutive_days = 3;
// Map wind speeds -> wind speed within limits.
std::vector<bool> wind_within_limits;
std::transform(wind_speed.begin(), wind_speed.end(),
std::back_inserter(wind_within_limits),
[](uint8_t wind_speed) -> bool {
return (wind_speed >= minimum_wind_speed) &&
(wind_speed <= maximum_wind_speed);
});
// Find the first K (minimum_consecutive_days) consecutive days with
// wind speed within limits.
const auto starting_day =
std::search_n(wind_within_limits.begin(), wind_within_limits.end(),
minimum_consecutive_days, true);
if (starting_day != wind_within_limits.end()) {
std::cout << "Race may start at day "
<< std::distance(wind_within_limits.begin(), starting_day) + 1
<< ".";
} else {
std::cout
<< "Wind speeds during the specified days exceed race conditions.";
}
}
Alternatively, we can integrate the transform into a binary predicate in the std::search_n invocation. This yields a more compact solution, but with, imo, somewhat worse semantics and readability.
#include <algorithm> // std::search_n
#include <cstdint> // uint8_t (for wind speeds)
#include <iostream> // std::cout
#include <iterator> // std::distance
#include <vector> // std::vector
int main() {
// Wind data and wind restrictions.
const std::vector<uint8_t> wind_speed{50U, 40U, 0U, 5U, 0U,
80U, 70U, 90U, 100U, 120U};
const uint8_t minimum_wind_speed = 10U;
const uint8_t maximum_wind_speed = 100U;
const std::size_t minimum_consecutive_days = 3;
// Find any K (minimum_consecutive_days) consecutive days with wind speed
// within limits.
const auto starting_day = std::search_n(
wind_speed.begin(), wind_speed.end(), minimum_consecutive_days, true,
[](uint8_t wind_speed, bool) -> bool {
return (wind_speed >= minimum_wind_speed) &&
(wind_speed <= maximum_wind_speed);
});
if (starting_day != wind_speed.end()) {
std::cout << "Race may start at day "
<< std::distance(wind_speed.begin(), starting_day) + 1 << ".";
} else {
std::cout
<< "Wind speeds during the specified days exceed race conditions.";
}
}
Both of the programs above, given the particular (hard-coded) wind data and restrictions that you've provided, results in:
Race may start at day 6.

Answer 2

You'd need to have a counter variable that's initially set to 0, and another variable to store the index where the sequence begins. and iterate through the array one element at a time. If you find an element between 10 and 100, check if the counter is equal to '0'. If it is, store the index in the other variable. Increment the counter by one. If the counter is equal to K, you're done, so break from the loop. Otherwise, if the element isn't between 10 and 100, set the counter to 0.