how to convert 2D to 1D array in C when int has hexadecimal

Question

I have to change this code of 2D array to 1D array but i am not sure how to do it. Because the values of the 2D arrays are in hexadecimal.

int Sbox[SIZE_A][SIZE_B] = { //two dimensional array
{
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
    0xfe, 0xd7, 0xab, 0x76
}, //*  initializers for row indexed by 0 
{
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf,
    0x9c, 0xa4, 0x72, 0xc0
}, //*  initializers for row indexed by 1
{
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1,
    0x71, 0xd8, 0x31, 0x15
}, //*  initializers for row indexed by 2
{
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
    0xeb, 0x27, 0xb2, 0x75
}, {
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3,
    0x29, 0xe3, 0x2f, 0x84
}, {
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39,
    0x4a, 0x4c, 0x58, 0xcf
}, {
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
    0x50, 0x3c, 0x9f, 0xa8
}, {
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21,
    0x10, 0xff, 0xf3, 0xd2
}, {
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d,
    0x64, 0x5d, 0x19, 0x73
}, {
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
    0xde, 0x5e, 0x0b, 0xdb
}, {
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62,
    0x91, 0x95, 0xe4, 0x79
}, {
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea,
    0x65, 0x7a, 0xae, 0x08
}, {
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
    0x4b, 0xbd, 0x8b, 0x8a
}, {
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9,
    0x86, 0xc1, 0x1d, 0x9e
}, {
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9,
    0xce, 0x55, 0x28, 0xdf
}, {
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
    0xb0, 0x54, 0xbb, 0x16
}
};

I want to parse the exact values 0x63, 0x7c, 0x77, etc into the 1D array. So I thought of changing the int to string first, then read out the string as 0x63, 0x7c, 0x77, etc to the 1D array. Any help on how to do it?

Answer 1

These are my codes. Is it ok?

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

#define SIZE_A 16 //width
#define SIZE_B 16 //heightint Sbox[SIZE_A][SIZE_B] = {     //two dimensional array
{0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
0xfe, 0xd7, 0xab, 0x76}, //*  initializers for row indexed by 0 
{0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf,
0x9c, 0xa4, 0x72, 0xc0}, //*  initializers for row indexed by 1
{0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1,
0x71, 0xd8, 0x31, 0x15}, //*  initializers for row indexed by 2
{0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
0xeb, 0x27, 0xb2, 0x75},
{0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3,
0x29, 0xe3, 0x2f, 0x84},
{0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39,
0x4a, 0x4c, 0x58, 0xcf},
{0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
0x50, 0x3c, 0x9f, 0xa8},
{0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21,
0x10, 0xff, 0xf3, 0xd2},
{0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d,
0x64, 0x5d, 0x19, 0x73},
{0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
0xde, 0x5e, 0x0b, 0xdb},
{0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62,
0x91, 0x95, 0xe4, 0x79},
{0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea,
0x65, 0x7a, 0xae, 0x08},
{0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
0x4b, 0xbd, 0x8b, 0x8a},
{0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9,
0x86, 0xc1, 0x1d, 0x9e},
{0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9,
0xce, 0x55, 0x28, 0xdf},
{0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
0xb0, 0x54, 0xbb, 0x16}
};

int myarray[SIZE_A*SIZE_B]={0};

void print2darray(int Sbox[SIZE_A][SIZE_B])
{
int i,j;

for (i = 0; i < SIZE_A; i++ )
{
    for (j = 0; j < SIZE_B; j++ )
    {
        printf("SBox[%d][%d] = 0x%02X\n",i,j,Sbox[i][j]);
        }
    }

for (i = 0; i < SIZE_A; i++ )
{
    for (j = 0; j < SIZE_B; j++ )
    {
        myarray[i*SIZE_A+j]=Sbox[i][j];
        int value=myarray[i*SIZE_B+j];
        printf("myarray is [%d,%d] = 0x%02X\n",i,j,value);
        }
    }

    return;
}

int main()
{
    print2darray(Sbox);
    return 0;
}

Answer 2

You can use the following code (both row-major and column-major order variants - please see comments in the code):

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

#define A_SIZE 2
#define B_SIZE 3

int main() {
  int values_2d[A_SIZE][B_SIZE] = {{0x12, 0x24, 0x46},{0x13,0x35, 0x57}};
  int values_1d[A_SIZE*B_SIZE]  = {0};
  int i,j;

  for (i = 0; i < A_SIZE; i++) {
    for (j = 0; j < B_SIZE; j++) {
      printf("v[%d,%d]=0x%02X\n", i, j, values_2d[i][j]);
    }
  }
  for (i = 0; i < A_SIZE*B_SIZE; i++) {
    values_1d[i] = values_2d[i/(B_SIZE)][i%B_SIZE]; // <<-- row-major order
    //values_1d[i] = values_2d[i%A_SIZE][i/A_SIZE]; // <<-- column-major order

    printf("values_1d[%d] = %d (0x%02X), values_2d[%d][%d] = %d (0x%02x)\n", 
        i, values_1d[i], values_1d[i], 
        i/B_SIZE, i%B_SIZE, 
        values_2d[i/B_SIZE][i%B_SIZE], values_2d[i/B_SIZE][i%B_SIZE]);
  }
  return 0;
}

Result:

┌─(55:55:55)─(michael@lorry)─(~/tmp/hex)
└─► gcc -o main main.c; ./main
values_1d[0] = 18 (0x12), values_2d[0][0] = 18 (0x12)
values_1d[1] = 36 (0x24), values_2d[0][1] = 36 (0x24)
values_1d[2] = 70 (0x46), values_2d[0][2] = 70 (0x46)
values_1d[3] = 19 (0x13), values_2d[1][0] = 19 (0x13)
values_1d[4] = 53 (0x35), values_2d[1][1] = 53 (0x35)
values_1d[5] = 87 (0x57), values_2d[1][2] = 87 (0x57)

It's is in Row-major order.

Answer 3

Regarding: i am not sure how to do it. Because the values of the 2D arrays are in hexadecimal.

int Sbox[SIZE_A][SIZE_B] = {...

int Sbox is your first clue. Good news, No conversion necessary.

The numbers represented within each of these blocks are just integers, shown in hexidecimal format. Therefore, no conversion (i.e. from hex to int) is necessary, as they are already int. All you have to do is pick one of the approaches (described in another answer) to re-arrange the values.

Answer 4

This should solve your problem, if you want the dimensions changed, switch the outer and inner loop

int array1D[SIZEA * SIZEB];
int index1D = 0;

for(int i = 0; i < SIZEB; ++i)
{
  for(int j = 0; i < SIZEA; ++j)
  {
    array1D[index1D++] = Sbox[j][i];
  }
}

Nishith was faster

Answer 5

You can declare a pointer to int and allocate memory and convert as shown...

int i, j, k=0;
int *ptr = malloc(sizeof(*ptr) * SIZE_A * SIZE_B);

for(i = 0; i< SIZE_A; i++)
    for(j = 0; j< SIZE_B; j++)
    {
        ptr[k++] = Sbox[i][j];
    }

Answer 6

The first thing you got to remember is that hexadecimal is just a way of presenting integer values, they are not stored as hexadecimal in the computer.

The second thing is that if you want to have a single array made out of a matrix, then the size of that single array would be (in your case) SIZE_A * SIZE_B entries big.

Then it's just a question of looping over the matrix, and setting the values in the array.