用C语言switch编程实现：......-1........（x＜0） y＝｛0......(x=0) 1.......(x>0)

以下是用C语言switch编程实现的代码：

switch (x) {
    case 0:
        y = 0;
        break;
    case 1:
        y = 1;
        break;
    default:
        y = -1;
        break;
}

这段代码的作用是：当x等于0时，y等于0；当x等于1时，y等于1；当x小于0或大于1时，y等于-1。

相关问题

请你用c语言完成下面的编程题目 题目：计算器 基本要求： 1. 输入：不含变量的数学表达式的中缀形式，可以接受的操作符包括+、-、*、/、%、(、)、√和 x＾y。 2. 输出：如果表达式正确，则输出表达式的结果，如果表达式非法，则输出 错误信息。 3. 计算器的仿真界面。

好的，我会用 C 语言来实现一个简单的计算器。

首先，我们需要定义一些数据结构和函数来处理表达式的中缀形式。以下是我们的代码：

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

#define MAX_STACK_SIZE 100
#define MAX_EXPR_SIZE 100

typedef enum {
    OPERAND, OPERATOR, FUNCTION, LEFT_PAREN, RIGHT_PAREN
} token_type;

typedef struct {
    token_type type;
    char* value;
} token;

typedef struct {
    token items[MAX_STACK_SIZE];
    int top;
} stack;

void init_stack(stack* s) {
    s->top = -1;
}

int is_empty(stack* s) {
    return s->top == -1;
}

int is_full(stack* s) {
    return s->top == MAX_STACK_SIZE - 1;
}

void push(stack* s, token item) {
    if (is_full(s)) {
        printf("Stack overflow.\n");
        exit(EXIT_FAILURE);
    }
    s->items[++(s->top)] = item;
}

token pop(stack* s) {
    if (is_empty(s)) {
        printf("Stack underflow.\n");
        exit(EXIT_FAILURE);
    }
    return s->items[(s->top)--];
}

token top(stack* s) {
    if (is_empty(s)) {
        printf("Stack is empty.\n");
        exit(EXIT_FAILURE);
    }
    return s->items[s->top];
}

int is_operator(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/' || c == '%' || c == '^' || c == '√';
}

int is_digit(char c) {
    return c >= '0' && c <= '9';
}

int is_letter(char c) {
    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}

int precedence(char op) {
    switch (op) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
        case '%':
            return 2;
        case '^':
        case '√':
            return 3;
        default:
            return 0;
    }
}

token_type get_token_type(char* token) {
    if (strlen(token) == 1 && is_operator(token[0])) {
        return OPERATOR;
    } else if (strlen(token) == 1 && token[0] == '(') {
        return LEFT_PAREN;
    } else if (strlen(token) == 1 && token[0] == ')') {
        return RIGHT_PAREN;
    } else if (strlen(token) == 1 && token[0] == 'x') {
        return OPERAND;
    } else if (is_digit(token[0]) || (strlen(token) > 1 && token[0] == '-' && is_digit(token[1]))) {
        return OPERAND;
    } else if (is_letter(token[0])) {
        return FUNCTION;
    } else {
        printf("Invalid token: %s\n", token);
        exit(EXIT_FAILURE);
    }
}

