java基础题 求更好的解法 更好的算法

Question

想要了解多种解法。/*
*输出1～1000之间能被3整除而不能被7整除的所有数
*/public class Math1{
public static void main(String[] args)
{
for(int i=1;i<=1000;i++)
{
if(i%3==0 && i%7!=0)
System.out.print(i+",");
}
}
}/*
*一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第10次落地时，共经过多少米？第10次反弹多高？
*/
public class Math2{
public static void main(String[] args)
{
double s=100.0;
double h=s/2; 
int n; 
for(n=2;n<=10;n++) 
 { 
  s=s+2*h;
  h=h/2; 
 }
System.out.print("第10次落地时，共经过："+s+"米");
System.out.print("第10次反弹的高度："+h+"米");
}
}/*
*使用循环计算2＋22＋222＋2222+….的前10项之和
*/public class Math3{
public static void main(String[] args)
{
long sum=2;
long n=2;
for(int i=2;i<=10;i++)
{
n=n*10+2;
sum+=n;
}
System.out.println("前10项的和："+sum);
}
}/*
*计算1＋1/3+1/5++1/7+1/9+…的前10000项之和
*/public class Math4{
public static void main(String[] args)
{
double sum=0.0;
for(int i=1;i<20000;i+=2)
sum+=1.0/i;
System.out.println("前10000项之和:"+sum);

}
}/*
*输出1000以内的全部素数
*/public class Math5{
public static void main(String[] args)
{
for(int i=2;i<1000;i++)
{
if(isPrime(i))
System.out.print(i+",");
}

}

public static boolean isPrime(int num)
{
for(int i=2;i<=Math.sqrt(num);i++)
{
if(num%i==0)
return false;
}
return true;
}
}/*
*编写一个类，该类封装了一元二次方程共有的属性和功能，
*即该类有刻画方程系数的3个成员变量以及求实根的方法。
*/import java.util.Scanner; 
public class Math6 
{ 
public static void main(String[] args) 
{ 
Scanner scanner = new Scanner(System.in); 
System.out.print("请输入a,b,c:"); 
double a = scanner.nextDouble(); 
double b = scanner.nextDouble(); 
double c = scanner.nextDouble(); 
new question().solve(a, b, c); 
} 

} 
class question
{ 
private double a = 0; 
private double b = 0 ; 
private double c = 0 ; 
private double root = 0; 
private double x1 = 0; 
private double x2 = 0; 
public void solve(double a,double b,double c) 
{ 
root = b*b - 4*a*c; 
if(root > 0) 
{ 
x1 = (-b + Math.sqrt(root))/(2*a); 
x2 =  (-b - Math.sqrt(root))/(2*a); 
System.out.println("x1="+x1+"\tx2="+x2); 
} 
else if(root == 0) 
{ 
x1 = x2 = -b/(2*a); 
System.out.println("x1="+x1+"\tx2="+x2); 
} 
else 
 System.out.println("无实数根！"); 
} 

}/*
*计算两个正整数的最大公约数和最小公倍数，要求从键盘输数。
*/import java.util.Scanner; public class Math7{
public static void main(String[] args)
{
Scanner scanner=new Scanner(System.in);
System.out.print("请输入两个整数：");
int a=scanner.nextInt();
int b=scanner.nextInt();

int m=Math.max(a,b);
int n=Math.min(a,b);
int r=1;
int p=m*n;
while(r!=0)
{
r=m%n;
m=n;
n=r;
}
System.out.println("最大公约数："+m);
System.out.println("最小公倍数："+p/m);


}
}/*
*输出1000以内的所有水仙花数
*/public class Math8{
public static void main(String[] args)
{
for(int n=100;n<1000;n++)
{
int a=n/100;
int b=n/10%10;
int c=n%10;
if(n==Math.pow(a,3)+Math.pow(b,3)+Math.pow(c,3))
System.out.println(n);
}
}

}/*
*要求从键盘输入三个整数x,y,z，请把这三个数由小到大输出
*/
import java.util.Arrays;
import java.util.Scanner;
public class Math9{
public static void main(String[] args)
{
Scanner s=new Scanner(System.in);
System.out.println("请输入三位整数：");
System.out.print("x=");
int x=s.nextInt();
System.out.print("y=");
int y=s.nextInt();
System.out.print("z=");
int z=s.nextInt();

int[] num={x,y,z};
System.out.print("排序前：");
for(int n:num)
System.out.print(n+",");
System.out.print("\n"+"排序后:");
Arrays.sort(num);
for(int n:num)
System.out.print(n+",");

}
}/*
*从键盘输入一个数，判断它是否是完数
*/
import java.util.Scanner;
public class Math10{
public static void main(String[] args)
{
System.out.println("请输入个整数：");
Scanner s=new Scanner(System.in);
int a=s.nextInt();
if(isPerfectNum(a))
System.out.println(a+"是完数!");
else
System.out.println(a+"不是完数!");

}

public static boolean isPerfectNum(int n)
{
int s=0;
int[] num=new int[n];
for (int i=1;i<n;i++)
{
if((n%i)==0)
s+=i;
}
if(s==n)
return true;
else
return false;

}}

