# Copy array with variable remap

This topic is 1866 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

## Recommended Posts

Hello.
Is there an algorithm or a function to remap an array in C to another array with a constant maping? I.e. I have an array of bytes (uint8_t) with 4 elements, and I would like to copy the values from this array to another array with a "static remap".

[CODE]uint8_t array_in[4];
uint8_t array_out[4];
void array_remap(uint8_t map, uint8_t * array_in, uint8_t * array_out) {
...
}[/CODE]

The function also takes a map parameter. This means that every time the function is called it has to remap the variables in the same order, provided that the map parameter is identical. Basically it acts like a seed number for the random remapper. Here's how the remap is supposed to take place according to the seed number. The remap table doesn't have to be exactly as displayed, but it should offer all 24 possibilities (4 elements mean 4! = 24 total combinations).

[quote]0x00: abcd -> abcd
0x01: abcd -> abdc
0x02: abcd -> acbd
0x03: abcd -> acdb
0x06: abcd -> bacd
0x09: abcd -> bcda
0x0A: abcd -> bdac
0x0B: abcd -> bdca
0x0C: abcd -> cabd
0x0F: abcd -> cbda
0x10: abcd -> cdab
0x11: abcd -> cdba
0x12: abcd -> dabc
0x13: abcd -> dacb
0x14: abcd -> dbac
0x15: abcd -> dbca
0x16: abcd -> dcab
0x17: abcd -> dcba[/quote]

I could write the function by using a 4x4=16 bit field inside an uint16_t function parameter, but I'm trying to reduce the parameter size to a simple index number (8 bits). Could the map parameter be somehow reduced to fit inside a byte (8 bits)?
Any ideas?

##### Share on other sites
What you call "remap" is usually called a "permutation".

This is how I would write the code:
[code]#include <stdio.h>
#include <inttypes.h>
#include <string.h>

void apply_kth_permutation(uint8_t *array, unsigned n, unsigned k) {
for (unsigned i = 0; i < n; ++i) {
unsigned j = i + (k % (n-i));
k /= n-i;
uint8_t temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}

int main() {
uint8_t s[5] = "abcd";
uint8_t a[5];
for (unsigned k=0; k<24; ++k) {
memcpy(a, s, 5);
apply_kth_permutation(a, 4, k);
puts(a);
}
}
[/code] Edited by Álvaro