C语言编写一个程序：输入x。计算输出y=√x

您好，以下是C语言编写的程序，可以实现输入x，计算输出y=√x的功能：

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

int main()
{
double x, y;
printf("请输入x的值：");
scanf("%lf", &x);
y = sqrt(x);
printf("y的值为：%lf\n", y);
return 0;
}

希望能对您有所帮助。

相关问题

用c语言编写(4)编写程序，输入实数x，根据如下公式，计算并输出y值。 x+lnx 1<x<2 2≤x<3 y= '| log1ox3≤x<41+x+x2 其他 (5)编写程序，输入实数x和y,根据如下公式，计算并输出t值。 |x2-y x≥0,y≥0 x +3y x≥0,y<0 x+√y x<0,y≥0 (x3-siny x<0,y<0 (6)编写程序，输入一个字母，若该字母为小写字母，则将其修改为大写字母，输出该字母及其ASCII值。 运行示例，运行时输入“al”。 (7)

以下是题目4、5、6的C语言代码：

(4)

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

int main()
{
    double x, y;
    printf("请输入一个实数x：");
    scanf("%lf", &x);
    if (x > 1 && x < 2) {
        y = x + log(x);
    } else if (x >= 2 && x < 3) {
        y = sqrt(x * x - 1) + x;
    } else if (x >= 3 && x < 4) {
        y = log10(x) + x * x + 1;
    } else {
        y = x;
    }
    printf("y = %lf\n", y);
    return 0;
}

(5)

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

int main()
{
    double x, y, t;
    printf("请输入两个实数x和y：");
    scanf("%lf %lf", &x, &y);
    if (x >= 0 && y >= 0) {
        t = fabs(x * x - y);
    } else if (x >= 0 && y < 0) {
        t = x + 3 * y;
    } else if (x < 0 && y >= 0) {
        t = x + sqrt(y);
    } else {
        t = x * x * x - sin(y);
    }
    printf("t = %lf\n", t);
    return 0;
}

(6)

#include <stdio.h>

int main()
{
    char c;
    printf("请输入一个字母：");
    scanf("%c", &c);
    if (c >= 'a' && c <= 'z') {
        c = c - 'a' + 'A';
    }
    printf("修改后的字母为%c，ASCII值为%d\n", c, c);
    return 0;
}

运行示例：

请输入一个实数x：1.5
y = 2.027726

请输入两个实数x和y：-2.5 4.6
t = -17.413479

请输入一个字母：a
修改后的字母为A，ASCII值为65

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

好的，我可以为您提供一些关于计算器C语言程序编写的基本思路和代码示例。

首先，计算器程序主要涉及到中缀表达式的转换和计算。中缀表达式是我们平时使用的常见表达式，例如“3+4*5”，而计算机更适用于后缀表达式，也称为逆波兰表达式，例如“3 4 5 * +”。

因此，我们需要将输入的中缀表达式转换为后缀表达式，然后再进行计算。中缀表达式转后缀表达式的算法可以使用栈来实现。具体步骤如下：

1. 从左到右遍历中缀表达式的每个数字和符号。
2. 如果是数字，则直接输出。
3. 如果是符号，则判断其优先级与栈顶元素的优先级，如果栈顶元素优先级高，则将栈顶元素弹出并输出，直到栈顶元素优先级低于该符号或者栈为空，然后将该符号压入栈中。
4. 如果是左括号“（”，则直接将其压入栈中。
5. 如果是右括号“）”，则将栈顶元素弹出并输出，直到遇到左括号“（”，将左括号弹出但不输出。
6. 重复以上步骤，直到遍历完中缀表达式。

转换成后缀表达式后，我们可以使用栈来计算。具体步骤如下：

1. 从左到右遍历后缀表达式的每个数字和符号。
2. 如果是数字，则将其压入栈中。
3. 如果是符号，则从栈中弹出两个数字，并根据该符号进行计算，将计算结果压入栈中。
4. 重复以上步骤，直到遍历完后缀表达式。

下面是一个简单的计算器C语言程序示例，仅包含加减乘除和括号的计算：

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

#define MAX_EXPR_LEN 100 // 表达式最大长度

