第七届蓝桥杯部分练习题答案(Java)

第七届蓝桥杯部分练习题答案(Java)

—————————————————————————————————————————————————————
今天闲来无事,把之前在蓝桥杯试题集中做的发给大家参考一下,其中(16进制转8进制非我所做)。欢迎广大博友阅览。如有发现错误,还望指教。不喜勿喷,如果发瑞我写代码的习惯不好,亦可以评论告知我,谢谢大家。
—————————————————————————————————————————————————————

圆的面积

问题描述
给定圆的半径r,求圆的面积。
输入格式
输入包含一个整数r,表示圆的半径。
输出格式
输出一行,包含一个实数,四舍五入保留小数点后7位,表示圆的面积。
样例输入
4
样例输出
50.2654825
数据规模与约定
1 <= r <= 10000。
提示
本题对精度要求较高,请注意π的值应该取较精确的值。你可以使用常量来表示π,比如PI=3.14159265358979323,也可以使用数学公式来求π,比如PI=atan(1.0)*4。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        double m = mianji(n);
        System.out.printf("%.7f\n", m);
    }

    public static double mianji(int x) {
        double m = (double) (Math.PI * x * x);
        return m;
    }

}

Fibonacci数列

问题描述
Fibonacci数列的递推公式为:Fn=Fn-1+Fn-2,其中F1=F2=1。
当n比较大时,Fn也非常大,现在我们想知道,Fn除以10007的余数是多少。
输入格式
输入包含一个整数n。
输出格式
输出一行,包含一个整数,表示Fn除以10007的余数。
说明:在本题中,答案是要求Fn除以10007的余数,因此我们只要能算出这个余数即可,而不需要先计算出Fn的准确值,再将计算的结果除以10007取余数,直接计算余数往往比先算出原数再取余简单。
样例输入
10
样例输出
55
样例输入
22
样例输出
7704
数据规模与约定
1 <= n <= 1,000,000。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        int[] x = new int[1000000];
        for (int i = 0; i < x.length; i++) {
            if (i == 0 || i == 1)
                x[i] = 1;
            else
                x[i] = (x[i - 1] + x[i - 2]) % 10007;
        }
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        System.out.println(x[n - 1]);
    }
}

闰年判断

问题描述
给定一个年份,判断这一年是不是闰年。
当以下情况之一满足时,这一年是闰年:
1. 年份是4的倍数而不是100的倍数;
2. 年份是400的倍数。
其他的年份都不是闰年。
输入格式
输入包含一个整数y,表示当前的年份。
输出格式
输出一行,如果给定的年份是闰年,则输出yes,否则输出no。
样例输入
2013
样例输出
no
样例输入
2016
样例输出
yes
数据规模与约定
1990 <= y <= 2050。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int y = in.nextInt();
        if (y % 400 == 0 || (y % 100 != 0 && y % 4 == 0)) {
            System.out.println("yes");
        } else {
            System.out.println("no");
        }
    }
}

01字串

问题描述
对于长度为5位的一个01串,每一位都可能是0或1,一共有32种可能。它们的前几个是:
00000
00001
00010
00011
00100
请按从小到大的顺序输出这32种01串。
输出格式
输出32行,按从小到大的顺序每行一个长度为5的01串。
样例输出
00000
00001
00010
00011
<以下部分省略>

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 32; i++) {
            String s = "";
            if (i < 2) {
                System.out.println("0000" + Integer.toBinaryString(i));
            } else if (i < 4) {
                System.out.println("000" + Integer.toBinaryString(i));
            } else if (i < 8) {
                System.out.println("00" + Integer.toBinaryString(i));
            } else if (i < 16) {
                System.out.println("0" + Integer.toBinaryString(i));
            } else {
                System.out.println(Integer.toBinaryString(i));
            }
        }
    }
}

字母图形

问题描述
利用字母可以组成一些美丽的图形,下面给出了一个例子:
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形,请找出这个图形的规律,并输出一个n行m列的图形。
输入格式
输入一行,包含两个整数n和m,分别表示你要输出的图形的行数的列数。
输出格式
输出n行,每个m个字符,为你的图形。
样例输入
5 7
样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
数据规模与约定
1 <= n, m <= 26。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] a = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                int abs = Math.abs(j - i);
                char x = (char) ('A' + abs);
                System.out.print(x);
            }
            System.out.println();
        }
    }
}