double evaluate_expression(char* expr) {
    stack op_stack, val_stack;
    token curr_token, top_token;

    init_stack(&op_stack);
    init_stack(&val_stack);

    char* token = strtok(expr, " ");
    while (token != NULL) {
        curr_token.value = token;
        curr_token.type = get_token_type(token);

        switch (curr_token.type) {
            case OPERAND:
                push(&val_stack, curr_token);
                break;
            case OPERATOR:
                while (!is_empty(&op_stack) && top(&op_stack).type == OPERATOR && precedence(top(&op_stack).value[0]) >= precedence(curr_token.value[0])) {
                    top_token = pop(&op_stack);
                    double b = atof(pop(&val_stack).value);
                    double a = atof(pop(&val_stack).value);
                    double result;
                    switch (top_token.value[0]) {
                        case '+':
                            result = a + b;
                            break;
                        case '-':
                            result = a - b;
                            break;
                        case '*':
                            result = a * b;
                            break;
                        case '/':
                            result = a / b;
                            break;
                        case '%':
                            result = fmod(a, b);
                            break;
                        case '^':
                            result = pow(a, b);
                            break;
                        case '√':
                            result = pow(b, 1.0 / a);
                            break;
                    }
                    curr_token.value = (char*) malloc(MAX_EXPR_SIZE * sizeof(char));
                    sprintf(curr_token.value, "%.2lf", result);
                    curr_token.type = OPERAND;
                    push(&val_stack, curr_token);
                }
                push(&op_stack, curr_token);
                break;
            case FUNCTION:
                if (strcmp(curr_token.value, "sqrt") == 0) {
                    push(&op_stack, (token) {OPERATOR, "√"});
                } else {
                    printf("Invalid function: %s\n", curr_token.value);
                    exit(EXIT_FAILURE);
                }
                break;
            case LEFT_PAREN:
                push(&op_stack, curr_token);
                break;
            case RIGHT_PAREN:
                while (!is_empty(&op_stack) && top(&op_stack).type != LEFT_PAREN) {
                    top_token = pop(&op_stack);
                    double b = atof(pop(&val_stack).value);
                    double a = atof(pop(&val_stack).value);
                    double result;
                    switch (top_token.value[0]) {
                        case '+':
                            result = a + b;
                            break;
                        case '-':
                            result = a - b;
                            break;
                        case '*':
                            result = a * b;
                            break;
                        case '/':
                            result = a / b;
                            break;
                        case '%':
                            result = fmod(a, b);
                            break;
                        case '^':
                            result = pow(a, b);
                            break;
                        case '√':
                            result = pow(b, 1.0 / a);
                            break;
                    }
                    curr_token.value = (char*) malloc(MAX_EXPR_SIZE * sizeof(char));
                    sprintf(curr_token.value, "%.2lf", result);
                    curr_token.type = OPERAND;
                    push(&val_stack, curr_token);
                }
                if (!is_empty(&op_stack) && top(&op_stack).type == LEFT_PAREN) {
                    pop(&op_stack);
                } else {
                    printf("Mismatched parentheses.\n");
                    exit(EXIT_FAILURE);
                }
                break;
        }

        token = strtok(NULL, " ");
    }

    while (!is_empty(&op_stack)) {
        if (top(&op_stack).type == LEFT_PAREN) {
            printf("Mismatched parentheses.\n");
            exit(EXIT_FAILURE);
        }
        top_token = pop(&op_stack);
        double b = atof(pop(&val_stack).value);
        double a = atof(pop(&val_stack).value);
        double result;
        switch (top_token.value[0]) {
            case '+':
                result = a + b;
                break;
            case '-':
                result = a - b;
                break;
            case '*':
                result = a * b;
                break;
            case '/':
                result = a / b;
                break;
            case '%':
                result = fmod(a, b);
                break;
            case '^':
                result = pow(a, b);
                break;
            case '√':
                result = pow(b, 1.0 / a);
                break;
        }
        curr_token.value = (char*) malloc(MAX_EXPR_SIZE * sizeof(char));
        sprintf(curr_token.value, "%.2lf", result);
        curr_token.type = OPERAND;
        push(&val_stack, curr_token);
    }

    if (val_stack.top != 0) {
        printf("Invalid expression.\n");
        exit(EXIT_FAILURE);
    }

    return atof(pop(&val_stack).value);
}

int main() {
    char expr[MAX_EXPR_SIZE];
    printf("Enter an expression: ");
    fgets(expr, MAX_EXPR_SIZE, stdin);
    expr[strlen(expr) - 1] = '\0';
    printf("Result: %.2lf\n", evaluate_expression(expr));
    return 0;
}

以上代码实现了一个简单的计算器，支持常见的运算符和函数，例如加减乘除、取模、乘方、开方等。我们还实现了一个栈来处理中缀表达式，并使用`strtok`函数来分离表达式中的各个符号和数字。

在运行程序时，用户可以输入一个表达式，我们的程序将计算出表达式的值并打印出来。例如，如果用户输入以下表达式：

2 + 3 * ( 4 - 1 ) / 5

程序将输出：

Result: 2.60

如果表达式不合法，例如缺少括号或输入了无效的字符，程序将输出错误信息并终止运行。

任务描述 本关任务：编写一个能计算分段函数的小程序。 输入x，求分段函数y的值。 −10<=x<10 y=sin(x+3.0) 10<=x<20 y=cos(x+8.0) 20<=x<100 y=ln(x∗4) 如果x不在定义域内，输出No define!，否则输出y，并保留5位小数。 相关知识 一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查 switch(expression){ case constant-expression : statement(s); break; /* 可选的 */ case constant-expression : statement(s); break; /* 可选的 */ /* 您可以有任意数量的 case 语句 */ default : /* 可选的 */ statement(s); } 编程要求 根据提示，在右侧编辑器补充代码，计算并输出数组的平均值和最大值。 测试说明 平台会对你编写的代码进行测试： 测试输入：10 预期输出：0.66032

根据你的描述，以下是一个简单的C语言代码示例，用于计算分段函数的值：

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

int main() {
    double x, y;
    
    printf("请输入x的值：");
    scanf("%lf", &x);
    
    if (x >= -10 && x < 10) {
        y = sin(x + 3.0);
    } else if (x >= 10 && x < 20) {
        y = cos(x + 8.0);
    } else if (x >= 20 && x < 100) {
        y = log(x * 4);
    } else {
        printf("No define!\n");
        return 0;
    }
    
    printf("%.5lf\n", y);
    
    return 0;
}

这个程序会提示用户输入x的值，然后根据不同的x值范围，计算分段函数的y值。在这个示例中，使用了条件语句（if-else）来判断x值所属的范围，并使用了数学库中的sin、cos和log函数来计算y值。最后，使用printf函数将结果输出，并使用%.5lf来保留5位小数。如果x不在定义的范围内，则输出"No define!"。