N个整数（数的大小为0-255）的序列，把它们加密为K个整数（数的大小为0-255）.再将K个整数顺序随机打乱，使得可以从这乱序的K个整数中解码出原序列。设计加密解密算法,且要求K<=15*N.

N个整数（数的大小为0-255）的序列，把它们加密为K个整数（数的大小为0-255）.再将K个整数顺序随机打乱，使得可以从这乱序的K个整数中解码出原序列。设计加密解密算法,且要求K<=15*N.

如果是：

N<=16,要求K<=16*N.
N<=16,要求K<=10*N.

N<=64,要求K<=15*N.

#include <iostream>
using namespace std;

void printArray(int* arr, int len) {
if (!arr) {
return;
}
for (int i = 0; i < len; ++i) {
cout << arr[i] << " ";
}
cout << endl;
}

int cmp(const void *a, const void *b) {
int aa = (*(const int*) a) >> 4;
int bb = (*(const int*) b) >> 4;
return aa - bb;
}

int cmp1(const void *a, const void *b) {
int aa = (*(const int*) a) >> 2;
int bb = (*(const int*) b) >> 2;
return aa - bb;
}

void disorder(int* arr, int len) {
srand((int) time(NULL));
for (int i = 0; i < len; i++) {
int tmp = rand() % len;
swap(arr[i], arr[tmp]);
}
}

int* encrypt1(int* arr, int len, int k) {
int id = 0;

int* encryptArr = new int[k * len];
memset(encryptArr, 0, sizeof(int) * k * len);
for (int i = 0; i < len; ++i) {
int index = (i << 4);
int prev = arr[i] >> 4;
int last = arr[i] & 15;
for (int j = 0; j < k - 8; ++j, id++) {
encryptArr[id] = index | prev;
}
for (int j = 0; j < 8; ++j, id++) {
encryptArr[id] = index | last;
}
}

//	printArray(encryptArr, k * len);
disorder(encryptArr, k * len);

return encryptArr;
}

int* encrypt2(int* arr, int len, int k) {
int id = 0;

int* encryptArr = new int[k * len];
memset(encryptArr, 0, sizeof(int) * k * len);
for (int i = 0; i < len; ++i) {
int index = (i << 2);
int data1 = arr[i] >> 6;
int data2 = (arr[i] >> 4) & 3;
int data3 = (arr[i] >> 2) & 3;
int data4 = arr[i] & 3;

encryptArr[id++] = index | data1;

for (int j = 0; j < 2; ++j, id++) {
encryptArr[id] = index | data2;
}

for (int j = 0; j < 4; ++j, id++) {
encryptArr[id] = index | data3;
}

for (int j = 0; j < 8; ++j, id++) {
encryptArr[id] = index | data4;
}
}

//	printArray(encryptArr, k * len);
disorder(encryptArr, k * len);

return encryptArr;
}

int* decrypt1(int* encryptArr, int len, int k) {
qsort(encryptArr, k * len, sizeof(int), cmp);
//	printArray(encryptArr, k * len);

int* decryptArr = new int[len];
memset(decryptArr, 0, sizeof(int) * len);
int prev = 0;
int last = 0;
int count1 = 0;
int count2 = 0;
int index = 0;
for (int i = 0; i < k * len; i += k) {
prev = encryptArr[i];
count1 = 1;
count2 = 0;
for (int j = i + 1; j < i + k; ++j) {
if (prev == encryptArr[j]) {
count1++;
} else {
last = encryptArr[j];
count2++;
}
}
if (count1 > k - 8) {
if (count1 == k) {	//加密前prev,last相同
last = prev;
}
swap(last, prev);
} else if (count2 > k - 8) {
if (count2 == k) {
prev = last;
}
}
prev &= 15;
last &= 15;
prev <<= 4;
decryptArr[index++] = prev | last;
}

return decryptArr;
}

