数学方法_arfken数学物理方法答案-CSDN博客

本文链接：https://blog.csdn.net/wuwu12dfda/article/details/84970399

1 寻找素数

原理：若一个数不是素数则必有小于它的数为其因子。

方法：素数遍历法。遍历所有范围内整数，若当前整数不是小于自身的素数整数倍则标记为素数。

题目描述

输入一个整数n(2<=n<=10000)，要求输出所有从1到这个整数之间(不包括1和这个整数)个位为1的素数，如果没有则输出-1。

输入输入有多组数据。每组一行，输入n。

输出：输出所有从1到这个整数之间(不包括1和这个整数)个位为1的素数(素数之间用空格隔开，最后一个素数后面没有空格)，如果没有则输出-1。

样例输入

样例输出

11 31 41 61

import java.util.Scanner;
 
public class Main{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            int n=sc.nextInt();
            boolean mark[]=new boolean[n+1]; //默认为false
            for(int i=0;i<=n;i++){
                mark[i]=true;//修改为默认素有数据为素数，为了后面代码好写
            }
            for(int i=2;i<n;i++){
                if(mark[i]==false){
                    continue; //下面那个for循环就不执行了
                }
                //素数的倍数为非素数，j+=i则是倍数的逐渐叠加
                for(int j=i*i;j<=n;j+=i){
                    mark[j]=false;
                }
            }
            int flag=0;//作为标记，最后一个数没有空格
            for(int i=2;i<n;i++){
                if(mark[i]&& i%10==1){
                    if(flag==0){
                        System.out.print(i);
                        flag++;
                    }else{
                        System.out.print(" "+i);
                    }
                }
            }
            if(flag==0)
                System.out.println("-1");
        }
    }
}

View Code

2 质因数的分解

题目描述
求正整数N(N>1)的质因数的个数。相同的质因数需要重复计算。如120=2*2*2*3*5，共有5个质因数。
输入描述:
可能有多组测试数据，每组测试数据的输入是一个正整数N，(1<N<10^9)。
输出描述:
对于每组数据，输出N的质因数的个数。
示例1
输入
120
输出
5

 1 package Test;
 2 
 3 import java.util.Map;
 4 import java.util.Scanner;
 5 import java.util.TreeMap;
 6 
 7 public class Main{
 8     public static void main(String[] args) {
 9         Scanner sc= new Scanner(System.in);
10         while(sc.hasNext()){
11             int n=sc.nextInt();
12             int count=0;
13             while(true){
14                 boolean flag=false;
15                 //每次都从2开始，确保不会有少算的
16                 for(int i=2;i<=Math.sqrt(n);i++){
17                     if(n%i==0){
18                         count++;
19                         n/=i;
20                         flag=true;
21                         break;
22                     }
23                 }
24                 //最后一个质数是其本身，要加一
25                 if(!flag){
26                     count++;
27                     break;
28                 }
29             }
30             System.out.println(count);
31         }
32     }
33 }

3 买房子

题目描述
某程序员开始工作，年薪N万，他希望在中关村公馆买一套60平米的房子，现在价格是200万，假设房子价格以每年百分之K增长，并且该程序员未来年薪不变，且不吃不喝，不用交税，每年所得N万全都积攒起来，问第几年能够买下这套房子（第一年房价200万，收入N万）
输入描述:
有多行，每行两个整数N（10<=N<=50）, K（1<=K<=20）
输出描述:
针对每组数据，如果在第21年或者之前就能买下这套房子，则输出一个整数M，表示最早需要在第M年能买下，否则输出Impossible，输出需要换行
示例1
输入
50 10
40 10
40 8
输出
8
Impossible
10

 1 package Test;
 2 
 3 import java.util.Scanner;
 4 
 5 public class Main{
 6     public static void main(String[] args) {
 7         Scanner sc= new Scanner(System.in);
 8         while(sc.hasNext()){    
 9             int n=sc.nextInt();
10             int k=sc.nextInt();
11             int year=-1;
12             for(int i=1;i<=21;i++){
13                 float f=(float)(200*Math.pow(1+k*1.0/100, i-1));//第一年还没有涨价
14                 if(n*i>=f){
15                     year=i;
16                     break;
17                 }                
18             }
19             if(year<0)
20                 System.out.println("Impossible");
21             else
22                 System.out.println(year);
23         }
24         
25     }    
26 }

4 递推数列

