输出汉字在Unicode的位置

题目：用Java编写程序，给出汉字“你”，“我”，“他”在Unicode表中的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Main {
    public static void main(String[] args) {
        // 汉字"你"、"我"、"他"的Unicode编码
        char you = '你';
        char me = '我';
        char him = '他';

        // 获取它们在Unicode表中的位置（即Unicode编码）
        int unicodeOfYou = (int) you;
        int unicodeOfMe = (int) me;
        int unicodeOfHim = (int) him;

        System.out.println("汉字'你'在Unicode表中的位置: " + unicodeOfYou);
        System.out.println("汉字'我'在Unicode表中的位置: " + unicodeOfMe);
        System.out.println("汉字'他'在Unicode表中的位置: " + unicodeOfHim);
    }
}

注：

将这三个字符变量转换成整型（int类型），存储各自对应的Unicode编码。在Java中，字符类型可以隐式转换为整型，转换的结果就是该字符在Unicode编码表中的位置。

1
2
3
int unicodeOfYou = (int) you;
int unicodeOfMe = (int) me;
int unicodeOfHim = (int) him;

输出希腊字母

编写一个Java应用程序，输出全部的希腊字母

分析：：可以通过循环遍历相应的Unicode范围来实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class GreekAlphabetPrinter {
    public static void main(String[] args) {
        // 输出小写希腊字母
        System.out.println("小写希腊字母:");
        for (char c = '\u03B1'; c <= '\u03C9'; c++) {
            System.out.print(c + " ");
        }
        System.out.println();

        // 输出大写希腊字母
        System.out.println("大写希腊字母:");
        for (char c = '\u0391'; c <= '\u03A9'; c++) {
            System.out.print(c + " ");
        }
    }
}
  • \u03B1 是小写希腊字母 α（alpha）的Unicode编码。
  • \u03C9 是小写希腊字母 ω（omega）的Unicode编码。
  • \u0391 是大写希腊字母 Α（Alpha）的Unicode编码。
  • \u03A9 是大写希腊字母 Ω（Omega）的Unicode编码。

异或运算符的加密

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class summation {
    public static void main(String[] args){
        char a1='十',a2='点',a3='进',a4='攻';
        char secret='A';
        a1=(char)(a1^secret);
        a2=(char)(a2^secret);
        a3=(char)(a3^secret);
        a4=(char)(a4^secret);
        System.out.println("密文:"+a1+a2+a3+a4);
        a1=(char)(a1^secret);
        a2=(char)(a2^secret);
        a3=(char)(a3^secret);
        a4=(char)(a4^secret);
        System.out.println("原文："+a1+a2+a3+a4);
    }
}

分析：异或运算是具有自反性的，即同一个字符异或两次相同字符会得到原字符，所以这是一种可逆加密。

求和

问题1：用Java编写应用程序，求1!+2!+3!..10!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class FactorialSumCalculator {
    public static void main(String[] args) {
        long sum = 0;
        for (int i = 1; i <= 10; i++) {
            sum += factorial(i);
        }
        System.out.println("1! + 2! + 3! + ... + 10! 的和是: " + sum);
    }

    // 计算阶乘的辅助函数
    private static long factorial(int n) {
        if (n == 0 || n == 1) {
            return 1L;
        } else {
            return n * factorial(n - 1);
        }
    }
}

分析：factorial函数是一个递归函数，用于计算阶乘。当输入的n等于0或1时，返回1（因为0!和1!都等于1），否则递归调用自身计算n-1的阶乘并乘以当前的n。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class summation {
    public static void main(String[] args) {
        double sum = 0;
        int i = 1, n = 10;
        int factorial = 1; // 新增变量用于保存当前项的阶乘值

        while (i <= n) {
            factorial *= i; // 计算当前项的阶乘值
            sum += factorial; // 将当前阶乘值累加到总和中
            i += 1;
        }

        System.out.println("1! + 2! + 3! + ... + 10! 的结果是: " + sum);
    }
}

问题2：求e的近似值

1
2
3
4
5
6
7
8
9
10
11
public class fractions {
    public static void main(String args[]){
        int i=0,n=20;
        double num=0,item=1;
        for (i=1;i<n;i++){
            num+=item;
            item*=(1.0/i);
        }
        System.out.println("num="+num);
    }
}

通过改变n的值使求出的e的值更加准确

问题3：求1+3+5+7+9的和同时求100以内的素数

1
2
3
4
5
6
7
8
9
10
11
12
public class summation {
    public static void main(String[] args) {
        int i, num = 0, j;
        int con = 10;
        for (i = 1; i <= con; i++) {
            if (i % 2 == 0) {
                continue;
            }
            num += i;
        }

}
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
public class summation {

