526互联

第一次作业

发布时间 2023-10-14 23:35:20作者: Mhl小马

 

#include<stdio.h>
#include<math.h>
double kaifang(int a)
{
if(a<0){
printf("负数无法开方");
return 65535.0f;
}
double x=1.0f,y=0.0f,k=0.0f;
y=x*x-a;
while(abs(y)>=0.001f){
k=2*x;
x=x-(y*1.0f)/k;
y=x*x-a;
}
return x;
 } 
 
 
 
 int main(){
  printf("请输入一个非负整数");
  int a=0;
  scanf("%d",&a);
  double c=kaifang(a);
  if(c==65535.0f){
  printf("输入有误"); 
 }
 else{
 printf("a的算数平方根是%f和-%f",c,c); 
 }
 return 0;
 }
牛顿迭代法
//牛顿迭代法计算开方
    //牛顿迭代法算开方
    public  double sequareRoot (double n) {
        if(n < 0) {
            return Double.NaN;
        }else {
            double err = 1e-15;
            double root = n;
            while(Math.abs(n - root * root) > err) {
                root = (n/root + root) / 2;
            }
            return root;
        }
    }
#include <stdio.h>
#include <math.h>
// 牛顿迭代法计算平方根
  double sqrt_newton(double x) {
  double guess = x / 2.0; // 初始猜测值为x的一半
  double delta = 0.000001; // 误差范围

  while (fabs(guess * guess - x) > delta)
 {
   guess = (guess + x / guess) / 2.0; // 更新猜测值
 }

return guess;
}

int main() {
int choice;
double num1, num2;

  printf("选择操作：\n");
  printf("1. 加法\n");
  printf("2. 减法\n");
  printf("3. 乘法\n");
  printf("4. 除法\n");
printf("5. 算术开方\n");
printf("请选择：");
scanf("%d", &choice);

switch (choice) {
case 1:
printf("请输入两个数字：");
scanf("%lf %lf", &num1, &num2);
printf("结果：%lf\n", num1 + num2);
break;
case 2:
printf("请输入两个数字：");
scanf("%lf %lf", &num1, &num2);
printf("结果：%lf\n", num1 - num2);
break;
case 3:
printf("请输入两个数字：");
scanf("%lf %lf", &num1, &num2);
printf("结果：%lf\n", num1 * num2);
break;
case 4:
printf("请输入两个数字：");
scanf("%lf %lf", &num1, &num2);
if (num2 != 0) {
printf("结果：%lf\n", num1 / num2);
} else {
printf("除数不能为0！\n");
}
break;
case 5:
printf("请输入一个数字：");
scanf("%lf", &num1);
if (num1 >= 0) {
printf("结果：%lf\n", sqrt_newton(num1));
} else {
printf("输入的数字不能小于0！\n");
}
    break;
    default:
printf("无效的选择！\n");
}

return 0;
}
public String Result(String[] suffix)
    {
         double label=0;
        Stack<String> Result = new Stack<String>();
        for(int i = 0;i < suffix.length; i++) {
                 if ("1234567890.".indexOf(suffix[i].charAt(0))>=0)
                Result.push(suffix[i]);
            else
            {   
double n = 0;
                if (suffix[i].equals("√"))
                {
                    double z = 0;
                    if(Double.parseDouble(Result.peek())>=0)
                    {
                        z = Double.parseDouble(Result.pop());
                        n = sequareRoot(z);
                    }
                    else label = 1;
                }
                else if (suffix[i].equals("-"))
                {　　                    if (i + 1 < suffix.length)
                    {　  　　　　　　　　　　　　　　 
                        if (Result.size()  == 1 || (Result.size() %2 == 0 && ("+-*/".contains(suffix[i + 1]))))
                        {
                            double q = 0;
                            q = Double.parseDouble(Result.pop());
                            n = -q;
                        }//否则 则判断为减号，弹出栈顶两个数相减
                        else
                        {
                            double a = 0, b = 0;
                            a = Double.parseDouble(Result.pop());
                            b = Double.parseDouble(Result.pop());
                            n = b - a;
                        }
                    }//i+1超出数组长度说明当前“-”为最后一个运算符
                    else
                    {
                        if (Result.size() == 1 )
                        {
                            double q = 0;
                            q = Double.parseDouble(Result.pop());
                            n = -q;
                            System.out.println(n);
                        }
                        else {
                            double a = 0, b = 0;
                            a = Double.parseDouble(Result.pop());
                            b = Double.parseDouble(Result.pop());
                            n = b - a;
                        }
                    }
                }//判断为一般运算符 则弹出栈顶两个数字进行双目运算
                else
                {
                    double x, y = 0;
                    x = Double.parseDouble(Result.pop());
                    y = Double.parseDouble(Result.pop());
                    switch (suffix[i]) {
                        case "+":
                            n = x + y;
                            break;
                        case "*":
                            n = x * y;
                            break;
                        case "/":
                            if (x == 0) {                                
label = 1;
                            }
                            n = y / x;
                            break;
                    }
                }
                Result.push(String.valueOf(n));
            }
        }　 
        if(label == 1)
            return "ERROR!";
        return (Result.peek());//返回栈顶的最终结果
    }