typedef struct {
    double data[MAX_EXPR_LEN]; // 栈数据
    int top; // 栈顶指针
} Stack;

// 初始化栈
void init(Stack *stack) {
    stack->top = -1;
}

// 判断栈是否为空
int is_empty(Stack *stack) {
    return stack->top == -1;
}

// 入栈
void push(Stack *stack, double num) {
    if (stack->top >= MAX_EXPR_LEN - 1) {
        printf("Stack overflow\n");
        exit(1);
    }
    stack->data[++stack->top] = num;
}

// 出栈
double pop(Stack *stack) {
    if (is_empty(stack)) {
        printf("Stack underflow\n");
        exit(1);
    }
    return stack->data[stack->top--];
}

// 获取栈顶元素
double peek(Stack *stack) {
    if (is_empty(stack)) {
        printf("Stack underflow\n");
        exit(1);
    }
    return stack->data[stack->top];
}

// 判断字符是否为操作符
int is_operator(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/';
}

// 获取操作符优先级
int get_priority(char c) {
    if (c == '+' || c == '-') {
        return 1;
    } else if (c == '*' || c == '/') {
        return 2;
    } else {
        return 0;
    }
}

// 中缀表达式转后缀表达式
void infix_to_postfix(char *expr, char *postfix) {
    Stack stack;
    init(&stack);
    int i = 0, j = 0;
    while (expr[i] != '\0') {
        if (isdigit(expr[i])) { // 数字直接输出
            postfix[j++] = expr[i++];
            while (isdigit(expr[i])) {
                postfix[j++] = expr[i++];
            }
            postfix[j++] = ' ';
        } else if (is_operator(expr[i])) { // 操作符
            while (!is_empty(&stack) && is_operator(peek(&stack)) && get_priority(peek(&stack)) >= get_priority(expr[i])) {
                postfix[j++] = pop(&stack);
                postfix[j++] = ' ';
            }
            push(&stack, expr[i++]);
        } else if (expr[i] == '(') { // 左括号
            push(&stack, expr[i++]);
        } else if (expr[i] == ')') { // 右括号
            while (peek(&stack) != '(') {
                postfix[j++] = pop(&stack);
                postfix[j++] = ' ';
            }
            pop(&stack);
            i++;
        } else {
            i++;
        }
    }
    while (!is_empty(&stack)) { // 将栈中剩余的操作符输出
        postfix[j++] = pop(&stack);
        postfix[j++] = ' ';
    }
    postfix[j] = '\0'; // 字符串结尾符
}

// 计算后缀表达式
double evaluate_postfix(char *postfix) {
    Stack stack;
    init(&stack);
    int i = 0;
    while (postfix[i] != '\0') {
        if (isdigit(postfix[i])) { // 数字直接入栈
            double num = 0;
            while (isdigit(postfix[i])) {
                num = num * 10 + (postfix[i] - '0');
                i++;
            }
            push(&stack, num);
        } else if (is_operator(postfix[i])) { // 操作符
            double num2 = pop(&stack);
            double num1 = pop(&stack);
            switch (postfix[i]) {
                case '+': push(&stack, num1 + num2); break;
                case '-': push(&stack, num1 - num2); break;
                case '*': push(&stack, num1 * num2); break;
                case '/': push(&stack, num1 / num2); break;
            }
            i++;
        } else {
            i++;
        }
    }
    return pop(&stack); // 最终结果为栈中唯一元素
}

int main() {
    char expr[MAX_EXPR_LEN], postfix[MAX_EXPR_LEN];
    printf("Enter an expression:\n");
    fgets(expr, MAX_EXPR_LEN, stdin);
    infix_to_postfix(expr, postfix);
    printf("Postfix expression: %s\n", postfix);
    printf("Result: %f\n", evaluate_postfix(postfix));
    return 0;
}

该程序使用了两个栈，一个用于中缀表达式转后缀表达式，另一个用于计算后缀表达式。在计算过程中，使用了C语言中的标准库函数isdigit来判断字符是否为数字，可以通过判断ASCII码值来实现。

选做部分的仿真界面可以使用图形库或者控制台输出来实现，具体方法可以根据个人喜好进行选择。