用 c 语言写输入由多行组成，每行都是一个正确的逻辑表达式。 逻辑表达式小于100个字符。 一个正确的逻辑表达式可以包含小写字母，空格和逻辑联结词（含括号）。单个小写字母表示一个逻辑变量，一个表达式中逻辑变量的个数不超过10。空格作为分隔符, 不是词，同一个词的字符之间不能有空格。每一个逻辑表达式产生如下的输出： 第一行按顺序输出表达式中的所有词。每个词之间用空格分开。 第二行按字母序输出表达式中的所有逻辑变量，用空格分开。 第三行开始输出逻辑变量值的所有组合情况。

好的，以下是使用C语言编写的程序示例：

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

// 定义获取词的函数
void get_words(char *expression, char **words, int *num_words) {
    char *word = strtok(expression, " ");
    int i = 0;
    while (word != NULL) {
        words[i++] = word;
        word = strtok(NULL, " ");
    }
    *num_words = i;
}

// 定义获取逻辑变量的函数
void get_variables(char *expression, char **variables, int *num_variables) {
    int i = 0;
    for (int j = 0; j < strlen(expression); j++) {
        if (expression[j] >= 'a' && expression[j] <= 'z') {
            char *variable = (char *) malloc(sizeof(char));
            variable[0] = expression[j];
            int k;
            for (k = 0; k < i; k++) {
                if (strcmp(variable, variables[k]) < 0) {
                    break;
                }
            }
            for (int l = i; l > k; l--) {
                variables[l] = variables[l - 1];
            }
            variables[k] = variable;
            i++;
        }
    }
    *num_variables = i;
}

// 获取所有逻辑变量的组合情况
void get_combinations(char **variables, int num_variables, char **combinations, int *num_combinations) {
    int num_bits = ceil(log2(pow(2, num_variables)));
    int num_combinations_temp = pow(2, num_variables);
    for (int i = 0; i < num_combinations_temp; i++) {
        combinations[i] = (char *) malloc(num_variables + 1);
        for (int j = 0; j < num_variables; j++) {
            int bit = (i >> (num_variables - j - 1)) & 1;
            combinations[i][j] = '0' + bit;
        }
        combinations[i][num_variables] = '\0';
    }
    *num_combinations = num_combinations_temp;
}

// 定义计算逻辑表达式值的函数
int evaluate_expression(char *expression, char **variables, char *combination) {
    int result = 0;
    int length = strlen(expression);
    char expression_copy[length + 1];
    strcpy(expression_copy, expression);
    for (int i = 0; i < length; i++) {
        if (expression_copy[i] >= 'a' && expression_copy[i] <= 'z') {
            char *variable = (char *) malloc(sizeof(char));
            variable[0] = expression_copy[i];
            int index = -1;
            for (int j = 0; j < strlen(combination); j++) {
                if (variables[j][0] == expression_copy[i]) {
                    index = j;
                    break;
                }
            }
            if (index >= 0) {
                expression_copy[i] = combination[index];
            }
        }
    }
    int num_tokens;
    char *tokens[100];
    char *token = strtok(expression_copy, " ");
    int i = 0;
    while (token != NULL) {
        tokens[i++] = token;
        token = strtok(NULL, " ");
    }
    num_tokens = i;
    for (int i = 0; i < num_tokens; i++) {
        if (tokens[i][0] == '(') {
            int j = i + 1;
            int counter = 1;
            while (counter > 0) {
                if (tokens[j][0] == '(') {
                    counter++;
                } else if (tokens[j][0] == ')') {
                    counter--;
                }
                j++;
            }
            char *subexpression = (char *) malloc((j - i) * sizeof(char));
            for (int k = i + 1; k < j - 1; k++) {
                subexpression[k - i - 1] = tokens[k][0];
            }
            subexpression[j - i - 2] = '\0';
            int subresult = evaluate_expression(subexpression, variables, combination);
            char subresult_str[2];
            sprintf(subresult_str, "%d", subresult);
            tokens[i] = subresult_str;
            for (int k = i + 1; k < j; k++) {
                tokens[k] = " ";
            }
            i = j - 1;
            free(subexpression);
        }
    }
    for (int i = 0; i < num_tokens; i++) {
        if (tokens[i][0] == '!') {
            int operand = atoi(tokens[i + 1]);
            int result_temp = !operand;
            char result_str[2];
            sprintf(result_str, "%d", result_temp);
            tokens[i] = result_str;
            tokens[i + 1] = " ";
        }
    }
    for (int i = 0; i < num_tokens; i++) {
        if (tokens[i][0] == '&') {
            int operand1 = atoi(tokens[i - 1]);
            int operand2 = atoi(tokens[i + 1]);
            int result_temp = operand1 && operand2;
            char result_str[2];
            sprintf(result_str, "%d", result_temp);
            tokens[i - 1] = result_str;
            tokens[i] = " ";
            tokens[i + 1] = " ";
        } else if (tokens[i][0] == '|') {
            int operand1 = atoi(tokens[i - 1]);
            int operand2 = atoi(tokens[i + 1]);
            int result_temp = operand1 || operand2;
            char result_str[2];
            sprintf(result_str, "%d", result_temp);
            tokens[i - 1] = result_str;
            tokens[i] = " ";
            tokens[i + 1] = " ";
        }
    }
    result = atoi(tokens[0]);
    return result;
}

// 主函数
int main() {
    char expressions[100][100];
    int num_expressions = 0;
    while (1) {
        fgets(expressions[num_expressions], 100, stdin);
        if (expressions[num_expressions][0] == '\n') {
            break;
        }
        expressions[num_expressions][strlen(expressions[num_expressions]) - 1] = '\0';
        num_expressions++;
    }
    for (int i = 0; i < num_expressions; i++) {
        char *words[100];
        int num_words;
        get_words(expressions[i], words, &num_words);
        for (int j = 0; j < num_words; j++) {
            printf("%s ", words[j]);
        }
        printf("\n");
        char *variables[10];
        int num_variables;
        get_variables(expressions[i], variables, &num_variables);
        for (int j = 0; j < num_variables; j++) {
            printf("%s ", variables[j]);
        }
        printf("\n");
        char *combinations[1024];
        int num_combinations;
        get_combinations(variables, num_variables, combinations, &num_combinations);
        for (int j = 0; j < num_combinations; j++) {
            for (int k = 0; k < num_variables; k++) {
                printf("%c ", combinations[j][k]);
            }
            int result = evaluate_expression(expressions[i], variables, combinations[j]);
            printf("%d\n", result);
        }
    }
    return 0;
}

这个程序假设您会按照题目要求逐行输入多个逻辑表达式，并在末尾输入一个空行以结束输入。对于每个逻辑表达式，它首先获取表达式中的所有词和逻辑变量，然后获取所有逻辑变量的组合情况，最后对于每个组合情况，它将表达式中的逻辑变量替换为组合情况中对应的值，并计算表达式的值。它输出表达式中的所有词、逻辑变量和每个逻辑变量值的组合情况及其结果。注意，这个程序没有对输入进行任何错误检查，因此需要您自己确保输入的正确性。