Getting numbers around a number - algorithm

Question

So, I'm trying to do something similar to a paginator (list of page numbers) where the current number is in the middle or as close as can be
Every way I solve it is hard and weird, just wondering if there is a nice mathy way to do it :)
given:
a: current page number
x: first page number
y: last page number
n: number required
I want to generate a list of numbers where a is as close to the center as can be, while staying within x and y
so f(5, 1, 10, 5) would return [3, 4, 5, 6, 7]
but f(1, 1, 10, 5) would return [1, 2, 3, 4, 5]
and f(9, 1, 10, 5) would return [6, 7, 8, 9, 10]
Can anyone think of a nice way of getting that kind of thing?
Implemented in a probably complicated way in ruby, can it be done simpler?
def numbers_around(current:, total:, required: 5)
required_before = (required - 1) / 2
required_after = (required - 1) / 2
before_x = current - required_before
after_x = current + required_after
if before_x < 1
after_x += before_x.abs + 1
before_x = 1
end
if after_x > total
before_x -= (after_x - total)
after_x = total
end
(before_x..after_x)
end

Answer 1

Here's something kind of mathy that returns the first number in the list (JavaScript code):
function f(a,x,y,n){
var m = n >> 1;
return x * (n > y - x) || a - m
+ Math.max(0,m - a + x)
- Math.max(0,m - y + a);
}
Output:
console.log(f(5,1,10,5)); // 3
console.log(f(1,1,10,5)); // 1
console.log(f(9,1,10,5)); // 6
console.log(f(2,1,10,5)); // 1
console.log(f(11,1,10,5)); // 6
console.log(f(7,3,12,10)); // 3

Answer 2

As you wont be mentioning the language you want this to do, here is some explained code I put together in C++:
std::vector<int> getPageNumbers(int first, int last, int page, int count) {
int begin = page - (count / 2);
if (begin < first) {
begin = first;
}
int cur = 0;
std::vector<int> result;
while (begin + cur <= last && cur < count) {
result.push_back(begin + cur);
++cur;
}
cur = 0;
while (begin - cur >= first && result.size() < count) {
++cur;
result.insert(result.begin(), begin-cur);
}
return result;
}
int main() {
std::vector<int> foo = getPageNumbers(1,10,10,4);
std::vector<int>::iterator it;
for (it = foo.begin(); it != foo.end(); ++it) {
std::cout << *it << " " << std::endl;
}
return 0;
}
What it does is basically:
Start at the Element page - (count/2) (count/2 is fine, you dont need to substract zero, as e.g. 2.5 will get rounded to 2).
If start element is below first, start at first
Keep adding Elements to the Result as long as current page number is smaller or equal the lastpage or until enough elements are inserted
Keep on inserting Elements in the beginning as long as there are less than count elements in the Resultvector or until the current Element is smaller than the first page
That is my basic attempt now. The code is executable.

Answer 3

After writing this, I realized it's very similar to #Nidhoegger's answer but maybe it will help? PHP
<?
//Assume 0 index pages
$current = 2;
$first = 1;
$last = 10;
$limit = 5;
$page_counter = floor($limit / 2); //start at half the limit, so if the limit is 5, start at current -2 (page 0) and move up
$pages = array();
for ($i = 0; $i < $limit) {
$page_to_add = $current + $page_counter;
$page_counter++;
if ($page_to_add > $last)
break;
if ($page_to_add > -1) {
$i++;
$pages[] = $page_to_add;
}
}
?>

Answer 4

I think it's just one of those problems with a lot of annoying corner cases.
start = a - (n / 2);
if (start < x) start = x; // don't go past first page.
end = start + (n - 1); // whereever you start, proceed n pages
if (end > y) { // also don't go past last page.
end = y;
start = end - (n - 1); // if you hit the end, go back n pages
if (start < x) start = x; // but _still_ don't go past first page (fewer than n pages)
}
// make some kind of vector [start..end] inclusive.
or, assuming higher-level primitives, if you prefer:
start = max(x, a - (n / 2)) // (n/2) pages before but don't pass x
end = min(start + (n - 1), y) // n pages long, but don't pass y
start = max(x, end - (n - 1)) // really n pages long, but really don't pass x
// make some kind of vector [start..end] inclusive.

Answer 5

Here's what seems to be the most efficient way to me. Using an array from 1 to n, find the index for the a value. First find the center point of the indexes of the array, then check to see if the number is close to one end or the other, and modify it by the difference. Then fill in the values.
It should be quick since instead of iterating, it uses algorithms to arrive at the index numbers.
Pseudocode:
centerindex = Ceiling(n/2, 1)
If (y-a) < (n - centerindex) Then centerindex = 2 * centerindex - (y - a) - 1
If (a-x) < (n - centerindex) Then centerindex = (a - x) + 1
For i = 1 to n
pages(i) = a - (centerindex - i)
Next i