#include <vector>
std::vector<int> Range(int from, int to, int step = 1) {
std::vector<int> range;
if (step > 0) {
for(int i = from; i < to; i += step) {
range.push_back(i);
}
} else if (step < 0) {
for(int i = from; i > to; i += step) {
range.push_back(i);
}
}
return range;
}
I don't like code duplication in my implementation, because I have two almost identical blocks. Is it possible to avoid it?
The signum function returns -1, 0, 1 if the argument is negative, zero, or positive.
int original_diff = signum(to-from);
When signum(to-current) is different, we know the relationship changed, regardless of which direction you were going.
if (original_diff == 0) return; //do nothing
for (int current= from; signum(to-current) != original_diff; current += step)
will do what you want.
I think the easiest way to solve this is to first calculate how many steps it takes to go from from to to, and then just build an array of that many elements. That also has the advantage that you can reserve the right amount of elements in the vector up front. You also have to make sure that step has the correct sign.
if (from <= to != step > 0)
step = -step;
size_t distance = std::abs(to - from);
size_t stepsize = std::abs(step);
size_t nsteps = (distance + stepsize - 1) / stepsize;
std::vector<int> range;
range.reserve(nsteps);
for (size_t i = 0; i < nsteps; ++i)
range.push_back(from + i * step);
You also might want to add some check that step is not zero.
auto rq = std::div(to - from, step); size_t nsteps = rq.quot + !!rq.rem? It's all ugly at this point :)
\$\endgroup\$
to - from might overflow...
\$\endgroup\$
The only difference is the </> which swaps on multiplication by a negative factor:
x < y <=> -x > -y. An ugly use would be:
for (int i = from; signum(step)*i < signum(step)*to; i += step) {
for (int i = from; signum(i - to) == signum(step); i += step) {
for (int i = from; (i - to)*signum(step) < 0; i += step) {
for (int i = from; (i - to)*step < 0; i += step) {
The last choice might seem best, but suffers integer overflow for huge values.
In fact the code duplication seems fine.