int* decrypt2(int* encryptArr, int len, int k) {
qsort(encryptArr, k * len, sizeof(int), cmp1);
//	printArray(encryptArr, k * len);

int* decryptArr = new int[len];
memset(decryptArr, 0, sizeof(int) * len);
int* data = new int[4];
int* count = new int[4];
int index = 0;
int id = 1;
for (int i = 0; i < k * len; i += k) {
memset(data, -1, 4 * sizeof(int));
memset(count, 0, 4 * sizeof(int));
data[0] = encryptArr[i];
count[0] = 1;
id = 1;
for (int j = i + 1; j < i + k; ++j) {
if (encryptArr[j] == data[0]) {
count[0]++;
} else if (encryptArr[j] == data[1]) {
count[1]++;
} else if (encryptArr[j] == data[2]) {
count[2]++;
} else if (encryptArr[j] == data[3]) {
count[3]++;
} else if (id < 4) {
data[id] = encryptArr[j];
count[id]++;
id++;
}
}
int data1 = -1;
int data2 = -1;
int data3 = -1;
int data4 = -1;
for (int i = 0; i < 4; ++i) {
if (!count[i]) {
break;
}
switch (count[i]) {
case 1:
data1 = data[i] & 3;
break;
case 2:
data2 = data[i] & 3;
break;
case 4:
data3 = data[i] & 3;
break;
case 8:
data4 = data[i] & 3;
break;
case 3:
data1 = data2 = data[i] & 3;
break;
case 5:
data1 = data3 = data[i] & 3;
break;
case 9:
data1 = data4 = data[i] & 3;
break;
case 6:
data2 = data3 = data[i] & 3;
break;
case 10:
data2 = data4 = data[i] & 3;
break;
case 12:
data3 = data4 = data[i] & 3;
break;
case 7:
data1 = data2 = data3 = data[i] & 3;
break;
case 11:
data1 = data2 = data4 = data[i] & 3;
break;
case 13:
data1 = data3 = data4 = data[i] & 3;
break;
case 14:
data2 = data3 = data4 = data[i] & 3;
break;
}

}
decryptArr[index] |= data1 << 6;
decryptArr[index] |= data2 << 4;
decryptArr[index] |= data3 << 2;
decryptArr[index] |= data4;

index++;

}
return decryptArr;
}

int* encryptChoice(int* arr, int len, int n, int k) {
int* encryptArr = NULL;
if (n == 16) {
if (len > n) {
return NULL;
}
if (k == 16) {
k = 12;
encryptArr = encrypt1(arr, len, k);
} else if (k == 10) {
encryptArr = encrypt1(arr, len, k);
}
} else if (n == 64 && k == 15) {
encryptArr = encrypt2(arr, len, k);
}

if (encryptArr) {
cout << "n,k: " << n << "," << k << endl;
cout << "加密数组:" << endl;
printArray(encryptArr, k * len);
}

return encryptArr;
}

void decryptChoice(int* encryptArr, int len, int n, int k) {
int* decryptArr = NULL;
if (n == 16) {
//int 是32bit
if (len > n) {
return;
}
if (k == 16) {
k = 12;
decryptArr = decrypt1(encryptArr, len, k);
} else if (k == 10) {
decryptArr = decrypt1(encryptArr, len, k);
}
} else if (n == 64 && k == 15) {
decryptArr = decrypt2(encryptArr, len, k);
}

if (decryptArr) {
cout << "解密数组:" << endl;
printArray(decryptArr, len);
}
}
int main() {
int arr1[] =
{ 12, 20, 51, 4, 7, 48, 32, 13, 41, 35, 44, 67, 55, 34, 54, 63 };
int len = sizeof(arr1) / sizeof(int);

int k = 16;
int n = 16;
int* encryptArr = NULL;
encryptArr = encryptChoice(arr1, len, n, k);
decryptChoice(encryptArr, len, n, k);

k = 10;
encryptArr = encryptChoice(arr1, len, n, k);
decryptChoice(encryptArr, len, n, k);

k = 15;
n = 64;
encryptArr = encryptChoice(arr1, len, n, k);
decryptChoice(encryptArr, len, n, k);
return 0;
}