Given a set of different integers A, each integer in range from 1 to 5000. It may be assumed that the set size won't be more than 50 (ie: |A|<=50).
I need a one-to-one function f that takes set A and returns an integer. (f: {..} --> R)
So for any A!=B => f(A)!=f(B) (!= stand for not equal). Of course, since A is a set, the order of integers doesn't matter, so A={1,2,3} identical to B={3,1,2}.
I'm sure there are a lot of simple functions that do the job, and functions with only primitive operators such as +,-,*,/ will be preffered.
Hi alex130:
The easiest way would be to multiply each integer by 2^i where i is the position of the integer inside the set.
^ = to the power of.
The elements of the set will have to be sorted first.
Clarification for venkateshwarr:
There are a lot of different sets with specific size, for example if |A|=3 then there are more than 1.38^10 different sets. So I need a function which takes a set (which may be preseted as linked list of integers), checks list size and computes unique integer for the set according to numbers it contains. Then I store that computed integer, and if I get the same list again I can compare function output against already stored integers. So it saves time and space storage in time consuming applications.
0
With monday.comâ€™s project management tool, you can see what everyone on your team is working in a single glance. Its intuitive dashboards are customizable, so you can create systems that work for you.
Comment for Dabas:
Your function is indeed gives one-to-one mapping, but it's not applicable since the numbers it produces are way beyond huge :)
Consider a set of 30 consequent integers: starting from 4950 to 4979. Even last computation 2^30 * 4979 is a huge number, not talking about the whole sum of previous 29.
I'm sorry, I've made a mistake when I told the function output need to be integer. It may (even should) be double.
0
alex130Author Commented:
GENERAL CLARIFICATION:
Function output may (should) be double. :)
f: {..} --> R means that functino takes a set of integers and returns a real number.
There are 5000!/(50!(5000-50!)) possible sets A, that requires over 400 bits to uniquely identify.
Would you settle for a hash function that was not one-to-one, but only rarely returned identical numbers
the cardinality of the power set implied here is even bigger,
50
----- 5000!
\ ---------------- = 2.30715956708335E+120 (the value is from a VB program I wrote)
/ K! (5000 - K)!
-----
K = 1
But this value can still fit in a VB double precision variable which can hold up to 1.79769313486232e+308.
So it's possible to find a function that maps each possible set of integers to a unique number value that
can fit in a double variable type. That is if there exists such a mapping function.
A possible scheme would be to number each set starting from 1:
f({1}) = 1; f({2}) = 2; ....... f({5000}) = 5000;
f({1,2}) = 5001; f({1,3}) = 5002; ...... f({1,5000}) = 9999;
f({2,3}) = 10000; f({2,4}) = 10001; .....f({2,5000}) = 14998;
and so on.... there's a pattern with numbers so there might be a possibility to create a function
from this pattern (most likely a spliced one).
0
alex130Author Commented:
Thoughts: Mapping with hash function and giving each set a unique integer number is either inefficient, space wasting and would take years to compute. It will be better to map to real numbers, using mathematical formula, depending on the set length.
For example consider the following function, I'm not sure that it's one-to-one but it's defenitely a start :)
Suppose A={x1,x2,..,xn}
f(A)=(x1)^(0.n) + (x2)^(0.n) + ... + (xn)^(0.n) (if |A|=5 then 0.n=0.5)
Of course 0.2=0.20 so lets asume that if number after decimal point is multiple
of ten, then it's converted to 0.nnn (so 0.30 will be 0.333). (When set size bound is 99 of course).
alex130:
My BA in Maths happened nearly 30 years ago... Can you please explain what the notation 0.n stands for?
Dabas
0
alex130Author Commented:
to Dabas:
0.n stand for a double (Real) number.
for example if n=5 then it is simply 0.5 (1/2).
So if A={x1,x2,..,xn} then it has n elements (|A|=n) so i would raise each element in power of 0.n and sum results.
For example if A={2, 3004, 4443} then |A|=3 and
f(A)=2^0.3 + 3004^0.3 + 4443^0.3=24.70499967
So far I haven't neither proven that this function is one-to-one nor found a contradictory exmple. But anyway, even if this function is one-to-one it is too slow because it involves raising in power operation which is a very complex one, especially when raising in non integer power.
If you can come up with another one-to-one function which uses only primitive operations (+-,/*) it would be great! :)
if f(A) is truncated to a 64 bit float, it will not be one to one
0
Featured Post
With monday.comâ€™s project management tool, you can see what everyone on your team is working in a single glance. Its intuitive dashboards are customizable, so you can create systems that work for you.
You are talking about arrays.
if you define an array as
int f[100];
f(1)=5;
then this is a one-to-one mapping.
Cheers!
venkat.