数列特征

问题描述
给出n个数,找出这n个数的最大值,最小值,和。
输入格式
第一行为整数n,表示数的个数。
第二行有n个数,为给定的n个数,每个数的绝对值都小于10000。
输出格式
输出三行,每行一个整数。第一行表示这些数中的最大值,第二行表示这些数中的最小值,第三行表示这些数的和。
样例输入
5
1 3 -2 4 5
样例输出
5
-2
3
数据规模与约定
1 <= n <= 10000。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE, sum = 0, n = in.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = in.nextInt();
        }
        for (int i = 0; i < a.length; i++) {
            if (min > a[i]) {
                min = a[i];
            }
            if (max < a[i]) {
                max = a[i];
            }
            sum += a[i];
        }
        System.out.println(max);
        System.out.println(min);
        System.out.println(sum);
    }
}

查找整数

问题描述
给出一个包含n个整数的数列,问整数a在数列中的第一次出现是第几个。
输入格式
第一行包含一个整数n。
第二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。
第三行包含一个整数a,为待查找的数。
输出格式
如果a在数列中出现了,输出它第一次出现的位置(位置从1开始编号),否则输出-1。
样例输入
6
1 9 4 8 3 9
9
样例输出
2
数据规模与约定
1 <= n <= 1000。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = in.nextInt();
        }
        int x = in.nextInt();
        for (int i = 0; i < a.length; i++) {
            if (a[i] == x) {
                System.out.println(i + 1);
                return;
            }
        }
        System.out.println(-1);
    }
}

杨辉三角形

问题描述
杨辉三角形又称Pascal三角形,它的第i+1行是(a+b)i的展开式的系数。它的一个重要性质是:三角形中的每个数字等于它两肩上的数字相加。下面给出了杨辉三角形的前4行:
1
1 1
1 2 1
1 3 3 1
给出n,输出它的前n行。
输入格式
输入包含一个数n。
输出格式
输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出,中间使用一个空格分隔。请不要在前面输出多余的空格。
样例输入
4
样例输出
1
1 1
1 2 1
1 3 3 1
数据规模与约定
1 <= n <= 34。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[][] a = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (j == 0 || j == i) {
                    a[i][j] = 1;
                } else if (j > 0 && j < i) {
                    a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
                } else {
                    a[i][j] = 0;
                }
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (a[i][j] != 0) {
                    System.out.print(a[i][j]);
                    if (j < i) {
                        System.out.print(" ");
                    }
                }
            }
            System.out.println();
        }
    }
}

特殊的数字

问题描述
  153是一个非常特殊的数,它等于它的每位数字的立方和,即153=1*1*1+5*5*5+3*3*3。编程求所有满足这种条件的三位十进制数。
输出格式
  按从小到大的顺序输出满足条件的三位十进制数,每个数占一行。

public class Main {
    public static void main(String[] args) {
        for (int i = 100; i <= 999; i++) {
            int n1 = i / 100;
            int n2 = (i % 100) / 10;
            int n3 = i % 10;
            if (n1 * n1 * n1 + n2 * n2 * n2 + n3 * n3 * n3 == i) {
                System.out.println(i);
            }
        }
    }
}

回文数

问题描述
  1221是一个非常特殊的数,它从左边读和从右边读是一样的,编程求所有这样的四位十进制数。
输出格式
  按从小到大的顺序输出满足条件的四位十进制数。

public class Main {
    public static void main(String[] args) {
        for (int i = 10; i < 100; i++) {
            int j = i / 10 + (i % 10) * 10;
            if (i % 10 == 0) {
                System.out.println(i + "0" + j);
            } else {
                System.out.println(i + "" + j);
            }
        }
    }
}

特殊回文数

问题描述
  123321是一个非常特殊的数,它从左边读和从右边读是一样的。
  输入一个正整数n, 编程求所有这样的五位和六位十进制数,满足各位数字之和等于n 。
输入格式
  输入一行,包含一个正整数n。
输出格式
  按从小到大的顺序输出满足条件的整数,每个整数占一行。