Answer 1

public class Example {
    publci static void main(String args[]) {
        for(int i=3,int j=0;;i<=999;i=i+3,j++) {
            j++;
            if(j%7==0) {
                System.out.println();
                continue;
            }
            System.out.print(i+" ");
        }
    }
}

Answer 2

/*
*输出1～1000之间能被3整除而不能被7整除的所有数
*/public class Math1{
public static void main(String[] args)
{
int j = 1;
for (int i = 3; i <= 1000; i = i + 3, j++)
{
if (j == 7)
{
j = 1;
i = i + 3;
}
System.out.print(i + ",");
}
}}

Answer 3

/*
*输出1～1000之间能被3整除而不能被7整除的所有数
*/public class Math1{
    public static void main(String[] args)
    {
            for(int i=3;i<=1000;i+=3)
            {
                if(i%7!=0)
                    System.out.print(i+",");
            }
    }        
}

Answer 4

谢谢发代码的我只是想了解不同的解法，通过别人的思想来了解自己的不足，
这样做不行吗？还有下面筛选法求素数public class Math5{
public static void main(String[] args)
{

int max = 1000; //假设求1000以内的素数
boolean[] isPrime = new boolean[max+1];
for(int i=0; i<=max; i++)
isPrime[i]=true;
isPrime[0]=isPrime[1]=false; //1和0不是素数，所以将相应的
//isPrime元素设置为false
int n = (int)Math.ceil(Math.sqrt(max));
for(int i=0; i<=n; i++)
{
if(isPrime[i]) //素数的整数倍不是素数，从而筛选掉所有不是素数的数
{
for(int j=2*i; j<=max; j=j+i)
isPrime[j]=false;
}
}
int largest=0;
for(largest=max; !isPrime[largest]; largest--)
{
System.out.println(largest);
}
}
}上面for(largest=max; !isPrime[largest]; largest--)
{
System.out.println(largest);
}


明显要改成
for(largest=max;largest>1;largest--)
{
if(isPrime[largest])
System.out.println(largest);
}
才能输出正常结果。
有人分析下筛选法求素数和原来上面代码求素数的差别吗？

Answer 5

    /*
     *输出1000以内的全部素数
     */
    static boolean[] date;    public static void sn(int n) {
        if (date == null) {
            date = new boolean[n + 1];
            for (int i = 2, mi = n; i < mi; i++) {
                for (int j = i + i; j <= mi; j += i) {
                    date[j] = true;
                }
            }
        } else if (date.length < n + 1) {
            boolean[] bd = new boolean[n + 1];
            System.arraycopy(date, 0, bd, 0, date.length);
            date = bd;
            for (int i = 2, mi = n; i < mi; i++) {
                if (!date[i]) {
                    for (int j = i + i; j <= mi; j += i) {
                        date[j] = true;
                    }
                }
            }
        }
        for (int i = 2; i <= n; i++) {
            if (!date[i]) {
                System.out.print(i + ",");
            }
        }
        System.out.println("");
    }

Answer 6

这个是筛法求质数，ls的似乎不是啊
public static void main(String[] args) {
int max = 1000;
boolean[] arr = new boolean[max + 1];
arr[0] = true;
arr[1] = true;
for (int i = 0; i <= max; i++) {
if (arr[i])
continue;
System.out.println(i);
for (int j = i * 2; j <= max; j += i)
arr[j] = true;
}
}

Answer 7

