Why C dosen't split correctly arrays?

• output[i * 8 + j] = input[IP[i][j] - 1]; is gibberish.
• Strings in C are null terminated but you never allocate space for a null terminator anywhere, nor do you null terminate your strings.
• Don't use global variables.

I was able to salvage your program like this:

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

char *start_inital_permutation(const char *input) {
    size_t count=0;
    char *output = malloc(64 * sizeof(char) + 1);
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            output[i * 8 + j] = input[count++];
        }
    }
    output[64] = '\0';
    return output;
}

int main()
{
    const char input[] = "1100110000000000110011001111111111110000101010101111000010101010";
    char *IP_M = start_inital_permutation(input);
    char L[32+1]; // left part
    char R[32+1]; // right part
    for (int i = 0; i < 32; i++) {
        L[i] = IP_M[i];
        R[i] = IP_M[i + 32];
    }
    L[32] = '\0';
    R[32] = '\0';

    printf("IP_M: %s\n", IP_M);
    printf("L:    %s\n", L);
    printf("R:    %s\n", R);
}

However, there's no apparent reason why you need to do the middle step with the 64 characters array. You could as well put that one in a union and save the copy (although then the individual left/right strings won't be null terminated). Example:

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

typedef union
{
  char data [64+1];
  struct
  {
    char left[32];
    char right[32];
    char zero;
  };
} ip_t;

ip_t *start_inital_permutation(const char *input) {
    size_t count=0;
    ip_t* obj = malloc(sizeof(ip_t));
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            obj->data[i * 8 + j] = input[count++];
        }
    }
    obj->data[64] = '\0';
    return obj;
}

int main()
{
    const char input[] = "1100110000000000110011001111111111110000101010101111000010101010";
    ip_t *IP_M = start_inital_permutation(input);

    printf("IP_M: %s\n", IP_M->data);
    printf("L:    %.32s\n", IP_M->left);
    printf("R:    %.32s\n", IP_M->right);
}

Using printf with "%s" assumes the value is a zero terminated string (AKA NULL terminated string).
I.e. a pointer to a sequence of chars, ending with a \0 char.

In your case when printf attempts to print L it prints char, and after the 32 chars that belong to L it continues. It happened to be that R is following L in memory, and so the content of R is also dumped. If the next byte in memory following R was not a 0, you would see even more characters printed. This behavior is dependent on the [possibly atrbitarary] content of your memory.

How to handle the issue (2 ways):

1. You can either increase the size of L and R to 33, and assign the last char to \0:

char L[33]; // left part
char R[33]; // right part
/* ... */
L[32] = '\0';
R[32] = '\0';

2. Or specify to printf the length of the strings (32) like this:

/*----------vvv-------*/ 
printf("L: %.32s\n", L);
printf("R: %.32s\n", R);

In the later case keep in mind that L and R are not "regular" C strings, which are expected to be zero terminated (at least as far as it concerns common functions like strlen, strcmp etc.).