#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <combination.h>
#include <limits.h>		/* for CHAR_BIT */

#define MAX 44
#define BITMASK(b) (1 << ((b) % CHAR_BIT))
#define BITSLOT(b) ((b) / CHAR_BIT)
#define BITSET(a, b) ((a)[BITSLOT(b)] |= BITMASK(b))
#define BITCLEAR(a, b) ((a)[BITSLOT(b)] &= ~BITMASK(b))
#define BITTEST(a, b) ((a)[BITSLOT(b)] & BITMASK(b))
#define BITNSLOTS(nb) ((nb + CHAR_BIT - 1) / CHAR_BIT)

void increment(char* bitarray, int n);
int test_all_zero(char* bitarray, int n);
void one_diag(char** bitarray, int i, int j);
void make_matrix(char** bitarray, char* U_array, int n);
void invert(char* bitarray, int n);
void display(char** bitarray, int n);

main(){
       char bitarray[MAX][BITNSLOTS(MAX)];
       int i,j;
       for (i=0; i<MAX; i++){
           memset(bitarray[i], 0, BITNSLOTS(MAX));
           }
       
       char U_array[BITNSLOTS(MAX*(MAX-1)/2)];
       memset(U_array, 0, BITNSLOTS(MAX*(MAX-1)/2));

       /* TEST CODE START */
       char test_array[BITNSLOTS(45)];
       memset(test_array, 0, BITNSLOTS(45));
       
       char test_matrix[10][BITNSLOTS(10)];
       for (i=0; i<10; i++){
           memset(test_matrix[i], 0, BITNSLOTS(10));
           }
       
       printf("Starting:\n");
       make_matrix(test_matrix, test_array, 10);
       display(test_matrix, 10);
          
       printf("Inverting:\n");
       
       while (test_all_zero(test_array, 45)){
             invert(test_array, 45);
             }
       
       make_matrix(test_matrix, test_array, 10);
       display(test_matrix, 10);
       
       /* TEST CODE END */

       getch();
}

void increment(char* bitarray, int n){
     int i = 0;
     while (i < n){
           if (!BITTEST(bitarray, i)){
              BITSET(bitarray, i);
              i = n;
              }
           else{
                BITCLEAR(bitarray, i);
                i++;
                }
           }
}
                
int test_all_zero(char* bitarray, int n){
    int i;
    int counter = 0;
    for (i=0; i<n; i++){
        if (!BITTEST(bitarray, i)){
           counter++;
           }
        }
    if (counter == n){
       return 1;
       }
    else{
         return 0;
         }
}

void one_diag(char** bitarray, int i, int j){
     if (i == j){
        BITSET(bitarray[i], j);
        }
}

void invert(char* bitarray, int n){
     int i;
     for (i=0; i<n; i++){
         if (BITTEST(bitarray, i)){
            BITCLEAR(bitarray, i);
            }
         else{
              BITSET(bitarray, i);
              }
         }
}

void make_matrix(char** bitarray, char* U_array, int n){
     int i,j,k;
     for (i=0,j=i+1,k=0; k<n; j++,k++){
         if (j > n){
            i++;
            j = i+1;
            }
         if (BITTEST(U_array, k)){
            BITSET(bitarray[i], j);
            BITSET(bitarray[j], i);
            }
         else{
              BITCLEAR(bitarray[i], j);
              BITCLEAR(bitarray[j], i);
              }
         }
}

void display(char** bitarray, int n){
     int i, j;
     for (i=0; i<n; i++){
         for (j=0; j<n; j++){
             if (BITTEST(bitarray[i], j)){
                printf("1");
                }
             else{
                  printf("0");
                  }
             }
         printf("\n");
         }
     printf("\n");
}

int one[10];
int two[10][20];
int three[10][20][30];

void func_one(char one[]) {}
void func_two(char two[][20]) {}
void func_three(char three[][20][30]) {}

func_one(one);
func_two(two);
func_three(three);

#include <stdio.h>

void func(int *array, int x_size, int y_size);

int main() {
    int data[][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };
    
    /* Now data[0][0] = 1
               [0][1] = 2
               [0][2] = 3
               [1][0] = 4
               ...
    */
    
    /* x_size: number of elements in data[x][*] */
    /* y_size: number of elements in data[*][y] */
    size_t x_size = sizeof(data) / sizeof(data[0]);  /* this will be 2 */
    size_t y_size = sizeof(data[0]) / sizeof(data[0][0]);  /* this will be 3 */
    
    func((int *)data, x_size, y_size);
    
    return 0;
}

void func(int *array, int x_size, int y_size) {
    int x, y;
    
    for(y = 0; y < y_size; y ++) {
        for(x = 0; x < x_size; x ++) {
            printf("%d", *(array + (x * y_size) + y));
            if(x + 1 < x_size) putchar(' ');
        }
        putchar('\n');
    }
}

struct list_t {
    struct name_t *name;
    size_t names;
};

struct name_t {
    char *name;
    size_t length;
};

char (*pa) [2]
char pa[][2]

char (*pa) [BITSNSLOT(10)]
char pa[][BITSNSLOT(10)]