MidiTraC Sequencer

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

#define SEQSIZE 16 /*Pattern Length*/

char* init_Array(char* d, const char* s) {
    char* tmp = d;
    while (*s) {
        *d++ = *s++;
    }
    *d = '\0';
    return tmp;
}

char* append_Array(char* d, const char* s) {
    while (*d) {
        ++d;
    }
    while (*s) {
        *d++ = *s++;
    }
    *d = '\0';
    return d;
}

void euclid(int d[], const int size, const int value) {
    char** tmp = (char**)malloc(size * sizeof(char*));
    for (int i = 0; i < size; ++i) {
        tmp[i] = (char*)malloc((size + 1) * sizeof(char));
    }
    int z = size;
    int p = size;
    int t = size;
    int s = value;
    (p < s) ? (p = s, s = t) : 0;
    t = p - s;
    for (int i = 0; i < size; ++i) {
        (i < s) ? init_Array(tmp[i], "X") : init_Array(tmp[i], "-");
    }
    while (t > 1) {
        (z > 0) ? z-- : 0;
        if (t < s) {
            p = s;
            s = t;
        }
        else {
            p = t;
        }
        t = p - s;
        for (int i = 0; i < s; ++i) {
            append_Array(tmp[i], tmp[z - i]);
        }
        z = p;
    }
    int n = 0;
    for (int i = 0; i < z; ++i) {
        int j = 0;
        while (tmp[i][j] != '\0') {
            d[n++] = (tmp[i][j] == 'X') ? 1 : 0;
            ++j;
        }
    }
    for (int i = 0; i < size; ++i) {
        free(tmp[i]);
    }
    free(tmp);
}

void shift(int d[], const int size, int shift_Value) {
    if (!shift_Value) {
        return;
    }
    (shift_Value < 0) ? (shift_Value += size) : 0;
    int* tmp = (int*)malloc(size * sizeof(int));
    for (int i = 0; i < size; ++i) {
        tmp[(i + shift_Value) % size] = d[i];
    }
    for (int i = 0; i < size; ++i) {
        d[i] = tmp[i];
    }
    free(tmp);
}

void cmp(int d[], const int s[], const int size, const int bool_operator) {
    for (int i = 0; i < size; ++i) {
        switch (bool_operator) {
        case 0:
            d[i] &= s[i];
            d[i] = !d[i];
            break;
        case 1:
            d[i] &= s[i];
            break;
        case 2:
            d[i] |= s[i];
            break;
        case 3:
            d[i] ^= s[i];
            break;
        default:
            break;
        }
    }
}

void print_Seq(const int arr[], const int size) {
    for (int i = 0; i < size; ++i) {
        if (arr[i] == 1) {
            printf(" X ");
        }
        else {
            printf(" - ");
        }
    }
}

int main() {
    /*set random Values*/
    srand(time(NULL));
    int rnd_STEPS_A = rand() % (SEQSIZE - 1) + 1;
    int rnd_STEPS_B = rand() % (SEQSIZE - 1) + 1;
    int rnd_SHIFT_A = rand() % (2 * SEQSIZE - 2) - (SEQSIZE-1);
    int rnd_SHIFT_B = rand() % (2 * SEQSIZE - 2) - (SEQSIZE-1);
    int rnd_SHIFT_C = rand() % (2 * SEQSIZE - 2) - (SEQSIZE-1);
    int rnd_CMP_OPERATOR = rand() % 4;
  
    char op[4];
    if (rnd_CMP_OPERATOR == 0) init_Array(op,"NOT");
    else if (rnd_CMP_OPERATOR == 1) init_Array(op, "AND");
    else if (rnd_CMP_OPERATOR == 2) init_Array(op, "OR");
    else init_Array(op, "XOR");

    /*print Counter*/
    for (int i = 0; i < SEQSIZE; ++i) {
        printf("%02i|", i + 1);
    }
    printf(" | Counter\n");
    for (int i = 0; i < SEQSIZE; ++i) {
        printf("---");
    }
    printf("\n");

    /*init euclidian Sequence*/
    int a[SEQSIZE], b[SEQSIZE];
    euclid(a, SEQSIZE, rnd_STEPS_A);
    euclid(b, SEQSIZE, rnd_STEPS_B);

    /*print Seq_A*/
    print_Seq(a, SEQSIZE);
    printf(" | Seq_A -> %i von %i\n", rnd_STEPS_A, SEQSIZE);

    /*shift Seq_A*/
    shift(a, SEQSIZE, rnd_SHIFT_A);

    /*print shifted Seq_A*/
    print_Seq(a, SEQSIZE);
    printf(" | Seq_A shift -> %i\n", rnd_SHIFT_A);

    printf("\n");

    /*print Seq_B*/
    print_Seq(b, SEQSIZE);
    printf(" | Seq_B -> %i von %i\n", rnd_STEPS_B, SEQSIZE);

    /*shift Seq_B*/
    shift(b, SEQSIZE, rnd_SHIFT_B);

    /*print shifted Seq_B*/
    print_Seq(b, SEQSIZE);
    printf(" | Seq_B shift -> %i\n", rnd_SHIFT_B);
    printf("\n");

    /*print Seq_A / Seq_B*/
    print_Seq(a, SEQSIZE);
    printf(" | Seq_A\n");
    print_Seq(b, SEQSIZE);
    printf(" | Seq_B\n");

    /*compare Seq_A / Seq_B*/
    cmp(a, b, SEQSIZE, rnd_CMP_OPERATOR);

    /*print Result*/
    for (int i = 0; i < SEQSIZE; ++i) {
        printf("---");
    }
    printf("\n");

    print_Seq(a, SEQSIZE);
    printf(" | cmp Seq_A %s Seq_B\n\n",op);

    /*shift Result*/
    shift(a, SEQSIZE, rnd_SHIFT_C);

    /*print Pattern*/
    print_Seq(a, SEQSIZE);
    printf(" | Seq_C shift -> %i\n", rnd_SHIFT_C);
    for (int i = 0; i < SEQSIZE; ++i) {
        printf("===");
    }
    printf("\n");

    return 0;
}