最简单的Java代码

1
2
3
4
5
6
7
public class Main
{
    public static void main(String[] args)
    {
        System.out.println("Hello World");
    }
}

语法基础

变量

变量必须先定义，才能使用，不能重名。

变量定义

1
2
3
4
5
6
7
8
9
10
11
12
public class test
{
    public static void main(String[] args)
    {
        int a = 5;
        int b, c = a, d = 10 / 2;

        System.out.println(a);
        System.out.println(c);
        System.out.println(d);
    }
}

输出

1
2
3
5
5
5

内置数据类型

类型 字节数 举例
byte 1 123
short 2 12345
int 4 123456789
long 8 12345678910111
float 4 1.2F
double 8 1.2
boolean 1 true、false
char 2 ‘A’

常量

使用final

类型转化

显式转化

1
int x = (int) 'A';

隐式转化

1
2
double x = 12;
double y = 4 * 3.3;
1
2
3
4
5
6
7
8
9
10
11
12
public class test
{
    public static void main(String [] args)
    {
        int x = (int) 'A';
        double y = 12;
        int r = (int) y;
        double z = 4F + 3.3F;
        int t = 'A' + 2;
        System.out.println(t);
    }
}

输入

方式一

效率较低，适合输入较小时使用

读入字符串

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        Scanner sc = new Scanner (System.in);
        String str = sc.next();
        System.out.println(str);

        str = sc.next();                    //只能读入空格之前
        System.out.println(str);
    }
}

输入

1
2
Java
Hello World

输出

1
2
Java
Hello

读入一行：

1
2
3
4
5
6
7
8
9
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner (System.in);
        String str = sc.nextLine();             //可以读入一行
        System.out.println(str);
    }
}

输入

1
Hello World

输出

1
Hello World

读入int

1
2
3
4
5
6
7
8
9
10
import java.util.Scanner;

public class Main {
    public static void main (String[] args) {
        Scanner sc = new Scanner (System.in);
        int x = sc.nextInt(), y = sc.nextInt();
        
        System.out.println(x + y);
    }
}

输入

1
1 2

输出

1
3

读入float

1
2
3
4
5
6
7
8
9
10
11
import java.util.Scanner;

public class Main {
    public static void main (String[] args) {
        Scanner sc = new Scanner (System.in);
        float x = sc.nextFloat();
        double y = sc.nextFloat();
        
        System.out.println(x + y);
    }
}

输入

1
3.0 4.5

输出

1
7.5

方式二

1
2
3
4
5
6
7
8
9
10
11
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    public static void main (String[] args) throws Exception {
        BufferedReader br = new BufferedReader (new InputStreamReader(System.in));
        
        String str = br.readLine();
        System.out.println(str);
    }
}

输入

1
Hello World

输出

1
Hello World

输出

方式一

效率较低，适合输出规模较小

1
2
3
4
5
6
7
8
public class Main {
    public static void main (String[] args) {
        System.out.print("hello ");
        System.out.println("world");
        System.out.println(123);
        System.out.printf("%04d %.2f\n", 4, 123.456);
    }
}

输出

1
2
3
hello world
123
0004 123.46

方式二

效率较高，输出规模较大时使用，注意需要抛异常

1
2
3
4
5
6
7
8
9
10
11
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;

public class Main {
    public static void main (String[] args) throws Exception{
        BufferedWriter bw = new BufferedWriter (new OutputStreamWriter(System.out));
        
        bw.write("hello world");
        bw.flush();
    }
}

输入

1
hello world

输出

1
hello world

