Question

让我们假设我有一个如下所示的输入数组

这里存储数组的每个元素，它占用1255位，即使数组元素的值非常小，即11 bit是数组中的最大元素并存储我只需要{{1}这意味着在11 bit我可以适应数组的所有其他元素。

我的任务是将32-bit elements of array压缩为11-bit array elements吗？预期的压缩数组看起来像

int output_arr[] = {00000001010 00000010100 .... 10011111111 ... }
                        |             |               |
                   11 bits(1)    11 bits(2)     11 bits( 1255)

要完成上述任务，我所做的就是

找到给定数组中的maximum元素
找到bits required来存储maximum elements（上一步）
找到存储bytes所需的no of bits，例如存储我需要等同的11位2 bytes（在下面的代码new_size中包含此内容）。 这是我需要你的帮助。以下是我的经理讲述的内存浪费，因为存储11位我的new_size是2 bytes，即5 bits仍然是额外的或浪费的。我怎么能避免这种情况。

这是我试过的

int my_pow(int input_num,int p) {
        int temp = 1;
        for(int iter = 0;iter < p; iter++) {
                temp = temp * input_num;
        }
        return temp;
}
int main() {
        #if 0
        int input_array[53069] = {1,2,2,3,4,1,2,4,6,1255,1,2,5,1233};
        #endif
        int input_array[] = {1,2,3,4,6,1255,1,2,5,1233};

        int max = input_array[0], ele = sizeof(input_array)/sizeof(input_array[0]);
        /* finding max elements in a array */
        for(int i = 0;i < ele; i++) {
                if(input_array[i] > max) {
                        max = input_array[i];
                }
        }
        /* finding no of bits required to store highest elements of array */
        int bit_required = 0;
        while(1) {
                if(max < my_pow(2,bit_required))
                        break;
                bit_required+=1;
        }
        /* when above loop fails bit_required is nothing 
           but no of bit required to store the highest element of array */

        /* finding size of new/compressed array */
        int new_size = 0;
        if(bit_required % 8 == 0) {
                new_size = bit_required/8;
        }
        else {
                new_size = (bit_required/8) + 1;
        }
        /* construct the new array again */
        typedef struct array_task {
                unsigned char new_array[new_size];/* in each cmp_arr, can store new_size char
                                                     now for each B[] I'm not using 32 bits , its new_size bits */
        }cmp_arr;/* creating new array of ele elements */
        cmp_arr cmpressed[ele];
        /* store elements of input_array[] into output_array[] */
        for(int row = 0 ; row < ele ;row++) {
                for(int col = bit_required - 1; col >= 0; col-- ) {
                        cmpressed[row].new_array[col] = ((input_array[row] >> col & 1) + 48) ;
                        printf("%d",(cmpressed[row].new_array[col]) - 48);
                }
                printf("\n");
        }
        #if 0
        printf("Size of A before %d\n",sizeof(input_array)); /* 40 bytes */
        printf("size of compressed array %d\n",sizeof(cmp_arr));/* same task, it perform in 2 bytes, 
                                                                each elements won't take 32 bits  */
        #endif
        return 0;
}

还有其他方法可以有效地完成同样的任务吗？我们非常欢迎所有的建议吗？

Answer 1

要将值移位11位而不是8位，16位或32位需要使用位进行操作。您基本上必须模拟一个（例如32位）整数数组中的位数组。在这种情况下，如果值存储在位偏移X处，它将（可能）存储在索引X / 32和X / 32 + 1的某个位置（如果它跨越32位的边界）。每当你必须在数组中设置一个值时，你必须加载这两个值并且＆＃34;放置＆＃34;你的电话号码。实现有点技术性，请尝试以下代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#define MASK32 ((uint64_t)0xffffffff)

void setValue(uint32_t *a, int bits, int i, int n) {
    int bitoffset = i * bits;
    int index = bitoffset / 32;
    int shift = bitoffset % 32;
    uint64_t maskbits = (~(uint64_t)0) >> (64-bits);
    uint64_t val = ((uint64_t)a[index+1]<<32) + a[index];
    val = val & ~(maskbits << shift) | ((n & maskbits) << shift);
    a[index] = (val & MASK32);
    a[index+1] = (val >> 32) & MASK32;
}

int getValue(const uint32_t *a, int bits, int i) {
    int bitoffset = i * bits;
    int index = bitoffset / 32;
    int shift = bitoffset % 32;
    uint64_t maskbits = (~(uint64_t)0) >> (64-bits);
    int val = ((((uint64_t)a[index+1]<<32) + a[index]) >> shift) & maskbits;
    return(val);
}

int input_arr[100] = {10,20,1255,1200,50,55,1,5,6,1000};

int main() {
    int        i, j;
    uint32_t   a[100*11/32+2];

    for(i=0; i<100; i++) setValue(a,11,i,input_arr[i]);
    for(j=0; j<100; j++) printf("a[%d/11] == %d\n", j, getValue(a,11,j));
}

Answer 2

我找到的另一种方法＆＃34;有趣＆＃34;正在分配一个字符数组并对一个符合最大值的类型进行强制转换。像这样：

NumBytesMaxValue = ...;
void* pointers = malloc(NumBytesMaxValue * NumValues);

if (NumBytesMaxValue == 1)
  cast_pointer_to_char_and_fill_it();
else if (NumBytesMaxValue == 2)
  cast_pointer_to_short_and_fill_it();
...

Answer 3

数据压缩是一个广泛的主题，一个活跃的研究领域...... 压缩您的数据可以通过多种不同的方式完成，以使其脱离主题。

但是，可以通过实用程序或初步阶段来查找阵列的最小类型：

#include <limits.h>
#include <stdio.h>

int main() {
    int input_array[] = { 1, 2, 2, 3, 4, 1, 2, 4, 6, 1255, 1, 2, 5, 1233 };
    size_t i, count = sizeof(input_array) / sizeof(input_array[0]);
    int min, max;
    int nc = 0;
    min = max = input_array[0];
    for (i = 1; i < count; i++) {
        if (min > input_array[i]) min = intput_array[i];
        if (max < input_array[i]) max = intput_array[i];
    }
    printf("min value is %d, max value is %d\n", min, max);
    if (min >= SCHAR_MIN && max <= SCHAR_MAX)
        nc += printf("type signed char is appropriate\n");
    if (min >= 0 && max <= UCHAR_MAX)
        nc += printf("type unsigned char is appropriate\n");
    if (min >= SHRT_MIN && max <= SHRT_MAX)
        nc += printf("type short is appropriate\n");
    if (min >= 0 && max <= USHRT_MAX)
        nc += printf("type unsigned short is appropriate\n");
    if (nc == 0)
        printf("no type smaller than int is appropriate\n");
    return 0;
}

对于编译时未知值的一组数字，您可以使用相同的方法：

从分配的小型数组开始，例如signed char。
读取下一个值：如果它适合当前类型，则将其添加到数组并继续。
如果没有，则分配更大类型的数组，例如short，将目前为止解析的值复制到其中，释放前一个数组，存储新值并继续。
如果新值不适合short，请使用较大的类型，例如int。
您可以为更大的类型编写代码，例如long和long long，但您需要针对每种类型的特定代码。
在读取阶段结束时，您有一个处理数据集中所有值的最小类型的数组。使用特定类型的代码处理此数组。这意味着您必须复制每种类型的处理代码，这可能很棘手。

如何将32位数组元素压缩为最小的所需位元素？

3 个答案: