#include <stdio.h>

/*
    Ideia geral:
    Dado um array de numeros inteiros distintos, devemos dividi-lo em tres conjuntos nao vazios
    com as seguintes propriedades:
      - O produto dos numeros do primeiro conjunto deve ser negativo (< 0).
      - O produto dos numeros do segundo conjunto deve ser positivo (> 0).
      - O produto dos numeros do terceiro conjunto deve ser zero.

    Estrategia:
      1. Separa os numeros em tres categorias: negativos, positivos e zeros.
      2. Seleciona um numero negativo para o primeiro conjunto, garantindo um produto negativo.
      3. Para o segundo conjunto, se houver numeros positivos, adiciona todos eles. Em seguida,
         adiciona os negativos restantes de forma que o total de negativos no conjunto seja par,
         assegurando um produto positivo.
      4. Os numeros restantes (inclusive zeros e, se necessario, um negativo extra) sao colocados
         no terceiro conjunto, garantindo que seu produto seja zero.
*/

// Le recursivamente os elementos do array
void ler_array(int a[], int n, int i) {
    if(i >= n) return;
    scanf("%d", &a[i]);
    ler_array(a, n, i + 1);
}

// Imprime recursivamente os elementos do array
void print_array(int a[], int n, int i) {
    if(i >= n) return;
    printf("%d ", a[i]);
    print_array(a, n, i + 1);
}

// Separa o array a em tres arrays negativos, positivos e zeros
void particiona(int a[], int n, int i, int negs[], int neg_size[], int pos[], int pos_size[], int zeros[], int zero_size[]) {
    if(i >= n) return;
    if(a[i] < 0) {
        negs[neg_size[0]++] = a[i];
    } else if(a[i] > 0) {
        pos[pos_size[0]++] = a[i];
    } else {
        zeros[zero_size[0]++] = a[i];
    }
    particiona(a, n, i + 1, negs, neg_size, pos, pos_size, zeros, zero_size);
}

// Copia recursivamente elementos do array original para destino do indice inicio ate fim
void copia_intervalo(int original[], int inicio, int fim, int destino[], int dest_index[]) {
    if(inicio >= fim) return;
    destino[dest_index[0]++] = original[inicio];
    copia_intervalo(original, inicio + 1, fim, destino, dest_index);
}

int main() {
    int n;
    scanf("%d", &n);
    int a[n];
    ler_array(a, n, 0);

    // Arrays para separar numeros negativos, positivos e zeros
    int negs[105], pos[105], zeros[105];
    int neg_size[1] = {0}, pos_size[1] = {0}, zero_size[1] = {0};
    particiona(a, n, 0, negs, neg_size, pos, pos_size, zeros, zero_size);

    // Arrays para armazenar os conjuntos finais
    int set_neg, set_pos[105], set_zero[105];
    int set_pos_size[1] = {0}, set_zero_size[1] = {0};

    // Primeiro conjunto contem um numero negativo para garantir produto < 0
    set_neg = negs[0];

    // Resto dos negativos apos usar um no primeiro conjunto
    int rem_neg[105];
    int rem_neg_size[1] = {0};
    copia_intervalo(negs, 1, neg_size[0], rem_neg, rem_neg_size);

    if(pos_size[0] > 0) {
        // Segundo conjunto inicia com todos os numeros positivos
        copia_intervalo(pos, 0, pos_size[0], set_pos, set_pos_size);

        // Se quantidade de negativos restantes for par, podem ser adicionados ao segundo conjunto
        if(rem_neg_size[0] % 2 == 0) {
            copia_intervalo(rem_neg, 0, rem_neg_size[0], set_pos, set_pos_size);
        } else {
            // Se for impar, adiciona todos, exceto o ultimo, no segundo conjunto
            copia_intervalo(rem_neg, 0, rem_neg_size[0] - 1, set_pos, set_pos_size);
            // O ultimo negativo vai para o terceiro conjunto para manter o produto zero
            copia_intervalo(rem_neg, rem_neg_size[0] - 1, rem_neg_size[0], set_zero, set_zero_size);
        }
    } else {
        // Se nao ha numeros positivos, adiciona dois negativos no segundo conjunto
        copia_intervalo(rem_neg, 0, 2, set_pos, set_pos_size);
        // O restante dos negativos vai para o terceiro conjunto
        copia_intervalo(rem_neg, 2, rem_neg_size[0], set_zero, set_zero_size);
    }

    // Adiciona todos os zeros no terceiro conjunto
    copia_intervalo(zeros, 0, zero_size[0], set_zero, set_zero_size);

    printf("1 %d\n", set_neg);

    printf("%d ", set_pos_size[0]);
    print_array(set_pos, set_pos_size[0], 0);
    printf("\n");

    printf("%d ", set_zero_size[0]);
    print_array(set_zero, set_zero_size[0], 0);
    printf("\n");

    return 0;
}