例题

  1. A+B

    输入两个整数，求这两个整数的和是多少。

    输入格式

    输入两个整数A,B，用空格隔开

    输出格式

    输出一个整数，表示这两个数的和

    数据范围

    0≤A,B≤10^8

    输入样例

    1
    3 4

    输出样例

    1
    7

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int x = sc.nextInt(), y = sc.nextInt();
            
            System.out.println(x + y);
        }
    }

  2. 差

    读取四个整数 A,B,C,D，并计算 (A×B−C×D)的值。

    输入格式

    输入共四行，第一行包含整数 A，第二行包含整数 B，第三行包含整数 C，第四行包含整数 D

    输出格式

    输出格式为 DIFERENCA = X，其中 X为 (A×B−C×D)的结果。

    数据范围

    −10000≤A,B,C,D≤10000

    输入样例

    1
    2
    3
    4
    5
    6
    7
    8

    输出样例

    1
    DIFERENCA = -26

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int a = sc.nextInt(), b = sc.nextInt(), c = sc.nextInt(), d = sc.nextInt();
            
            System.out.print("DIFERENCA = ");
            System.out.println(a * b - c * d);
        }
    }

  3. 平均数

    计算所给圆的面积。π的取值为 3.14159

    输入格式

    输入包含一个浮点数R，为圆的半径

    输出格式

    输出格式为 A=X，其中 X为圆的面积，用浮点数表示，保留四位小数。

    数据范围

    0< R < 10000.00

    输入样例

    1
    2.00

    输出样例

    1
    A=12.5664

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            float r = sc.nextFloat();
            System.out.print("A=");
            System.out.printf("%.4f", r * r * 3.14159);
        }
    }

  4. 平均数1

    读取两个浮点数A和B的值，对应于两个学生的成绩。请你计算学生的平均分，其中A的成绩权重为3.5，B的成绩权重为7.5。成绩的取值范围在到10之间，且保留一位小数

    输入格式

    输入占两行，每行包含一个浮点数，第一行表示 A，第二行表示 B

    输出格式

    输出格式为 MEDIA = X，其中 X为平均分，结果保留五位小数

    数据范围

    0≤A,B≤10.0

    输入样例

    1
    2
    5.0
    7.1

    输出样例

    1
    MEDIA = 6.43182

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            float a = sc.nextFloat(), b = sc.nextFloat();

            System.out.print("MEDIA = ");
            System.out.printf("%.5f", (a * 0.35 + b * 0.75) / 1.1);
        }
    }

  5. 工资

    读取一名员工的员工编号，本月工作总时长（小时）以及时薪，并输出他的工资条，工资条中包括员工编号和员工月收入。

    输入格式

    输入包含两个整数和一个浮点数，分别代表员工编号，工作时长以及时薪。

    每个数占一行。

    输出格式

    输出共两行，第一行格式为 NUMBER = X，其中X为员工编号。

    第二行格式为 SALARY = U$ Y，其中Y为该员工月收入，保留两位小数。

    数据范围

    1≤员工编号≤100

    1≤总工作时长≤200

    1≤时薪≤50

    输入样例

    1
    2
    3
    25
    100
    5.50

    输出样例

    1
    2
    NUMBER = 25
    SALARY = U$ 550.00

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int x = sc.nextInt(), t = sc.nextInt();
            double y = sc.nextFloat();

            System.out.printf("NUMBER = %d\n", x);
            System.out.printf("SALARY = U$ %.2f",y * t);
        }
    }

  6. 油耗

    给定一个汽车行驶的总路程（km）和消耗的油量（l），请你求出汽车每消耗 1升汽油可行驶多少公里路程。

    输入格式

    输入共两行，第一行包含整数 X，表示行驶总路程。

    第二行包含保留一位小数的浮点数 Y，表示消耗的油量。

    输出格式

    输出格式为 M km/l，其中M为计算结果，保留三位小数。

    数据范围

    1≤X,Y≤10^9

    输入样例

    1
    2
    500
    35.0

    输出样例

    1
    14.286 km/l

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int x = sc.nextInt();
            double y = sc.nextDouble();

            System.out.printf("%.3f km/l", x / y);
        }
    }

  7. 两点间的距离

    给定两个点 P1 和 P2，其中 P1 的坐标为 (x1,y1)，P2 的坐标为 (x2,y2)，请你计算两点间的距离是多少。

    输入格式

    输入共两行，每行包含两个双精度浮点数 xi,yi，表示其中一个点的坐标。

    输入数值均保留一位小数。

    输出格式

    输出你的结果，保留四位小数。

    数据范围

    −109≤xi,yi≤109

    输入样例

    1
    2
    1.0 7.0
    5.0 9.0

    输出样例

    1
    4.4721

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            double x1 = sc.nextDouble(), y1 = sc.nextDouble();
            double x2 = sc.nextDouble(), y2 = sc.nextDouble();
            double dx = x2 - x1, dy = y2 - y1;

            double dist = Math.sqrt(dx * dx + dy * dy);

            System.out.printf("%.4f", dist);
        }
    }

  8. 两点间的距离

    读取一个整数值并将其分解为多张钞票的和，每种面值的钞票可以使用多张，并要求所用的钞票数量尽可能少。

    请你输出读取值和钞票清单。

    钞票的可能面值有 100,50,20,10,5,2,1

    输入格式

    输入一个整数N

    输出格式

    参照输出样例，输出读取数值以及每种面值的钞票的需求数量。

    数据范围

    0< N <1000000

    输入样例

    1
    576

    输出样例

    1
    2
    3
    4
    5
    6
    7
    8
    576
    5 nota(s) de R$ 100,00
    1 nota(s) de R$ 50,00
    1 nota(s) de R$ 20,00
    0 nota(s) de R$ 10,00
    1 nota(s) de R$ 5,00
    0 nota(s) de R$ 2,00
    1 nota(s) de R$ 1,00

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int x = sc.nextInt();
            System.out.println(x);
            System.out.printf("%d nota(s) de R$ 100,00\n", x / 100);
            x %= 100;
            System.out.printf("%d nota(s) de R$ 50,00\n", x / 50);
            x %= 50;
            System.out.printf("%d nota(s) de R$ 20,00\n", x / 20);
            x %= 20;
            System.out.printf("%d nota(s) de R$ 10,00\n", x / 10);
            x %= 10;
            System.out.printf("%d nota(s) de R$ 5,00\n", x / 5);
            x %= 5;
            System.out.printf("%d nota(s) de R$ 2,00\n", x / 2);
            x %= 2;
            System.out.printf("%d nota(s) de R$ 1,00\n", x);
        }
    }

  9. 时间转换

    读取一个整数值，它是工厂中某个事件的持续时间（以秒为单位），请你将其转换为小时：分钟：秒来表示。

    输入格式

    输入一个整数N

    输出格式

    输出转换后的时间表示，格式为 hours:minutes:seconds。

    数据范围

    0< N <1000000

    输入样例

    1
    556

    输出样例

    1
    0:9:16

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    import java.util.Scanner;

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

            int hours = x / 3600;
            x %= 3600;
            int min = x / 60;
            x %= 60;
            
            System.out.printf("%d:%d:%d", hours, min, x);
        }
    }