样例输入
52
样例输出
899998
989989
998899
数据规模和约定
  1<=n<=54。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        DOIT(n);
    }

    public static void DOIT(int n) {
        for (int i = 100; i <= 999; i++) {
            int n1 = (i + "").charAt(0) - '0';
            int n2 = (i + "").charAt(1) - '0';
            int n3 = (i + "").charAt(2) - '0';
            if (n1 * 2 + n2 * 2 + n3 == n) {
                System.out.println("" + n1 + n2 + n3 + n2 + n1);
            }
        }
        for (int i = 100; i <= 999; i++) {
            int n1 = (i + "").charAt(0) - '0';
            int n2 = (i + "").charAt(1) - '0';
            int n3 = (i + "").charAt(2) - '0';
            if (n1 * 2 + n2 * 2 + n3 * 2 == n) {
                System.out.println("" + n1 + n2 + n3 + n3 + n2 + n1);
            }
        }
    }
}

十进制转十六进制

问题描述
  十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号,分别表示十进制数的0至15。十六进制的计数方法是满16进1,所以十进制数16在十六进制中是10,而十进制的17在十六进制中是11,以此类推,十进制的30在十六进制中是1E。
  给出一个非负整数,将它表示成十六进制的形式。
输入格式
  输入包含一个非负整数a,表示要转换的数。0<=a<=2147483647
输出格式
  输出这个整数的16进制表示
样例输入
30
样例输出
1E

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        System.out.println(Integer.toHexString(a).toUpperCase());
    }
}

十六进制转十进制

问题描述
  从键盘输入一个不超过8位的正的十六进制数字符串,将它转换为正的十进制数后输出。
  注:十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
样例输入
FFFF
样例输出
65535

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String a = in.next();
        long i = Long.parseLong(a, 16);
        System.out.println(i);
    }
}

十六进制转八进制

问题描述
  给定n个十六进制正整数,输出它们对应的八进制数。
输入格式
  输入的第一行为一个正整数n (1<=n<=10)。
  接下来n行,每行一个由0~9、大写字母A~F组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。
输出格式
  输出n行,每行为输入对应的八进制正整数。
注意
  输入的十六进制数不会有前导0,比如012A。
  输出的八进制数也不能有前导0。
样例输入
2
39
123ABC
样例输出
71
4435274
提示
  先将十六进制数转换成某进制数,再由某进制数转换成八进制。

import java.util.HashMap;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        String a[] = new String[n];
        String b[] = new String[n];
        for (int i = 0; i < a.length; i++) {
            a[i] = in.next();
            b[i] = "";
        }
        for (int i = 0; i < a.length; i++) {
            b[i] = hexToOctal(a[i]);
            System.out.println(b[i]);
        }
    }

    public static String hexToBinary(String hexNum) {
        char[] chs = { '0', '1' };
        String str = new String("0123456789ABCDEF");
        char[] charArray = hexNum.toUpperCase().toCharArray();
        int pos = charArray.length * 4;
        char[] binaryArray = new char[pos];
        for (int i = charArray.length - 1; i >= 0; i--) {
            int temp = str.indexOf(charArray[i]);
            for (int j = 0; j < 4; j++) {
                binaryArray[--pos] = chs[temp & 1];
                temp = temp >>> 1;
            }
        }
        return new String(binaryArray);
    }

    public static String binaryHandle(String binary) {
        String str = binary.substring(binary.indexOf('1'));
        int len = str.length();
        if (len % 3 == 0)
            return str;
        else if (len % 3 == 1)
            return "00" + str;
        else
            return "0" + str;
    }

    public static String hexToOctal(String str) {
        String s = hexToBinary(str);
        String s1 = binaryHandle(s);
        return binaryToOctal(s1);
    }

    public static String binaryToOctal(String binary) {
        HashMap<String, Character> map = new HashMap<String, Character>();
        map.put("000", '0');
        map.put("001", '1');
        map.put("010", '2');
        map.put("011", '3');
        map.put("100", '4');
        map.put("101", '5');
        map.put("110", '6');
        map.put("111", '7');
        int pos = binary.length() / 3;
        char[] octArray = new char[pos];
        for (int i = binary.length(); i > 0; i -= 3) {
            String s = binary.substring(i - 3, i);
            octArray[--pos] = map.get(s);
        }
        return new String(octArray);
    }

}

数列排序

问题描述
  给定一个长度为n的数列,将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
  第一行为一个整数n。
  第二行包含n个整数,为待排序的数,每个整数的绝对值小于10000。