//UI设计
class Calculator1 extends JFrame implements ActionListener {
    private JPanel jp_north = new JPanel();
    //JPanel是java图形用户界面GUI工具包swing中的面板容器类，包含在javax.swing包中，可以进行嵌套，功能是对窗体中具有相同逻辑功能组件进行组合
    private JTextField resultText = new JTextField("0"); //创建一个输入框
    private JPanel jp_center = new JPanel();
    private String input = "";

    public Calculator1()  throws HeadlessException{
        this.init();
        this.addNorthComponent();
        this.addCenterComponent();
    }
    //建立计算器界面布局
    public void init() {
        this.setTitle("计算器");//界面名称
        this.setSize(800,800);//界面大小
        this.setLayout(new BorderLayout());//建立布局
        this.setResizable(false); //计算器界面被拉伸
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);//使用system exit方法退出应用程序
    }

    //向顶层容器添加组件
    public void addNorthComponent()
    {
        this.resultText.setPreferredSize(new Dimension(700,150));
        resultText.setHorizontalAlignment(JTextField.RIGHT);;//文本框内容右对齐
        resultText.setEditable(false);//文本框不允许修改结果
        resultText.setFont(new Font("隶书",Font.PLAIN,36));
        jp_north.add(resultText);
        this.add(jp_north,BorderLayout.NORTH);//把顶层界面添加到整体布局的上层
    }

    //向中间层容器添加组件
    public void addCenterComponent()
    {
        String btn_next = "C()/789*456-123+√0.=";//存储中间按钮的所有字符

        this.jp_center.setLayout(new GridLayout(5,4,3,3));//设置中间按钮的行列（5行4列的网格布局）
        this.add(jp_center,BorderLayout.CENTER);//中层布局添加到整体布局的中层
        this.setVisible(true);
         String regex = "[\\+\\-\\*\\/\\√\\(\\)\\.\\=C]";
        for(int i = 0;i < 20;i++)
        {
            String temp = btn_next.substring(i,i+1);
            JButton btn = new JButton();
            btn.setFont(new Font("宋体",Font.BOLD,30));
            btn.addActionListener(this);//每个按钮都注册事件监听器
            btn.setText(temp);
            btn.setBackground(Color.PINK);
            jp_center.add(btn);
            if(temp.matches(regex)) {
               btn.setFont(new Font("粗体",Font.BOLD,30));
               btn.setForeground(Color.RED);
            }
        }
    }
 void input_expression(char* expression, int size) {
char c;
int index = 0;
gotoxy(12, 7);
while (1) {
c = _getch(); // 逐字符读取输入
if (c == '\r' || c == '\n') { // 回车或换行表示输入结束
expression[index] = '\0';
break;
}
else if (c == '\b' && index > 0) { // 处理退格
index--;
gotoxy(25 + index, 7);
printf(" ");
gotoxy(25 + index, 7);
}
else if (isprint(c) && index < size - 1) { // 只接受可打印字符
expression[index++] = c;
printf("%c", c);
}
}
}
void zhuanhuan(char g[], char e[]) {
int i, j;
for (i = 0, j = 0; g[i] != '\0'; i++) {
if (g[i] == '-' && (i == 0 || g[i - 1] == '(')) {
e[j++] = '0';
e[j++] = g[i];
}
e[j] = '\0';
}
int is_operation(char op) {
if (op == '+' || op == '-' || op == '*' || op == '/') {
return 1;
}
return 0;
}
int priority(char op) {
if (op == '+' || op == '-') {
return 1;
}
else if (op == '*' || op == '/') {
return 2;
}
return 0;
}
void postfix(char e[], char f[]) {
int i, j, k;
char stack[100];
int top = -1;
for (i = 0, j = 0; e[i] != '\0'; i++) {
if (isdigit(e[i]) || e[i] == '.') {
f[j++] = e[i];
if (!isdigit(e[i + 1]) && e[i + 1] != '.') {
f[j++] = ' ';
}
}
else if (e[i] == '(') {
stack[++top] = e[i];
}
else if (is_operation(e[i])) {
while (top >= 0 && priority(stack[top]) >= priority(e[i])) {
f[j++] = stack[top--];
}
stack[++top] = e[i];
}
else if (e[i] == ')') {
while (top >= 0 && stack[top] != '(') {
f[j++] = stack[top--];
}
top--; // Pop the left parenthesis
}
}
while (top >= 0) {
f[j++] = stack[top--];
}
f[j] = '\0';
}
double readnum(char f[], int* i) {
double num = 0.0;
double decimal = 0.1;
int is_decimal = 0;
while (isdigit(f[*i]) || f[*i] == '.') {
if (f[*i] == '.') {
is_decimal = 1;
}
else {
if (is_decimal) {
num += (f[*i] - '0') * decimal;
decimal *= 0.1;
}
else {
num = num * 10 + (f[*i] - '0');
}
}
(*i)++;
}
return num;
}
double evalpost(char f[]) {
double stack[100];
int top = -1;
double num1, num2;
for (int i = 0; f[i] != '\0'; i++) {
if (isdigit(f[i]) || f[i] == '.') {
stack[++top] = readnum(f, &i);
}
else if (f[i] == ' ') {
continue;
}
else if (is_operation(f[i])) {
num2 = stack[top--];
num1 = stack[top--];
switch (f[i]) {
case '+':
stack[++top] = num1 + num2;
break;
case '-':
stack[++top] = num1 - num2;
break;
case '*':
stack[++top] = num1 * num2;
break;
case '/':
stack[++top] = num1 / num2;
break;
}
}
}
return stack[top];
}
int is_valid_expression(const char* expression) {
int parentheses_count = 0;
int last_char_is_operator = 0;
for (int i = 0; expression[i] != '\0'; i++) {
if (isdigit(expression[i]) || expression[i] == '.') {
last_char_is_operator = 0;
}
else if (is_operation(expression[i])) {
if (last_char_is_operator) {
return 0;
}
last_char_is_operator = 1;
}
else if (expression[i] == '(') {
parentheses_count++;
last_char_is_operator = 0;
}
else if (expression[i] == ')') {
parentheses_count--;
if (parentheses_count < 0) {
return 0;
}
last_char_is_operator = 0;
}
else {
return 0;
}
}
if (parentheses_count != 0) {
return 0;
}
return 1;
}
void display_ending() {
system("cls");
printf("##########################\n");
printf("# #\n");
printf("# 谢谢使用 #\n");
printf("# #\n");
printf("##########################\n");
}
int main() {
char input_expr[100]; // 用于存储用户输入的表达式
char processed_expression[100]; // 用于存储处理后的表达式（去除空格等）
char postfix_expression[100]; // 用于存储后缀表达式
double result; // 用于存储计算结果
int continue_calculating = 1; // 标志位，用于判断是否继续计算
int user_choice; // 用户选择：继续计算或退出
display_calculator(); // 显示计算器界面
while (continue_calculating) {
input_expression(input_expr, sizeof(input_expr));
if (!is_valid_expression(input_expr)) {
gotoxy(12, 7);
printf("输入不合法，请按回车重新输入\n");
while (getchar() != '\n'); // 等待用户按回车
display_calculator(); // 显示新的计算器界面
continue; // 跳过本次循环的剩余部分
}
zhuanhuan(input_expr, processed_expression);
postfix(processed_expression, postfix_expression);
result = evalpost(postfix_expression);
gotoxy(12 + strlen(input_expr) + 1, 7);
printf(" = %.2f\n", result);
gotoxy(50, 15);
printf("继续计算/退出:1/0: ");
scanf("%d", &user_choice);
while (getchar() != '\n'); // 清空输入缓冲区，防止干扰下次输入
if (user_choice == 0) {
continue_calculating = 0;
}
else {
// 清除输入表达式行
gotoxy(12, 7);
for (int i = 0; i < strlen(input_expr) + 100; i++) {
printf(" ");
}
gotoxy(12, 7);
}
}
display_ending();
system("pause");
return 0;
}