//去掉重复的代码    public static void main(String[] args) {
//        A b = new B();
////        b.s();0
        long s = System.currentTimeMillis();
        sn(100000000);
        System.out.flush();
        long e = System.currentTimeMillis();
        System.out.println(e - s);
        s = System.currentTimeMillis();
        sn(200000000);
        System.out.flush();
        e = System.currentTimeMillis();
        System.out.println(e - s);
    }
    /*
     *输出1000以内的全部素数
     */
    static boolean[] date;    public static void sn(int n) {
        int ol = 0;
        if (date == null) {
            date = new boolean[n + 1];
            ol = 0;
        } else if (date.length < n + 1) {
            boolean[] bd = new boolean[n + 1];
            ol = date.length - 1;
            System.arraycopy(date, 0, bd, 0, date.length);
            date = bd;
        }
        for (int i = 2, mi = n; i < mi; i++) {
            if (!date[i]) {
                if (ol == 0) {
                    for (int j = i + i; j <= mi; j += i) {
                        date[j] = true;
                    }
                } else {
                    for (int j = i > ol + i ? i + i : ol / i * i + i; j <= mi; j += i) {
                        date[j] = true;
                    }
                }
            }
        }
        for (int i = 2; i <= n; i++) {
            if (!date[i]) {
                System.out.print(i + ",");
            }
        }
        System.out.println("");
    }

Answer 8

使用循环计算2＋22＋222＋2222+….的前10项之和
public static void main(String[] args) {
int i = 2;
int n = 10;
long sum = 0;
for (int j = n; j <= n; j++) {
sum *= 10;
sum += j;
}
sum *= i;
System.out.println(sum);
}

Answer 9

额，循环是for (int j = 1; j <= n; j++)

Answer 10

//上面是
/*                } else {
                    for (int j = i > ol ? i + i : ol / i * i + i; j <= mi; j += i) {
*///使用循环计算2＋22＋222＋2222+….的前10项之和 ，另外一种计算
        long sum = 0, n = 2;
        int t = 10;
        for (int i = 0; i < t; i++) {
            sum += n * Math.pow(10, i) * (t - i);
        }
        System.out.println("前10项的和:" + sum);

Answer 11

/*
*计算两个正整数的最大公约数和最小公倍数，要求从键盘输数。
*/
//最大公约数
public static int getMCD(int i, int j){
return j == 0 ? i : getMCD(j , i % j);
}

//最小共倍数
public static int getMCM(int i, int j){
return i / getMCD(i, j) * j;
}

Answer 12

/*
*输出1～1000之间能被3整除而不能被7整除的所有数 
*/
参数 m n t 本题 3 ， 7 ， 1000
 m 开始 步长 m 递增至 t，一个计数 逢 n 归 1 ；/*
*一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第10次落地时，共经过多少米？第10次反弹多高？
*/
等比数列求和，可以直接计算/*
*使用循环计算2＋22＋222＋2222+….的前10项之和
*/
建一个数组，长度为前 N 项中的 N ，本题为 10； 从头往后以 1 递增赋值， 满 10 回退一格加 1 ； 且适合大数运算/*
*计算1＋1/3+1/5++1/7+1/9+…的前10000项之和
*/
貌似可以用矩阵乘法，可以将时间复杂度降到 lg(n) ；没仔细想 不知道对否/*
*输出1000以内的全部素数
*/
筛选法

Answer 13

        /*
         *计算1＋1/3+1/5++1/7+1/9+…的前10000项之和
         */
        double sum = 0.0;
        for (int i = 1; i < 20000; i += 2) {
            sum += 1.0 / i;
        }
        System.out.println("前10000项之和:" + sum);        /////////////
        java.math.BigDecimal c = BigDecimal.ONE;//分子
        java.math.BigDecimal b = BigDecimal.ONE;//分母
        java.math.BigDecimal a = BigDecimal.ONE;
        int bit = 20;//保留的位数
        for (int i = 1; i < 10000; i++) {
            a = BigDecimal.valueOf(i * 2 - 1);
            c = c.multiply(a);//
            c = c.add(b);//c = c*a+b*1
            b = b.multiply(a);//b=b*a
        }
        System.out.println("前10000项之和(保留" + bit + "位小数):" + c.divide(b, bit, BigDecimal.ROUND_HALF_DOWN));
/*run：
前10000项之和:5.58692519920711
前10000项之和(保留20位小数):6.58687519670701143447*/

Answer 14

        java.math.BigDecimal c = BigDecimal.ONE;//分子
        java.math.BigDecimal b = BigDecimal.ONE;//分母
        java.math.BigDecimal a = BigDecimal.ONE;
        int bit = 20;//保留的位数
        for (int i = 2; i < 10000; i++) {/////多算了一个1
            a = BigDecimal.valueOf(i * 2 - 1);
            c = c.multiply(a);//
            c = c.add(b);//c = c*a+b*1
            b = b.multiply(a);//b=b*a
        }
        System.out.println("前10000项之和(保留" + bit + "位小数):" + c.divide(b, bit, BigDecimal.ROUND_HALF_DOWN));