输出格式
  输出一行,按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9
样例输出
3 4 6 8 9

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < a.length; i++) {
            a[i] = in.nextInt();
        }
        for (int i = 0; i < a.length; i++) {
            int temp = a[i];
            int j;
            for (j = i - 1; j >= 0; j--) {
                if (a[j] > temp) {
                    a[j + 1] = a[j];
                } else {
                    break;
                }
            }
            a[j + 1] = temp;
        }
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "  ");
        }
    }
}

区间k大数查询

问题描述
给定一个序列,每次询问序列中第l个数到第r个数中第K大的数是哪个。
输入格式
第一行包含一个数n,表示序列长度。
第二行包含n个正整数,表示给定的序列。
第三个包含一个正整数m,表示询问个数。
接下来m行,每行三个数l,r,K,表示询问序列从左往右第l个数到第r个数中,从大往小第K大的数是哪个。序列元素从1开始标号。
输出格式
总共输出m行,每行一个数,表示询问的答案。
样例输入
5
1 2 3 4 5
2
1 5 2
2 3 2
样例输出
4
2
数据规模与约定
对于30%的数据,n,m<=100;
对于100%的数据,n,m<=1000;
保证k<=(r-l+1),序列中的数<=106。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < a.length; i++) {
            a[i] = in.nextInt();
        }
        int m = in.nextInt();
        int[][] b = new int[m][3];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < 3; j++) {
                b[i][j] = in.nextInt();
            }
        }

        for (int i = 0; i < m; i++) {
            int l = b[i][0], r = b[i][1], K = b[i][2];
            int x = r - l + 1;
            int[] c = new int[x];
            for (int j = 0; j < x; j++) {
                c[j] = a[l - 1];
                l++;
            }
            paiXu(c);
            System.out.println(c[K - 1]);
        }
    }

    public static int[] paiXu(int a[]) {
        for (int i = 0; i < a.length; i++) {
            int temp = a[i];
            int j;
            for (j = i - 1; j >= 0; j--) {
                if (a[j] < temp) {
                    a[j + 1] = a[j];
                } else {
                    break;
                }
            }
            a[j + 1] = temp;
        }
        return a;
    }
}

Anagrams问题

问题描述
  Anagrams指的是具有如下特性的两个单词:在这两个单词当中,每一个英文字母(不区分大小写)所出现的次数都是相同的。例如,“Unclear”和“Nuclear”、“Rimon”和“MinOR”都是Anagrams。编写一个程序,输入两个单词,然后判断一下,这两个单词是否是Anagrams。每一个单词的长度不会超过80个字符,而且是大小写无关的。
  输入格式:输入有两行,分别为两个单词。
  输出格式:输出只有一个字母Y或N,分别表示Yes和No。
  输入输出样例

样例输入

Unclear
Nuclear

样例输出

Y

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s1 = in.next();
        String s2 = in.next();
        if (s1.length() != s2.length()) {
            System.out.println("N");
        } else {
            s1 = s1.toUpperCase();
            s2 = s2.toUpperCase();
            int[] a = new int[s1.length()];
            int[] b = new int[s2.length()];
            for (int i = 0; i < a.length; i++) {
                a[i] = s1.charAt(i) - 'A';
                b[i] = s2.charAt(i) - 'A';
            }
            for (int i = 0; i < b.length; i++) {
                for (int j = i + 1; j < b.length; j++) {
                    if (a[i] > a[j]) {
                        int temp = a[i];
                        a[i] = a[j];
                        a[j] = temp;
                    }
                    if (b[i] > b[j]) {
                        int temp = b[i];
                        b[i] = b[j];
                        b[j] = temp;
                    }
                }
            }
            for (int i = 0; i < b.length; i++) {
                if (a[i] != b[i]) {
                    System.out.println("N");
                    return;
                }
            }
            System.out.println("Y");
        }
    }
}

前缀表达式

问题描述
  编写一个程序,以字符串方式输入一个前缀表达式,然后计算它的值。输入格式为:“运算符 对象1 对象2”,其中,运算符为“+”(加法)、“-”(减法)、“*”(乘法)或“/”(除法),运算对象为不超过10的整数,它们之间用一个空格隔开。要求:对于加、减、乘、除这四种运算,分别设计相应的函数来实现。
  输入格式:输入只有一行,即一个前缀表达式字符串。
  输出格式:输出相应的计算结果(如果是除法,直接采用c语言的“/”运算符,结果为整数)。
  输入输出样例