    public static void main(String[] args) {
        // 计算并输出从1到10中指定奇数之和
        int oddSum = 0;
        for (int i = 1; i <= 10; i += 2) {
            oddSum += i;
        }
        System.out.println("1+3+5+7+9的值是: " + oddSum);

        // 找出并打印出2到100之间的所有素数
        for (int j = 2; j <= 100; j++) {
            boolean isPrime = true;
            for (int i = 2; i * i <= j; i++) {
                if (j % i == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                System.out.println(" " + j + "是素数");
            }
        }
    }
}

关键点：

内部的 for 循环从2开始遍历至 i * i <= j，这是因为若 j 不是素数，则它一定有一个因子小于等于它的平方根。这样可以显著减少检查的次数

问题3：分别用do-while和for循环计算1+1/2!+1/3!+1/4!+…的前20项之和

1
2
3
4
5
6
7
8
9
10
11
12
13
public class summation {
    public static void main(String[] args) {
        int i = 1;
        double m = 1.0; // 将m的初始值改为double类型
        double sum = 0;
        do {
            m *= 1.0 / i; // 使用1.0/i来避免整数除法
            sum += m;
            i += 1;
        } while (i <= 20);
        System.out.println("1+1/2!+1/3!+1/4!+...的结果是：" + String.format("%.5f", sum));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class summation {

    public static void main(String[] args) {
        double sum = 0.0; // 使用double类型来存储和，以提高精度
        double factorial = 1.0; // 初始化阶乘为1.0，使用double类型避免下溢

        for (int i = 1; i <= 20; i++) {
            factorial *= i; // 计算阶乘
            sum += 1.0 / factorial; // 累加每一项的倒数
        }

        System.out.println("1+1/2!+1/3!+1/4!+...的结果是：" + String.format("%.5f", sum));
    }
}

注：因为精度问题，所以写的是1.0,0.0,而不是 1 , 0

问题4：

编写应用程序，使用for循环语句计算8+88+888+…的前10项之和

1
2
3
4
5
6
7
8
9
10
11
12
public class summation {
    public static void main(String[] args) {
        int num=8;
        double sum=0;
        for(int i=0;i<10;i++){
            sum+=num;
            num*=10;
        }
        System.out.println("8+88+888+...的前10项之和为：" + sum);
    }

}

switch语句练习

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
import java.util.Scanner;

public class Switch {
    public static void main(String []args){
        int number=0;
        System.out.println("输入正整数(回车确定)");
        Scanner reader =new Scanner(System.in);
        number =reader.nextInt();
        switch(number){
            case 9:
            case 131:
            case 12:System.out.println(number+"是三等奖");
                    break;
            case 209: 
             case 596:
            case 27:System.out.println(number+"是二等奖");
                    break;
            case 875:
            case 316:
            case 59:System.out.println(number+"是一等奖");
                    break;
            default:System.out.println(number+"未中奖");
        }
    }
}

分析：

  1. Scanner reader = new Scanner(System.in); 创建了一个 Scanner 对象 reader，它用于读取标准输入流（即键盘输入）。System.in 是Java系统内置的输入流对象，指向标准输入设备，默认情况下就是键盘。
  2. number = reader.nextInt(); 这一行则是通过 reader 对象从标准输入流中读取用户输入的一个整数值，并将其赋值给变量 number。nextInt() 方法会等待用户在控制台输入一个整数并按回车键确认后，将该整数值读取并返回。

遍历数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class traversing {
    public static void main(String[]args){
        int a[]={1,2,3,4};
        char b[]={'a','b','c','d'};
        for(int n=0;n<a.length;n++){
            System.out.println(a[n]);
        }
        for(int n=0;n<b.length;n++){
            System.out.println(b[n]);
        }
        for(int i:a){
            System.out.println(i);
        }
        for(char ch:b){
            System.out.println(ch);
        }

    }
}

求出1000以内的所有完数

如果一个数恰好等于他的因子之和，则这个数称为完数，编写应用程序求1000以内的所有完数

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
public class PerferNum {
    public static void main(String[] args) {
        // 声明并初始化一个字符串变量，用于存储完数并以逗号分隔
        String perfectNumbers = "";

        // 遍历 1 到 1000 之间的所有整数
        for (int number = 1; number <= 1000; number++) {
            // 计算因子之和
            int sum = 0;
            for (int i = 1; i < number; i++) {
                if (number % i == 0) {
                    sum += i;
                }
            }

            // 如果因子之和等于原始数，那么这个数就是完数
            if (sum == number) {
                // 将完数添加到字符串中，并在完数之间添加逗号分隔
                perfectNumbers += number + (perfectNumbers.isEmpty() ? "" : ", ");
            }
        }

        // 输出所有完数
        System.out.println("1000 以内的所有完数: " + perfectNumbers);
    }
}
1
perfectNumbers += number + (perfectNumbers.isEmpty() ? "" : ", ");

这段代码的作用是将找到的完数（number）添加到字符串 perfectNumbers 的末尾，并在添加新的完数之前，如果 perfectNumbers 中已经有其他完数，则在它们之间添加一个逗号（,）作为分隔符。

求最大正整数

编写应用程序，输出满足1+2+3+…+n<8888的最大正整数n

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class GreatPosInte {
    public static void main(String []args){
        double sum=0;
        int n=0;
        for(int i=0;;i++){
             sum+=i;
             if (sum<=8888){
                 continue;
             }
             if(sum>8888){
                 n=i-1;
                 break;
             }
        }
        System.out.println("1+2+3+....+n<8888的最大正整数n为:"+n);

    }
}