sscanf 字符串并反转字符串

sscanf函数是用来从一个字符串中读取数据并按照指定格式进行转换和格式化的函数。它可以用来提取字符串中的整数、浮点数和字符串等数据类型。而反转字符串可以使用C语言中的strrev函数，它可以将一个字符串反转。使用方法如下：

char str[] = "hello world";
strrev(str);
printf("%s", str); //输出dlrow olleh

如果需要反转一个字符串并存储到另一个字符串中，可以使用strcpy和strrev函数结合使用，如下所示：

char str1[] = "hello world";
char str2[100];
strcpy(str2, str1);
strrev(str2);
printf("%s", str2); //输出dlrow olleh

相关问题

用c语言输入任意给定的左线性文法，转换为等价的有限自动机，并以状态转换图方式输出

好的，以下是一个简单的 C 语言程序，可以将输入的左线性文法转换为等价的有限自动机，并以状态转换图方式输出。需要注意的是，由于左线性文法的特殊性质，转换出的有限自动机可能会比较复杂，因此在实际使用中可能需要进行优化。

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

#define MAX_RULES 100     // 最大产生式数量
#define MAX_LENGTH 100    // 最大符号串长度

// 存储产生式的结构体
struct Rule {
    char left;           // 产生式左部非终结符
    char right[MAX_LENGTH];  // 产生式右部终结符串
};

// 存储状态转换的结构体
struct Transition {
    int from;            // 起始状态
    int to;              // 终止状态
    char input;          // 输入字符
};

int main() {
    struct Rule rules[MAX_RULES];     // 存储所有的产生式
    int num_rules = 0;                // 产生式数量
    char start;                       // 起始非终结符
    int num_states = 0;               // 状态数量
    int accepting_states[MAX_LENGTH]; // 接受状态集合
    int num_accepting_states = 0;     // 接受状态数量
    struct Transition transitions[MAX_RULES * MAX_LENGTH]; // 存储所有的状态转换
    int num_transitions = 0;          // 状态转换数量

    // 读入产生式
    printf("请输入产生式，以空行结束：\n");
    char line[MAX_LENGTH];
    while (fgets(line, MAX_LENGTH, stdin) != NULL && line[0] != '\n') {
        if (num_rules >= MAX_RULES) {
            printf("产生式数量超过最大限制！\n");
            return 1;
        }
        if (sscanf(line, "%c->%s", &rules[num_rules].left, rules[num_rules].right) != 2) {
            printf("无效的产生式格式：%s", line);
            return 1;
        }
        num_rules++;
    }

    // 读入起始非终结符
    printf("请输入起始非终结符：\n");
    if (scanf("%c", &start) != 1) {
        printf("无效的起始非终结符！\n");
        return 1;
    }

    // 构造状态转换图
    for (int i = 0; i < num_rules; i++) {
        // 将产生式右部反转
        int len = strlen(rules[i].right);
        for (int j = 0; j < len / 2; j++) {
            char temp = rules[i].right[j];
            rules[i].right[j] = rules[i].right[len - j - 1];
            rules[i].right[len - j - 1] = temp;
        }

        // 构造状态转换
        int current_state = 0;
        for (int j = 0; j < len; j++) {
            // 查找当前状态是否已存在
            int next_state = -1;
            for (int k = 0; k < num_states; k++) {
                if (transitions[k].from == current_state && transitions[k].input == rules[i].right[j]) {
                    next_state = transitions[k].to;
                    break;
                }
            }
            if (next_state == -1) {
                // 新建转移状态
                next_state = num_states;
                num_states++;
                for (int k = 0; k < num_accepting_states; k++) {
                    if (accepting_states[k] == current_state) {
                        // 如果当前状态是接受状态，则新建的状态也是接受状态
                        accepting_states[num_accepting_states++] = next_state;
                        break;
                    }
                }
            }
            transitions[num_transitions++] = (struct Transition){current_state, next_state, rules[i].right[j]};
            current_state = next_state;
        }
        // 将最终状态设为接受状态
        accepting_states[num_accepting_states++] = current_state;
    }

    // 输出状态转换图
    printf("状态转换图如下：\n");
    printf("状态数量：%d\n", num_states);
    printf("接受状态数量：%d\n", num_accepting_states);
    printf("接受状态：");
    for (int i = 0; i < num_accepting_states; i++) {
        printf("%d ", accepting_states[i]);
    }
    printf("\n");
    printf("状态转换：\n");
    for (int i = 0; i < num_transitions; i++) {
        printf("%d --%c--> %d\n", transitions[i].from, transitions[i].input, transitions[i].to);
    }

    return 0;
}

输入格式为：

产生式1
产生式2
...
产生式n

起始非终结符

其中每个产生式的格式为 `非终结符->终结符串`，终结符串可以包含多个字符。例如，以下是一个左线性文法的示例输入：

S->aS
S->a

起始非终结符为 `S`。程序会输出状态转换图，例如：

状态转换图如下：
状态数量：3
接受状态数量：1
接受状态：2
状态转换：
0 --a--> 1
1 --a--> 2