题目描述
给定a0,a1,以及an=p*a(n-1) + q*a(n-2)中的p,q。这里n >= 2。求第k个数对10000的模。
输入描述:
输入包括5个整数：a0、a1、p、q、k。
输出描述:
第k个数a(k)对10000的模。
示例1
输入
20 1 1 14 5
输出
8359

 1 package Test;
 2 
 3 import java.util.Arrays;
 4 import java.util.Scanner;
 5 
 6 public class Main{
 7     public static void main(String[] args) {
 8         Scanner sc=new Scanner(System.in);
 9         while(sc.hasNext()){
10             int a0=sc.nextInt();
11             int a1=sc.nextInt();
12             int p=sc.nextInt();
13             int q=sc.nextInt();
14             int k=sc.nextInt();
15             //把递归做成了for循环，用数组来替换
16             int[] dp=new int[k+1];
17             dp[0]=a0;
18             dp[1]=a1;
19             //要求对10000的模，低位取模可以减少运算量避免大数运算
20             for(int i=2;i<=k;i++){
21                 dp[i]=(p*dp[i-1]%10000+q*dp[i-2]%10000)%10000;
22             }
23             System.out.println(dp[k]);
24         }
25     }
26 }

5 鸡兔同笼

题目描述
一个笼子里面关了鸡和兔子（鸡有2只脚，兔子有4只脚，没有例外）。已经知道了笼子里面脚的总数a，问笼子里面至少有多少只动物，至多有多少只动物。
输入描述:
每组测试数据占1行，每行一个正整数a (a < 32768)
输出描述:
输出包含n行，每行对应一个输入,包含两个正整数，第一个是最少的动物数，第二个是最多的动物数，两个正整数用一个空格分开
如果没有满足要求的答案，则输出两个0。
示例1
输入
3
输出
0 0

 1 import java.util.Scanner;
 2 /*
 3  * 编程思路： 鸡有2只脚，兔子为4，都是2的倍数，当不能被2整除时，必然不存在
 4  * 最多的就是全部都是鸡的情况，最少是全为兔子，但要考虑到此时也可能有部分的鸡
 5  */
 6 
 7 public class Main{
 8     public static void main(String[] args) {
 9         Scanner sc=new Scanner(System.in);
10         while(sc.hasNext()){
11             int n=sc.nextInt();
12             if(n%2!=0){
13                 System.out.println("0 0");
14             }else{
15                 int max=n/2;
16                 int min=n/4+n%4/2;
17                 System.out.println(min+" "+max);
18             }
19         }
20     }
21 }

6 矩阵最大值

题目描述
编写一个程序输入一个mXn的矩阵存储并输出，并且求出每行的最大值和每行的总和。要求把每行总和放入每行最大值的位置，如果有多个最大值，取下标值最小的那一个作为最大值。最后将结果矩阵输出。
输入描述:
输入的第一行包括两个整数m和n(1<=m,n<=100)，分别代表矩阵的行和列的维数。
接下来的m行每行有n个数，代表矩阵的元素。
输出描述:
可能有多组测试数据，对于每组数据，输出按题目要求执行后的矩阵。
示例1
输入
3 3
1 1 1
1 1 1
1 1 1
3 3
3 2 3
2 3 2
3 2 3
输出
3 1 1
3 1 1
3 1 1
8 2 3
2 7 2
8 2 3

 1 package Test;
 2 
 3 import java.util.Arrays;
 4 import java.util.Scanner;
 5 
 6 
 7 public class Main{
 8     public static void main(String[] args) {
 9         Scanner sc=new Scanner(System.in);
10         while(sc.hasNext()){
11             int m=sc.nextInt();
12             int n=sc.nextInt();
13             String[][] str=new String[m][n];
14             String a=sc.nextLine();//接收换行符，因为nextLine是遇到换行符存储，在输入m n后就会有多余的换行符
15             for(int i=0;i<m;i++)
16                 str[i]=sc.nextLine().split(" ");
17             
18             for(int i=0;i<m;i++){
19                 int maxIndex=findMax(str[i]);//得到每一行的最大索引位置
20                 str[i][maxIndex]=sum(str[i]);//将每一行的和放在最大索引处
21                 for(int j=0;j<n-1;j++){
22                     System.out.print(str[i][j]+" ");
23                 }
24                 System.out.print(str[i][n-1]);
25                 System.out.println();
26             }
27         }        
28     }
29     //求和
30     public static String sum(String[] str){
31         int sum=0;
32         for(int i=0;i<str.length;i++){
33             sum+=Integer.parseInt(str[i]);
34         }
35         return sum+"";//要返回的必须是字符串形式
36     }
37     //比较数值大小
38     public static int findMax(String[] str){
39         int index=0;
40         for(int i=0;i<str.length;i++){
41             if(Integer.parseInt(str[index])<Integer.parseInt(str[i]))
42                 index=i;
43         }
44         return index;
45     }
46 }