Равномерно распределить n элементов за m итераций

Я буду использовать немного другое соглашение об именах: давайте по интервалам T запускать события [1..T] и N. Также давайте решим задачу как циклическую. Чтобы сделать это, давайте добавим один ложный шаг в конце, на котором мы гарантированно сработаем событие (и это также будет событие в момент времени 0, то есть перед циклом). Итак, мой T - это ваш i+1, а мой N - ваш x+1.

Если разделить T на N с напоминанием, получится T = w*N + r. Если r=0 дело тривиальное. Если r != 0, лучшее, что вы можете достичь, - это интервалы r размера w+1 и интервалы (N-r) размера w. Быстрое и простое, но достаточно хорошее решение будет примерно таким (псевдокод):

events = []
w = T / N
r = T % N
current = 0
for(i = 1; i<=N; i++) {
   current += w;
   if (i <= r)
      current += 1;
   events[i] = current;
}

Вы можете видеть, что последним значением в массиве будет T, как и было обещано нашим переформулированием как циклической проблемой. Это будет T, потому что в течение цикла мы добавим w к current, N раз и добавим r, умноженное на 1, так что сумма будет w*N+r, то есть T.

Главный недостаток этого решения состоит в том, что все «длинные» интервалы будут в начале, а все «короткие» интервалы будут в конце.

Вы можете распределять интервалы более равномерно, если будете немного умнее. И результирующая логика будет по существу такой же, как и за Линейный алгоритм Брезенхема, упомянутым в комментариях. Представьте, что вы рисуете линию на плоскости, где ось X представляет время, а ось Y представляет события, от (0,0) (которое является событием 0 до вашего временного интервала) до (i+1, x+1) (которое является событием x+1, просто по истечении вашего срока). Момент для создания события - это когда вы переключаетесь на следующий Y, то есть рисуете первый пиксель в данном Y.

Если вы хотите делать приращения x по сравнению с итерациями n, вы можете сделать это следующим образом:

int incCount = 0;
int iterCount = 0;

boolean step() {
    ++iterCount;
    int nextCount = (iterCount*x + n/2) / n; // this is rounding division
    if (nextCount > incCount) {
        ++incCount;
        return true;
    }
    else {
        return false;
    }
}

Это простой для понимания способ. Если у вас встроенный ЦП, где разделение дороже, вы можете выполнить точно то же самое, например:

int accum = n/2;

boolean step() {
    accum+=x;
    if (accum >= n) {
        accum-=n;
        return true;
    }
    else {
        return false;
    }
}

Общая сумма, добавленная к accum, здесь, как и в первом примере, равна iterCount*x + n/2, но деление заменено инкрементным повторным вычитанием. Так работает алгоритм рисования линий Брезенхема.