问题 H: 真值表(Ⅲ)

真值表(Ⅲ)是一种逻辑工具，用于列出逻辑命题的所有可能取值情况。在真值表(Ⅲ)中，每一行表示一种可能的取值情况，每一列表示一个逻辑变量或逻辑运算符，最后一列表示整个逻辑表达式的结果。通过真值表(Ⅲ)的分析，我们可以更好地理解逻辑运算，更加准确地描述和解决问题。真值表(Ⅲ)通常用于验证逻辑表达式的正确性，简化逻辑表达式以及在电路设计和编程中使用。在实际应用中，我们可以通过真值表(Ⅲ)来确定逻辑电路中各个元件的输入和输出关系，也可以通过真值表(Ⅲ)确定程序中各个逻辑语句的执行情况。

相关问题

实验一:真值表c语言实现 实验分值:8分 实验目的: 用c语言or c++实现真值表 实验要

求: 实现一个程序，输入逻辑表达式的变量个数n，输出该逻辑表达式的真值表。

实验过程:

1. 首先需要了解什么是真值表。真值表是一种表格，用于列出逻辑表达式中变量的所有可能取值及其结果。在逻辑表达式中，变量的取值只有 true 或 false 两种情况，因此真值表中每个变量都有两个可能的取值，真或假。如果有 n 个变量，则真值表将有 2^n 行。

2. 程序设计思路：

首先，程序需要读入变量的个数 n，然后根据变量个数 n，生成一个二进制数，表示变量所有可能的取值组合。接着，对每一种可能的取值组合，计算逻辑表达式的结果，并将其输出到真值表中。

3. 程序实现：

以下是一个用 c 语言实现真值表的代码示例：

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

int main()
{
    int n; // 变量个数
    int i, j; // 循环变量
    int m; // 真值表的行数
    int **table; // 真值表
    char str[100]; // 逻辑表达式字符串

    printf("请输入变量个数n：");
    scanf("%d", &n);

    // 计算真值表的行数
    m = pow(2, n);

    // 分配真值表的空间
    table = (int **) malloc(m * sizeof(int *));
    for (i = 0; i < m; i++) {
        table[i] = (int *) malloc(n * sizeof(int));
    }

    // 生成真值表
    for (i = 0; i < m; i++) {
        int k = i;
        for (j = n - 1; j >= 0; j--) {
            table[i][j] = k % 2;
            k = k / 2;
        }
    }

    // 读入逻辑表达式
    printf("请输入逻辑表达式：");
    scanf("%s", str);

    // 输出真值表的表头
    for (i = 0; i < n; i++) {
        printf("%c\t", 'A' + i);
    }
    printf("%s\n", str);

    // 计算逻辑表达式的结果，并输出到真值表中
    for (i = 0; i < m; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", table[i][j]);
        }
        printf("%d\n", eval(str, table[i], n));
    }

    // 释放真值表的空间
    for (i = 0; i < m; i++) {
        free(table[i]);
    }
    free(table);

    return 0;
}

int eval(char *expr, int *vals, int n) {
    int i;
    int result = 0;
    int op1, op2;
    char op;

    for (i = 0; i < strlen(expr); i++) {
        if (expr[i] == ' ') {
            continue;
        } else if (expr[i] >= 'A' && expr[i] < 'A' + n) {
            result = vals[expr[i] - 'A'];
        } else if (expr[i] == '0') {
            result = 0;
        } else if (expr[i] == '1') {
            result = 1;
        } else if (expr[i] == '!') {
            result = !result;
        } else if (expr[i] == '&' || expr[i] == '|') {
            op = expr[i];
        } else if (expr[i] == '(') {
            int j = i + 1, k = 1;
            while (k > 0) {
                if (expr[j] == '(') {
                    k++;
                } else if (expr[j] == ')') {
                    k--;
                }
                j++;
            }
            op1 = eval(expr + i + 1, vals, n);
            i = j - 1;
            if (expr[i + 1] == '!') {
                op1 = !op1;
                i++;
            }
            if (op == '&') {
                result = result && op1;
            } else if (op == '|') {
                result = result || op1;
            } else {
                result = op1;
            }
        }
    }

    return result;
}

在代码中，我们首先读入变量个数 n，然后根据变量个数计算出真值表的行数 m。接着，我们使用动态内存分配的方法，为真值表分配空间。然后，我们使用循环生成真值表，对于每一行，我们使用二进制数的方法，表示变量所有可能的取值组合。接着，我们读入逻辑表达式字符串，并输出真值表的表头。最后，我们使用 eval 函数计算逻辑表达式的结果，并将其输出到真值表中。

4. 实验测试：

以下是一个测试样例：

输入：

请输入变量个数n：2
请输入逻辑表达式：(A&B)|(!A&C)

输出：

A	B	(A&B)|(!A&C)
0	0	1
0	1	0
1	0	0
1	1	1

可以看到，程序成功地输出了真值表，并计算了逻辑表达式的结果。

问题 K: 单词检查(Ⅲ)- Hash表实现 java版本

好的，以下是单词检查(Ⅲ)- Hash表实现的Java版本代码：

import java.util.HashMap;
import java.util.Map;

public class SpellChecker {
    private final Map<String, Integer> dictionary;

    public SpellChecker(String[] words) {
        dictionary = new HashMap<>();
        for (String word : words) {
            dictionary.put(word, 1);
        }
    }

    public boolean check(String word) {
        return dictionary.containsKey(word.toLowerCase());
    }
}

使用方法如下：

public static void main(String[] args) {
    String[] words = {"apple", "banana", "orange", "pear", "peach"};
    SpellChecker spellChecker = new SpellChecker(words);
    System.out.println(spellChecker.check("Apple")); // true
    System.out.println(spellChecker.check("grape")); // false
}

以上代码中，我们使用HashMap作为Hash表的实现。构造函数中将单词列表中的每个单词作为键，值设为1，表示该单词在字典中出现过。在check方法中，我们将要检查的单词转换为小写后作为键来查询HashMap，如果该单词在字典中出现过，则返回true，否则返回false。