Generating a static ranged integer value based on an array of bytes - c++

Question

Okay, this is a strange one I believe, and I have absolutely no idea of how to go about it.
So basically what I'm looking for is a way to generate a fixed ranged integer value based on a given array of bytes.
Say I have an array named imALonleyArray
unsigned char imALonleyArray[16] = {0x33, 0x7E, 0xD5, 0x8F, 0xC3, 0x01, 0x39, 0x0C, 0x5B, 0x0F, 0x80, 0x9C, 0x78, 0x90, 0x89, 0xF5};
I'd like to somehow generate a static ranged integer value based on the above array.
Why you might ask?
I need to assign a fixed int value from possibly int_min to int_max or, really for this program (0-1487) based on a given users 16 byte session token.
Example:
int getIntRangeFromGivenBytes(unsigned char *arr, int minValue, int maxValue){
/*Magic here that somehow computes then returns an int value between
minValue and maxValue based on the given bytes provided by the 'arr' argument*/
}
I tried my best to describe what I'm trying to do here. I'm a newb here, please don't shoot me down.
Thanks in advance!

Answer 1

From what I understand, you're asking for an algorithm that for a given char array, generate an integer within a given range [a,b], where the same integer will pop up for the same input.
A really easy and simple one would be to add them all together and use % modulo to get it into the range.
int interval = maxValue - minValue;
int increment = 0;
for(int i = 0; i < array_size; ++i){
increment += array[i];
increment = increment % interval; // this ensures output is always within the interval
}
int final_answer = increment + a;
If you want one that's reversible, that'd be different. And frankly impossible if there's more possible arrangements of the array than there are elements in the interval. (If two different arrays map to the same integer, how do you reverse it?)
An example, let's say you have interval [0,5].
unsigned char array[2] = {0x00, 0x00}; // assign to 0
unsigned char array[2] = {0x00, 0x01}; // assign to 1
unsigned char array[2] = {0x00, 0x02}; // assign to 2
unsigned char array[2] = {0x00, 0x03}; // assign to 3
unsigned char array[2] = {0x00, 0x04}; // assign to 4
unsigned char array[2] = {0x00, 0x05}; // assign to 5
unsigned char array[2] = {0x00, 0x06}; // now what?
So you need to make sure that the interval is large enough, or limit the size of the char array enough that there's no collisions.
sidenote: the word static means something very specific in C++, so your question was a bit confusing.

Answer 2

You want a hash, and a simple hash on values that are numeric integer types to some range is division:
uint64_t to_value(const uint8_t *array) {
uint64_t result = array[0];
for (int i = 1; i < 8; ++i)
result = (result << 8) | array[i];
return result;
}
uint64_t to_range(uint64_t input, uint64_t lower, uint64_t upper) {
if (lower > upper)
std::swap(upper, lower);
if (upper == std::numeric_limits<uint64_t>::max() &&
lower == std::numeric_limits<uint64_t>::min())
return input;
auto range = upper - lower + 1;
return lower + ((input - lower) / range);
}
Use:
uint64_t my_hash(const uint8_t *data) {
auto value = to_value(data);
return to_range(value, 0, 1487);
}
Whether such a hash has some other properties that you haven’t listed is another story. But it fulfills the requirements you state.