1.判断可逆素数
【问题描述】若将某一素数的各位数字的顺序颠倒后得到的数仍是素数，则此素数称为可逆素数。编写一个判断某数是否可逆素数的函数，在主函数中输入一个整数，再调用此函数进行判断
【输入形式】用户在第一行输入一个整数。
【输出形式】程序在下一行输出yes或是no,yes表示此数是可逆素数，no表示不是。用户输入的数必须为正整数。注意：yes或是no全是小写输出。
【样例输入】23
【样例输出】no
【样例说明】用户输入23，23各位数字颠倒之后得到32，23是素数，但32不是素数，所以23不是可逆素数。
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
if (panduan(n)) {
System.out.println("yes");
} else {
System.out.println("no");
}
}
public static boolean panduan(int n) {
int nishu = niyunsuan(n);
return qiu(n) && qiu(nishu);
}
private static int niyunsuan(int num) {
long rev = 0;
while (num > 0) {
rev = (rev * 10) + (num % 10);
num /= 10;
}
return (int) rev;
}//生成逆数
private static boolean qiu(long num) {
for (long i = 2; i <= Math.sqrt(num); i++) {
if (num % i == 0) {
return false;
}
}
return num > 1;
}//判断是否为素数通过写好的静态方法输出逆数，再用同一种方法判断原数和逆数是否为素数，最后输出
2.日期类编写
【问题描述】先编写一个日期类，要求如下：
1）成员变量：year(表示年)、month(表示月)、day(表示日)，类型均为int；
2）默认构造方法Date()，默认日期为2000年1月1日；
3）构造方法Date(int year,int month,int day)；
4）编写计算任意两个日期之间相隔天数的方法int interval(Date d）。
然后编写测试类 输入两个日期，输出两个日期之间的间隔天数。
【输入形式】
2020 5 10
2020 5 20
【输出形式】
10
【样例输入】
2020 5 10 2020 5 20
【样例输出】
10
public class main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int y1 = scanner.nextInt();
int m1 = scanner.nextInt();
int d1 = scanner.nextInt();
int y2 = scanner.nextInt();
int m2 = scanner.nextInt();
int d2 = scanner.nextInt();
Data date1=new Data(y1,m1,d1);
Data date2=new Data(y2,m2,d2);
System.out.println(date1.jisuan(date2));
}
}
class Data{
private int year;
private int month;
private int day;
public Data(){
year = 2000;
month = 1;
day = 1;
}
public Data(int a, int b, int c){
this.year=a;
this.month=b;
this.day=c;
}
public int getYear() {
return this.year;
}
public int getMonth() {
return this.month;
}
public int getDay() {
return this.day;
}
public int jisuan(Data d){
boolean d1 = runnianjisuan(d.getYear());
boolean t1 = runnianjisuan(this.year);
return (d.getYear() - this.year) * 365 + dijitian(d.getMonth(),d.day,d1)-dijitian(this.getMonth(),this.getDay(),t1);
}
private static boolean runnianjisuan(int year) {
return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
}
public static int dijitian(int mm, int dd, boolean runnianjisuan) {
int[] yuefen = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (runnianjisuan) {
yuefen[1] = 29;
}
int tianshu = 0;
for (int i = 0; i < mm - 1; i++) {
tianshu += yuefen[i];
}
tianshu += dd;
return tianshu;
}
}根据年数相减可以直接计算年份差距的天数，然后通过调用方法可以计算较晚的日期当年的天数，相加即可得到差距天数
3.两村庄公用一口井
【问题描述】两个村庄共用一口井。编写一个Village类，该类有一个静态的double型成员变量waterAmount，用于模拟井水的水量。在主类Land的main方法中创建两个村庄，一个村庄“Zhang”，另一个为“Li”，每个村庄的人数可以在主类中设置，假设一个村庄中每个人的喝水量相同，试完成以下程序。
【输入形式】
第一行输入井水的水量，第二行输入村庄“Zhang”的人数和每个人的喝水量（浮点数），第三行输入村庄“Li”的人数和每个人的喝水量（浮点数）；
【输出形式】
第一行输出井中初始的水量；
第二行输出村庄“Zhang”用水量和用完水后的井中水量；
第二行输出村庄“Li”用水量和用完水后的井中水量；
【样例输入】
1000 20 1.6 30 1.7
【样例输出】
1000.0 32.0 968.0 51.0 917.0
public class main {
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
Village.setWaterAmount(sc.nextDouble());
System.out.println(Village.getWaterAmount());
Village Zhang = new Village("Zhang",sc.nextInt());
Zhang.setDrinkAmount(sc.nextDouble());
Village Li = new Village("Li",sc.nextInt());
Li.setDrinkAmount(sc.nextDouble());
Zhang.drinkWater();
System.out.println(" " + Li.getWaterAmount());
Li.drinkWater();
System.out.println(" " + Zhang.getWaterAmount());
}
}
class Village {
private static double waterAmount;
public static double getWaterAmount() {
return waterAmount;
}
public static void setWaterAmount(double x) {
waterAmount = x;
}
private String n;
private int r;
private double drinkAmount;
public Village(String n, int r) {
this.n = n;
this.r = r;
}
public void setDrinkAmount(double x) {
this.drinkAmount = x;
}
public void drinkWater() {
double t = r * drinkAmount;
if (t >= waterAmount) {
t = waterAmount;
}
waterAmount -= t;
System.out.print(t);
}
}同一种方法调用两遍，再输出即可，主要是类中方法的编写和定义
