用C写一个打印真值表的代码

好的，以下是C语言代码示例，可以打印出指定变量的真值表：

#include <stdio.h>

int main() {
    int var;
    printf("Please enter a variable(0 or 1): ");
    scanf("%d", &var);

    printf("Truth Table:\n");
    printf("-----------\n");
    printf("Input | Output\n");
    printf("------|-------\n");
    printf("  0   |   %d\n", !var);
    printf("  1   |   %d\n", var);

    return 0;
}

希望对你有帮助！

相关问题

用C语言写一段真值表代码

好的，以下是一段简单的真值表代码，用于打印两个布尔变量的所有可能取值的组合和对应的逻辑运算结果：

#include <stdio.h>

int main() {
    int a, b;
    printf("a\tb\ta AND b\ta OR b\ta XOR b\n");
    for (a = 0; a <= 1; a++) {
        for (b = 0; b <= 1; b++) {
            printf("%d\t%d\t%d\t%d\t%d\n", a, b, a && b, a || b, a ^ b);
        }
    }
    return 0;
}

输出结果：

a	b	a AND b	a OR b	a XOR b
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

这个程序使用了嵌套的 for 循环来遍历所有可能的 a 和 b 的取值组合，并计算并打印出对应的逻辑运算结果。其中，&& 表示逻辑与运算（AND），|| 表示逻辑或运算（OR），^ 表示异或运算（XOR）。

你能用c语言写一个构造合式公式的真值表吗

当然可以，下面是一个用C语言实现构造合式公式的真值表的示例代码：

#include <stdio.h>

// 定义布尔类型
typedef enum {
    false,
    true
} bool;

// 定义布尔运算符类型
typedef enum {
    AND,
    OR,
    NOT
} Operator;

// 定义布尔表达式类型
typedef struct {
    bool value;         // 表达式的取值
    bool is_variable;   // 是否是变量
    char variable;      // 变量名
    Operator op;        // 运算符
    struct BooleanExpression* left;  // 左子表达式
    struct BooleanExpression* right; // 右子表达式
} BooleanExpression;

// 创建变量节点
BooleanExpression* createVariable(char variable) {
    BooleanExpression* expr = (BooleanExpression*)malloc(sizeof(BooleanExpression));
    expr->value = false;
    expr->is_variable = true;
    expr->variable = variable;
    return expr;
}

// 创建非运算节点
BooleanExpression* createNot(BooleanExpression* expr) {
    BooleanExpression* not_expr = (BooleanExpression*)malloc(sizeof(BooleanExpression));
    not_expr->value = false;
    not_expr->is_variable = false;
    not_expr->op = NOT;
    not_expr->left = expr;
    not_expr->right = NULL;
    return not_expr;
}

// 创建二元运算节点
BooleanExpression* createBinary(BooleanExpression* left, Operator op, BooleanExpression* right) {
    BooleanExpression* binary_expr = (BooleanExpression*)malloc(sizeof(BooleanExpression));
    binary_expr->value = false;
    binary_expr->is_variable = false;
    binary_expr->op = op;
    binary_expr->left = left;
    binary_expr->right = right;
    return binary_expr;
}

// 计算布尔表达式的取值
bool evaluate(BooleanExpression* expr) {
    if (expr->is_variable) {
        // 变量节点的取值由外部传入
        return expr->value;
    }
    switch (expr->op) {
        case NOT:
            return !evaluate(expr->left);
        case AND:
            return evaluate(expr->left) && evaluate(expr->right);
        case OR:
            return evaluate(expr->left) || evaluate(expr->right);
        default:
            return false;
    }
}

// 打印布尔表达式
void printExpr(BooleanExpression* expr) {
    if (expr->is_variable) {
        printf("%c", expr->variable);
    } else {
        switch (expr->op) {
            case NOT:
                printf("!");
                printExpr(expr->left);
                break;
            case AND:
                printf("(");
                printExpr(expr->left);
                printf(" && ");
                printExpr(expr->right);
                printf(")");
                break;
            case OR:
                printf("(");
                printExpr(expr->left);
                printf(" || ");
                printExpr(expr->right);
                printf(")");
                break;
            default:
                break;
        }
    }
}

// 构造合式公式的真值表
void truthTable(BooleanExpression* expr) {
    // 计算变量个数
    int var_count = 0;
    char var_list[26] = {0};
    for (int i = 0; i < strlen(expr); i++) {
        char ch = expr[i];
        if (ch >= 'a' && ch <= 'z') {
            bool found = false;
            for (int j = 0; j < var_count; j++) {
                if (var_list[j] == ch) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                var_list[var_count++] = ch;
            }
        }
    }
    // 打印表头
    for (int i = 0; i < var_count; i++) {
        printf("%c ", var_list[i]);
    }
    printf("%s\n", expr);
    // 构造真值表
    int row_count = pow(2, var_count);
    for (int i = 0; i < row_count; i++) {
        // 初始化变量节点的取值
        for (int j = 0; j < var_count; j++) {
            BooleanExpression* var_expr = createVariable(var_list[j]);
            var_expr->value = (i & (1 << j)) ? true : false;
        }
        // 计算表达式的取值
        bool result = evaluate(expr);
        // 打印一行真值
        for (int j = 0; j < var_count; j++) {
            printf("%d ", (i & (1 << j)) ? 1 : 0);
        }
        printf("%d\n", result);
    }
}

int main() {
    // 构造布尔表达式
    BooleanExpression* p = createVariable('p');
    BooleanExpression* not_p = createNot(p);
    BooleanExpression* q = createVariable('q');
    BooleanExpression* q_or_not_p = createBinary(q, OR, not_p);
    BooleanExpression* p_and_q_or_not_p = createBinary(p, AND, q_or_not_p);
    // 打印布尔表达式
    printExpr(p_and_q_or_not_p);
    printf("\n");
    // 构造真值表
    truthTable(p_and_q_or_not_p);
    return 0;
}

此代码实现了构造合式公式的真值表的功能，仅供参考。