[___oj]

Следовательно n увеличится ровно столько раз сколько будит равна размерность массива. И поэтому значение элементов массива не будит превосхадить размерности массива. »

Ты прав, в том примере случайно не число, а индекс в массиве.

Тогда такой вариант:

Код:

1:     #include<conio.h>
2:     #include<stdio.h>
3:     #include<stdlib.h>
4:     #include<time.h>
5:     #include<mem.h>
6:     
7:     
8:     
9:     #define ASIZE        200
10:    #define RANDOMSID    500
11:    
12:    int main()
13:     {
14:     srand(time(NULL));
15:     int values[ ASIZE ], random_id[ RANDOMSID ], randomiza, i, j;
16:    
17:     memset( &random_id, 0, sizeof(random_id) );
18:    
19:    
20:     for( i=0, j=0, randomiza=0; i<ASIZE; )
21:      {
22:      randomiza = rand() % RANDOMSID;
23:      if( !random_id[ randomiza ] )
24:       {
25:       random_id[ j++ ] = 1;
26:       values[ i++ ] = randomiza;
27:       }
28:      }
29:    
30:     for(unsigned n=0; n<200; n++ )
31:      {
32:      printf( "%d ", values[ n ] );
33:      }

[pva]

Извияюсь, что в прошлом примере не поставил разделитель при выводе на экран, чем сбил столку. Иногда не проверяю код :-[
Для случая когда диапазон гораздо больше последовательности, которую надо выдать, предлагаю очередной "хитрый" способ:

Код:

// Опять же предполагаю, что число возможных комбинаций не меньше числа требуемых
// Снова используем принцип случайного перемешивания.
// Но на этот раз хитро делаем выборку. Главное - чтобы она была отсортирована и без повторений.
// использую C++, если возникнут вопросы - переведу на С

static const int rand_range = 500;
static const unsigned rand_count = 200;

// допустим мы уже получили все комбинации и отсортировали их по возрастанию
// рассчитаем вероятность того, что ра расстояние между соседними двумя < x
// пусть числа выпадают с равномерным на [0,M] распределением
// вероятность что число попадёт N раз в отрезок [X,M] равна ((M-X)/M)^N
// тогда вероятность что при N испытаниях расстояние до ближайшего значения_
// будет X равно F(X) = 1 - ((M-X)/M)^N
// по теореме http://www.nsu.ru/mmf/tvims/chernova/tv/lec/node32.html#SECTION000821
// генерируем случайную величину, которая задаёт расстояния между значениями
// dX = (M - X)*(1 - (1 - R)^(1/N))
// где R - равномерно распределённая на [0,1] величина.
// суммируя dX получаем строго возрастающую последовательность

vector<int> rands(rand_count);

{  // заполняем
    int prev = 0;

    for (unsigned count=rands.size(); 0<--count; )
    {
        // dX = (M - X)*(1 - (1 - R)^(1/N))
        // стараемся сделать так, чтобы хватило места для последующих элементов /*1*/

        prev += (double(rand_range - count /*1*/) - double(prev)) *
                    (1. - pow(1. - double(rand())/RAND_MAX), 1./count));

        rands[count] = prev;

        // на единицу смещаем чтобы не выпало одинаковых значений,
        // т.к. данное распределение при округлении может давать 0
        ++prev;
    }
    rands[0] = (double(rand_range) - double(prev)) *(double(rand())/RAND_MAX);
}

// перемешиваем
for (unsigned count=rands.size(); 0<--count; )
{
    std::swap(first[rand() % count], first[count]);
}

// вывод в stdout
for(unsigned count=0; count<rands.size(); ++count)
{
    std::cout << rands[count] << "\n";
}

[ganselo]

предлагаю очередной "хитрый" способ: »

Спасибо всё работает

если возникнут вопросы - переведу на С »

Не стоит... всё понятно.