Mapping two integers to one, in a unique and deterministic way

algorithmdeterministicintegermappingmath

Imagine two positive integers A and B. I want to combine these two into a single integer C.

There can be no other integers D and E which combine to C.
So combining them with the addition operator doesn't work. Eg 30 + 10 = 40 = 40 + 0 = 39 + 1
Neither does concatination work. Eg "31" + "2" = 312 = "3" + "12"

This combination operation should also be deterministic (always yield the same result with the same inputs) and should always yield an integer on either the positive or the negative side of integers.

Best Answer

You're looking for a bijective NxN -> N mapping. These are used for e.g. dovetailing. Have a look at this PDF for an introduction to so-called pairing functions. Wikipedia introduces a specific pairing function, namely the Cantor pairing function:

pi(k1, k2) = 1/2(k1 + k2)(k1 + k2 + 1) + k2

Three remarks:

As others have made clear, if you plan to implement a pairing function, you may soon find you need arbitrarily large integers (bignums).
If you don't want to make a distinction between the pairs (a, b) and (b, a), then sort a and b before applying the pairing function.
Actually I lied. You are looking for a bijective ZxZ -> N mapping. Cantor's function only works on non-negative numbers. This is not a problem however, because it's easy to define a bijection f : Z -> N, like so:
- f(n) = n * 2 if n >= 0
- f(n) = -n * 2 - 1 if n < 0

Related Solutions

The difference between the remap, noremap, nnoremap and vnoremap mapping commands in Vim

remap is an option that makes mappings work recursively. By default it is on and I'd recommend you leave it that way. The rest are mapping commands, described below:

:map and :noremap are recursive and non-recursive versions of the various mapping commands. For example, if we run:

:map j gg           (moves cursor to first line)
:map Q j            (moves cursor to first line)
:noremap W j        (moves cursor down one line)

Then:

j will be mapped to gg.
Q will also be mapped to gg, because j will be expanded for the recursive mapping.
W will be mapped to j (and not to gg) because j will not be expanded for the non-recursive mapping.

Now remember that Vim is a modal editor. It has a normal mode, visual mode and other modes.

For each of these sets of mappings, there is a mapping that works in normal, visual, select and operator modes (:map and :noremap), one that works in normal mode (:nmap and :nnoremap), one in visual mode (:vmap and :vnoremap) and so on.

For more guidance on this, see:

:help :map
:help :noremap
:help recursive_mapping
:help :map-modes

Python – Generate random integers between 0 and 9

Try:

from random import randrange
print(randrange(10))

Docs: https://docs.python.org/3/library/random.html#random.randrange

Best Answer

Related Solutions

The difference between the remap, noremap, nnoremap and vnoremap mapping commands in Vim

Python – Generate random integers between 0 and 9

Related Topic