Btukfyl

For "not too random" integers, you could start with the current UNIX time, then use the recursive formula r = ((r * 7621) + 1) % 32768;. The nth random integer between 0 (inclusive) and M (exclusive) would be r % M after the nth iteration.

This is called a linear congruential generator.

The recursion formula is what bzip2 uses to select the pivot in its quicksort implementation. I wouldn't know about other purposes, but it works pretty well for this particular one...

Look at implementing a pseudo-random generator (what's "inside" rand()) of your own, for instance the Mersenne twister is highly-regarded.

The only "robust" (not easily predictable) way of doing this is writing your own pseudo-random number generator and seeding it with the current time. Obligatory wikipedia link: http://en.wikipedia.org/wiki/Pseudorandom_number_generator

You can get the "Tiny Mersenne Twister" here: http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/TINYMT/index.html

it is pure c and simple to use. E.g. just using time:

#include "tinymt32.h"

// And if you can't link:

#include "tinymt32.c"



#include <time.h>

#include <stdio.h>



int main(int argc, const char* argv)

{

    tinymt32_t state;

    uint32_t seed = time(0);



    tinymt32_init(&state, seed);



    for (int i=0; i<10; i++)

            printf("random number %d: %un", i, (unsigned int)tinymt32_generate_uint32(&state));

}

The smallest and simple random generator which work with ranges is provided below with fully working example.

unsigned int MyRand(unsigned int start_range,unsigned int end_range)

  {

    static unsigned int rand = 0xACE1U; /* Any nonzero start state will work. */



    /*check for valid range.*/

    if(start_range == end_range) {

        return start_range;

    }



    /*get the random in end-range.*/

    rand += 0x3AD;

    rand %= end_range;



    /*get the random in start-range.*/

    while(rand < start_range){

        rand = rand + end_range - start_range;

    }



    return rand;

  }



int main(void)

{

    int i;

    for (i = 0; i < 0xFF; i++)

    {

    printf("%ut",MyRand(10,20));

    }

    return 0;

}

If you're not generating your numbers too fast (*1) and your upper limit is low enough (*2) and your "time of day" includes nanoseconds, just use those nanoseconds.

#include <stdio.h>

#include <stdlib.h>

#include <time.h>



int nanorand(void) {

    struct timespec p[1];

    clock_gettime(CLOCK_MONOTONIC, p);

    return p->tv_nsec % 1000;

}



int main(void) {

    int r, x;

    for (;;) {

        r = nanorand();

        do {

            printf("please type %d (< 50 quits): ", r);

            fflush(stdout);

            if (scanf("%d", &x) != 1) exit(EXIT_FAILURE);

        } while (x != r);

        if (r < 50) break;

    }

    puts("");

    return 0;

}

And a sample run ...

please type 769 (< 50 quits): 769

please type 185 (< 50 quits): 185

please type 44 (< 50 quits): 44

<sup>(*1) if you're using them interactively, one at a time

(*2) if you want numbers up to about 1000</sup>

#include<stdio.h>

#include<conio.h>

#include<stdlib.h>

int main()

{

unsigned int x,r,i;

// no of random no you want to generate

scanf("%d",&x);

// put the range of random no 

scanf("%d",&r);

unsigned int *a=(unsigned int*)malloc(sizeof(unsigned int)*x);

for(i=0;i<x;i++)

printf("%d ",(a[i]%r)+1);   

free(a);

getch();

return 0;

}

One of the simplest random number generator which not return allways the same value:

uint16_t simpleRand(void)

  {

    static uint16_t r = 5531; //dont realy care about start value

    r+=941; //this value must be relative prime to 2^16, so we use all values

    return r;

  }  

You can maybe get the time to set the start value if you dont want that the sequence starts always with the same value.