习题

  1. 简单乘积

    读取两个整数值。

    在此之后，计算它们的乘积并将结果存储在名为 PROD 的变量中。

    输出结果如下例所示。

    输入格式

    共两行，每行包含一个整数。

    输出格式

    输出格式为 PROD = X，其中X为乘积结果。

    数据范围

    输入的两个整数的绝对值均不超过 10000

    输入样例

    1
    2
    3
    9

    输出样例

    1
    PROD = 27

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int x = sc.nextInt(), y = sc.nextInt();

            System.out.printf("PROD = %d", x * y);
        }
    }

  2. 简单计算

    给定你两个产品的产品编号，产品数量以及产品单价。

    请你计算买下两种产品一共需要花费多少钱。

    输入格式

    输入共两行。

    每行包含两个整数以及一个浮点数，表示其中一件产品的产品编号，产品数量以及产品单价。

    输出格式

    输出格式为 VALOR A PAGAR: R$ X，其中X为产品总价值，保留两位小数。

    数据范围

    1≤产品编号,产品数量≤10000

    1.00≤产品单价≤10000.00

    输入样例

    1
    2
    12 1 5.30
    16 2 5.10

    输出样例

    1
    VALOR A PAGAR: R$ 15.50

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int tag1 = sc.nextInt(), num1 = sc.nextInt();
            double pri1 = sc.nextDouble();
            int tag2 = sc.nextInt(), num2 = sc.nextInt();
            double pri2 = sc.nextDouble();

            System.out.printf("VALOR A PAGAR: R$ %.2f", num1 * pri1 + num2 * pri2);
        }
    }

  3. 球的体积

    给定你一个球体的半径R，请你计算球体的体积。

    π取 3.14159

    注意：有些语言中 (4/3) 无法得到 1.3333… ，建议在公式中使用 (4/3.0)

    输入格式

    输入一个整数R

    输出格式

    输出格式为 VOLUME = X，其中 X为球体的体积，结果保留三位小数。

    数据范围

    1≤R≤2000

    输入样例

    1
    3

    输出样例

    1
    VOLUME = 113.097

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int r = sc.nextInt();
            System.out.printf("VOLUME = %.3f", 4 / 3.0 * 3.14159 * r * r *r);
        }
    }

  4. 面积

    给定三个浮点数 A，B和 C

    然后，计算如下图形的面积：

    底边为 A，高为 C的三角形。

    半径 C的圆。（π=3.14159）

    底边为 A 和 B，高为 C 的梯形。

    边长为 B 的正方形。

    边长为 A 和 B的长方形

    输入格式

    输入共一行，包含三个保留一位小数的浮点数 A，B，C

    输出格式

    输出共五行，形式如下所示：

    第一行，格式为 TRIANGULO: X，其中 X 为所求三角形面积。

    第二行，格式为 CIRCULO: X，其中 X 为所求圆形面积。

    第三行，格式为 TRAPEZIO: X，其中 X 为所求梯形面积。

    第四行，格式为 QUADRADO: X，其中 X 为所求正方形面积。

    第五行，格式为 RETANGULO: X，其中 X 为所求长方形面积。

    所有答案保留三位小数。

    数据范围

    0≤A,B,C≤10000.0

    输入样例

    1
    3.0 4.0 5.2

    输出样例

    1
    2
    3
    4
    5
    TRIANGULO: 7.800
    CIRCULO: 84.949
    TRAPEZIO: 18.200
    QUADRADO: 16.000
    RETANGULO: 12.000

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            double a = sc.nextDouble(), b = sc.nextDouble(), c = sc.nextDouble();
            System.out.printf("TRIANGULO: %.3f\n", 0.5 * a * c);
            System.out.printf("CIRCULO: %.3f\n", 3.14159 * c * c);
            System.out.printf("TRAPEZIO: %.3f\n", (a + b) * c / 2);
            System.out.printf("QUADRADO: %.3f\n", b * b);
            System.out.printf("RETANGULO: %.3f\n", a * b);
        }
    }

  5. 平均数2

    读取三个浮点数 A，B 和 C 的值，对应于三个学生的成绩。

    请你计算学生的平均分，中 A 的成绩的权重为 2，B 的成绩的权重为 3，C 的成绩的权值为 5

    成绩的取值范围在 0 到 10 之间，且均保留一位小数。

    输入格式

    输入共三行，每行包含一个浮点数，第一行表示 A，第二行表示 B，第三行表示 C

    输出格式

    输出格式为 MEDIA = X，其中 X 为平均分，结果保留一位小数。

    数据范围

    0≤A,B,C≤10.0

    输入样例

    1
    2
    3
    5.0
    6.0
    7.0

    输出样例

    1
    MEDIA = 6.3

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            double a = sc.nextDouble(), b = sc.nextDouble(), c = sc.nextDouble();

            System.out.printf("MEDIA = %.1f", (a * 2 + b * 3 + c * 5) / 10);
        }
    }

  6. 工资和奖金

    编写一个程序，给定你一个销售人员的名字，底薪以及月销售额。

    请你计算他的月收入是多少。

    已知月收入等于底薪加 15% 的月销售额。

    所有数据保留两位小数。

    输入格式

    输入第一行包含一个由大写字母构成的长度不超过 10 的字符串，表示销售人员的名字。

    第二行包含一个浮点数，表示该人员的底薪。

    第三行包含一个浮点数，表示该人员的月销售额。

    输出格式

    输出格式为 TOTAL = R$ X，X 为该人员月收入。

    数据范围

    0≤底薪，月销售额≤10000.00

    输入样例

    1
    2
    3
    JOAO
    500.00
    1000.00

    输出样例

    1
    TOTAL = R$ 650.00

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String name = sc.next();
            double n = sc.nextDouble(), m = sc.nextDouble();

            System.out.printf("TOTAL = R$ %.2f", n + 0.15 * m);
        }
    }

  7. 最大值

    给定三个整数，请你找出它们中的最大值。

    下列公式可能对你有所帮助：

    max(a, b) = (a + b + abs(a - b)) / 2

    输入格式

    输入占一行，包含三个整数

    输出格式

    输出格式为 X eh o maior，其中 X 为三个数中的最大值

    数据范围

    1≤给定整数≤10^9

    输入样例

    1
    7 14 106

    输出样例

    1
    106 eh o maior

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int a = sc.nextInt(), b = sc.nextInt(), c = sc.nextInt();

            int tmp = (a + b + Math.abs(a - b)) / 2;
            int max = (tmp + c + Math.abs(tmp - c)) / 2;
            System.out.printf("%d eh o maior", max);
        }
    }

  8. 距离

    两辆汽车在同一地点，同时，沿同一方向前进。

    一辆车的速度为 60 km/h，另一辆车的速度为 90 km/h

    显然，快车与慢车的距离会不断拉开，每过一个小时（60 分钟），两车的距离就拉开 30 公里。

    现在，告诉你两车之间的距离为 L 公里，请你求出两车已经行驶了多长时间？

    输入格式

    输入包含一个整数 L，表示两车之间的距离。

    输出格式

    输出格式为 X minutos，其中 X 为已经行驶的时间，单位为分钟

    数据范围

    1≤L≤10^9

    输入样例

    1
    30

    输出样例

    1
    60 minutos

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int L = sc.nextInt();
            System.out.printf("%d minutos", L * 2);
        }
    }

  9. 燃料消耗

    一辆汽车每行驶 12 公里需要消耗 1 升汽油，现在告诉你该汽车的行驶速度 S（km/h）和行驶时间 T（h），请你计算该车在行驶过程中一共消耗了多少升汽油。

    输入格式

    输入共两行，第一行包含一个整数 T，表示行驶时间（h）。

    第二行包含一个整数 S，表示行驶速度（km/h）。

    输出格式

    输出行驶期间的总油耗，结果保留三位小数

    数据范围

    1≤T,S≤10^7

    输入样例

    1
    2
    10
    85

    输出样例

    1
    70.833

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int t = sc.nextInt(), s = sc.nextInt();
            System.out.printf("%.3f",(double) t * s / 12);
        }
    }

  10. 钞票和硬币

    读取一个带有两个小数位的浮点数，这代表货币价值。

    在此之后，将该值分解为多种钞票与硬币的和，每种面值的钞票和硬币使用数量不限，要求使用的钞票和硬币的总数量尽可能少。

    钞票的面值是 100,50,20,10,5,2

    硬币的面值是 1,0.50,0.25,0.10,0.05 和 0.01

    经过实验证明：在本题中，优先使用面额大的钞票和硬币可以保证所用的钞票和硬币总数量最少。

    输入格式

    输入一个浮点数 N

    输出格式

    参照输出样例，输出每种面值的钞票和硬币的需求数量。

    数据范围

    0≤N≤1000000.00

    输入样例

    1
    576.73

    输出样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    NOTAS:
    5 nota(s) de R$ 100.00
    1 nota(s) de R$ 50.00
    1 nota(s) de R$ 20.00
    0 nota(s) de R$ 10.00
    1 nota(s) de R$ 5.00
    0 nota(s) de R$ 2.00
    MOEDAS:
    1 moeda(s) de R$ 1.00
    1 moeda(s) de R$ 0.50
    0 moeda(s) de R$ 0.25
    2 moeda(s) de R$ 0.10
    0 moeda(s) de R$ 0.05
    3 moeda(s) de R$ 0.01

    解
    方法一

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    //方法一：为防止double的精度问题，先在n上加一个1e-8
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            double n = sc.nextDouble();

            n += 1e-8;

            System.out.println("NOTAS:");
            int cnt = (int) n / 100;
            n = n - cnt * 100;
            System.out.printf("%d nota(s) de R$ 100.00\n" , cnt);

            cnt = (int) (n / 50);
            n = n - cnt * 50;
            System.out.printf("%d nota(s) de R$ 50.00\n" , cnt);

            cnt = (int) (n / 20);
            n = n - cnt * 20;
            System.out.printf("%d nota(s) de R$ 20.00\n" , cnt);

            cnt = (int) (n / 10);
            n = n - cnt * 10;
            System.out.printf("%d nota(s) de R$ 10.00\n" , cnt);

            cnt = (int) (n / 5);
            n = n - cnt * 5;
            System.out.printf("%d nota(s) de R$ 5.00\n" , cnt);

            cnt = (int) n / 2;
            n = n - cnt * 2;
            System.out.printf("%d nota(s) de R$ 2.00\n" , cnt);

            System.out.println("MOEDAS:");
            cnt = (int) n / 1;
            n = n - cnt * 1;
            System.out.printf("%d moeda(s) de R$ 1.00\n" , cnt);

            cnt = (int) (n / 0.5);
            n = n - cnt * 0.5;
            System.out.printf("%d moeda(s) de R$ 0.50\n" , cnt);

            cnt = (int) (n / 0.25);
            n = n - cnt * 0.25;
            System.out.printf("%d moeda(s) de R$ 0.25\n" , cnt);

            cnt = (int) (n / 0.1);
            n = n - cnt * 0.1;
            System.out.printf("%d moeda(s) de R$ 0.10\n" , cnt);

            cnt = (int) (n / 0.05);
            n = n - cnt * 0.05;
            System.out.printf("%d moeda(s) de R$ 0.05\n" , cnt);

            cnt = (int) (n / 0.01);
            n = n - cnt * 0.01;
            System.out.printf("%d moeda(s) de R$ 0.01\n" , cnt);
        }
    }

    方法二

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    //先将钱数扩大100倍转化为整型直接避免精度问题
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            double x = sc.nextDouble();
            int n = (int) (x * 100);

            System.out.println("NOTAS:");
            int cnt = n / 10000;
            n = n - cnt * 10000;
            System.out.printf("%d nota(s) de R$ 100.00\n" , cnt);

            cnt = n / 5000;
            n = n - cnt * 5000;
            System.out.printf("%d nota(s) de R$ 50.00\n" , cnt);

            cnt = n / 2000;
            n = n - cnt * 2000;
            System.out.printf("%d nota(s) de R$ 20.00\n" , cnt);

            cnt = n / 1000;
            n = n - cnt * 1000;
            System.out.printf("%d nota(s) de R$ 10.00\n" , cnt);

            cnt = n / 500;
            n = n - cnt * 500;
            System.out.printf("%d nota(s) de R$ 5.00\n" , cnt);

            cnt = n / 200;
            n = n - cnt * 200;
            System.out.printf("%d nota(s) de R$ 2.00\n" , cnt);

            System.out.println("MOEDAS:");
            cnt = n / 100;
            n = n - cnt * 100;
            System.out.printf("%d moeda(s) de R$ 1.00\n" , cnt);

            cnt = n / 50;
            n = n - cnt * 50;
            System.out.printf("%d moeda(s) de R$ 0.50\n" , cnt);

            cnt = n / 25;
            n = n - cnt * 25;
            System.out.printf("%d moeda(s) de R$ 0.25\n" , cnt);

            cnt = n / 10;
            n = n - cnt * 10;
            System.out.printf("%d moeda(s) de R$ 0.10\n" , cnt);

            cnt = n / 5;
            n = n - cnt * 5;
            System.out.printf("%d moeda(s) de R$ 0.05\n" , cnt);

            cnt = n / 1;
            n = n - cnt * 1;
            System.out.printf("%d moeda(s) de R$ 0.01\n" , cnt);
        }
    }

  11. 天数转换

    读取对应于一个人的年龄（以天为单位）的整数值，并转化为年，月和日表示方式输出，年、月、日分别对应 ano(s), mes(es), dia(s)。

    注意：为了方便计算，假设全年 365 天，每月 30 天

    输入格式

    输入一个整数 N

    输出格式

    参照输出样例，输出转换后的天数表达

    数据范围

    0≤N≤1000000

    输入样例

    1
    400

    输出样例

    1
    2
    3
    1 ano(s)
    1 mes(es)
    5 dia(s)

    解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    import java.util.Scanner;

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

            int y = n / 365;
            n %= 365;
            int m = n / 30;
            n %= 30;
            int d = n;

            System.out.printf("%d ano(s)\n", y);
            System.out.printf("%d mes(es)\n", m);
            System.out.printf("%d dia(s)\n", d);
        }
    }