样例输入
+ 5 2
样例输出
7

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.next();
        int a = in.nextInt();
        int b = in.nextInt();
        char c = s.charAt(0);
        switch (c) {
        case '+':
            add(a, b);
            break;
        case '-':
            minus(a, b);
            break;
        case '*':
            multiply(a, b);
            break;
        case '/':
            rid(a, b);
            break;
        default:
            break;
        }
    }

    public static void add(int a, int b) {
        System.out.println(a + b);
    }

    public static void minus(int a, int b) {
        System.out.println(a - b);
    }

    public static void multiply(int a, int b) {
        System.out.println(a * b);
    }

    public static void rid(int a, int b) {
        System.out.println(a / b);
    }

}

排序

问题描述

  编写一个程序,输入3个整数,然后程序将对这三个整数按照从大到小进行排列。
  输入格式:输入只有一行,即三个整数,中间用空格隔开。
  输出格式:输出只有一行,即排序后的结果。
  输入输出样例

样例输入

9 2 30

样例输出

30 9 2

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[] a = { in.nextInt(), in.nextInt(), in.nextInt() };
        for (int i = 0; i < a.length; i++) {
            for (int j = i + 1; j < a.length; j++) {
                if (a[i] < a[j]) {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
}

图形显示

问题描述

  编写一个程序,首先输入一个整数,例如5,然后在屏幕上显示如下的图形(5表示行数):
  * * * * *
  * * * *
  * * *
  * *
  *

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

未名湖边的烦恼

问题描述

  每年冬天,北大未名湖上都是滑冰的好地方。北大体育组准备了许多冰鞋,可是人太多了,每天下午收工后,常常一双冰鞋都不剩。
  每天早上,租鞋窗口都会排起长龙,假设有还鞋的m个,有需要租鞋的n个。现在的问题是,这些人有多少种排法,可以避免出现体育组没有冰鞋可租的尴尬场面。(两个同样需求的人(比如都是租鞋或都是还鞋)交换位置是同一种排法)

输入格式

  两个整数,表示m和n

输出格式

  一个整数,表示队伍的排法的方案数。

样例输入

3 2

样例输出

5

数据规模和约定

  m,n∈[0,18]
  问题分析

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int m = in.nextInt(), n = in.nextInt();
        System.out.println(make(m, n));
    }

    public static int make(int m, int n) {
        if (m < n) {
            return 0;
        } else if (n == 0) {
            return 1;
        }
        return make(m - 1, n) + make(m, n - 1);
    }
}

P1103

  编程实现两个复数的运算。设有两个复数 和 ,则他们的运算公式为:

  要求:(1)定义一个结构体类型来描述复数。
  (2)复数之间的加法、减法、乘法和除法分别用不用的函数来实现。
  (3)必须使用结构体指针的方法把函数的计算结果返回。
  说明:用户输入:运算符号(+,-,*,/) a b c d.
  输出:a+bi,输出时不管a,b是小于0或等于0都按该格式输出,输出时a,b都保留两位。

输入:
  - 2.5 3.6 1.5 4.9
输出:
  1.00+-1.30i


public class Main {
    public static void main(String[] arg) {
        Scanner in = new Scanner(System.in);
        String x = in.next();
        float a = in.nextFloat(), b = in.nextFloat(), c = in.nextFloat(), d = in.nextFloat();

        if (x.equals("+")) {
            System.out.println(String.format("%.2f", (a + c)) + "+" + String.format("%.2f", (b + d)) + "i");
        } else if (x.equals("-")) {
            System.out.println(String.format("%.2f", (a - c)) + "+" + String.format("%.2f", (b - d)) + "i");
        } else if (x.equals("*")) {
            System.out.println(
                    String.format("%.2f", (a * c - b * d)) + "+" + String.format("%.2f", (a * d + b * c)) + "i");
        } else if (x.equals("/")) {
            System.out.println(String.format("%.2f", (a * c + b * d) / (c * c + d * d)) + "+"
                    + String.format("%.2f", (b * c - a * d) / (c * c + d * d)) + "i");
        }
    }
}
展开阅读全文

没有更多推荐了,返回首页