杭电ACM 1030 Delta-wave java代码解析
最后更新于：2022-04-01 09:48:49
~~~
# Delta-wave
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 6931 Accepted Submission(s): 2674
~~~
Problem Description
A triangle field is numbered with successive integers in the way shown on the picture below.
The traveller needs to go from the cell with number M to the cell with number N. The traveller is able to enter the cell through cell edges only, he can not travel from cell to cell through vertices. The number of edges the traveller passes makes the length of the traveller's route.
Write the program to determine the length of the shortest route connecting cells with numbers N and M.
Input
Input contains two integer numbers M and N in the range from 1 to 1000000000 separated with space(s).
Output
Output should contain the length of the shortest route.
Sample Input
~~~
6 12
~~~
Sample Output
~~~
3
~~~
**求最近的路径的大小，本质上这个题中每一个块可以表示为三个坐标的形式，那就是水平方向的第几层，左侧的左侧第几列，右侧看右侧第几列，比如说：1这个元素在水平第1层，左侧第1列，右侧第1列； 6这个元素是水平第3层，左侧第2层，右侧第1层，那么1到6的计算就是这三个坐标的差的绝对值之和：2+1+0 = 3 ，也就是说1到6需要3步。**
剩下的自然是怎么求出来各个方向上的位置咯：水平方向是level = sqrt(num - 1) + 1，左侧的坐标可以表示为：left = ( level*level - num）/ 2 +1，
右侧的坐标可以表示为：right = （num- (level-1)*(level-1) - 1）/ 2 + 1
那么剩下的就是将两个点的三个坐标的值对应求差然后去绝对值再求和就可以了
~~~
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while(scanner.hasNext())
{
int num1 = scanner.nextInt();
int num2 = scanner.nextInt();
int level1 = (int)Math.sqrt(num1 - 1) + 1;
int left4num1 = (level1*level1 - num1)/2 + 1;
int right4num1 = (num1 - (level1 - 1) * (level1 - 1) - 1)/2 + 1;
int level2 = (int)Math.sqrt(num2 - 1) + 1;
int left4num2 = (level2*level2 - num2)/2 + 1;
int right4num2 = (num2 - (level2 - 1) * (level2 - 1) - 1)/2 + 1;
System.out.println(Math.abs(level1 - level2) + Math.abs(left4num1 - left4num2) + Math.abs(right4num1 - right4num2));
}
}
}
~~~
杭电ACM 1041 Computer Transformation java代码详解AC
最后更新于：2022-04-01 09:48:46
~~~
# Computer Transformation
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 6916 Accepted Submission(s): 2504
~~~
Problem Description
A sequence consisting of one digit, the number 1 is initially written into a computer. At each successive time step, the computer simultaneously tranforms each digit 0 into the sequence 1 0 and each digit 1 into the sequence 0 1. So, after the first time step, the sequence 0 1 is obtained; after the second, the sequence 1 0 0 1, after the third, the sequence 0 1 1 0 1 0 0 1 and so on.
How many pairs of consequitive zeroes will appear in the sequence after n steps?
Input
Every input line contains one natural number n (0 < n ≤1000).
Output
For each input n print the number of consecutive zeroes pairs that will appear in the sequence after n steps.
Sample Input
~~~
2
3
~~~
Sample Output
~~~
1
1
~~~
本题看起来也不难，但是注意一个问题就是当输入的数值达到大约在40左右的时候，普通的int类型的数据就会发生溢出，无法存放这么大的数字，这就是大数啦，所以需要你特别的对大数进行一定的处理才能使得不发生溢出。一开始我做的时候就是没有考虑到这个问题所以感觉结果明明是对的呀，但是就是一直出错，后来终于发现大数溢出的问题，稍微改了下就好了。
~~~
import java.math.BigDecimal;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while(scanner.hasNext())
{
int num = scanner.nextInt();
BigDecimal sum = new BigDecimal(0);
sum = funct(num);
System.out.println(sum);
}
}
public static BigDecimal funct(int i) {
BigDecimal[] array = new BigDecimal[i+1];
int sum = 0;
array[1] = new BigDecimal(0);
if(i == 1)
return array[1];
array[2] = new BigDecimal(1);
for(int j = 3; j <= i ; j++)
{
array[j] = array[j - 1].add(array[j - 2].multiply(new BigDecimal(2))) ;
}
return array[i];
}
}
~~~
杭电ACM 1040 As Easy As A+B java 解读
最后更新于：2022-04-01 09:48:44
~~~
# As Easy As A+B
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 48014 Accepted Submission(s): 20587
~~~
Problem Description
These days, I am thinking about a question, how can I get a problem as easy as A+B? It is fairly difficulty to do such a thing. Of course, I got it after many waking nights.
Give you some integers, your task is to sort these number ascending (升序).
You should know how easy the problem is now!
Good luck!
Input
Input contains multiple test cases. The first line of the input is a single integer T which is the number of test cases. T test cases follow. Each test case contains an integer N (1<=N<=1000 the number of integers to be sorted) and then N integers follow in the same line.
It is guarantied that all integers are in the range of 32-int.
Output
For each case, print the sorting result, and one line one case.
Sample Input
~~~
2
3 2 1 3
9 1 4 7 2 5 8 3 6 9
~~~
Sample Output
~~~
1 2 3
1 2 3 4 5 6 7 8 9
~~~
题目的大意为：第一行输入你要输入几行的数据，然后第一列的数据是表示本行上有多少个数据，对其进行排序即可
~~~
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
int i = 0, j = 0, num2 = 0, m = 0, num3 = 0;
List listTemp = new ArrayList();
Object[] object = new Object[num];
while(i < num)
{
num2 = scanner.nextInt();
List list = new ArrayList();
object[i] = new Object();
for(j = 0; j < num2; j++)
{
num3 = scanner.nextInt();
list.add(num3);
}
list = sort2(list.toArray());
object[i] = list;
i++;
}
for(i = 0; i < object.length; i++)
{
listTemp = (List) object[i];
for(j = 0; j < listTemp.size(); j++)
{
if(j == 0)
System.out.print(listTemp.get(j));
else
System.out.print(" " + listTemp.get(j));
}
System.out.println();
}
}
private static List sort2(Object[] objects) {
List listTemp = new ArrayList();
int num1, num2, temp;
Object obj = null;
for(int i = 0; i < objects.length; i++)
{
num1 = Integer.parseInt(objects[i].toString());
for(int j = i; j < objects.length; j++)
{
num2 = Integer.parseInt(objects[j].toString());
if(num1 > num2)
{
temp = num1;
num1 = num2;
num2 = temp;
obj = objects[i];
objects[i] = objects[j];
objects[j] = obj;
}
}
listTemp.add(num1);
}
//System.out.println(listTemp);
return listTemp;
}
}
~~~
杭电1047 An Easy Task – java 解读
最后更新于：2022-04-01 09:48:42
~~~
# An Easy Task
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 17866 Accepted Submission(s): 11383
~~~
Problem Description
Ignatius was born in a leap year, so he want to know when he could hold his birthday party. Can you tell him?
Given a positive integers Y which indicate the start year, and a positive integer N, your task is to tell the Nth leap year from year Y.
Note: if year Y is a leap year, then the 1st leap year is year Y.
Input
The input contains several test cases. The first line of the input is a single integer T which is the number of test cases. T test cases follow.
Each test case contains two positive integers Y and N(1<=N<=10000).
Output
For each test case, you should output the Nth leap year from year Y.
Sample Input
~~~
3
2005 25
1855 12
2004 10000
~~~
Sample Output
~~~
2108
1904
43236
Hint
We call year Y a leap year only if (Y%4==0 && Y%100!=0) or Y%400==0.
题目大意是：输入一个整数控制输入的数据的组数，以下输入哪一年 第几个闰年，闰年的判断标准是：年数除以4余数为0并且除以100余数不为0，或者年数是400的整数倍，到达第几个闰年的时候输出年数。
~~~
~~~
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
int i = 0, num_year = 0, num_times = 0, count = 0;
List<Integer> list = new ArrayList<Integer>();
while(i < num)
{
count = 0;
num_year = scanner.nextInt();
num_times = scanner.nextInt();
while(count < num_times)
{
if (num_year%4==0 && num_year%100!=0 || num_year%400==0)
{
count++;
}
if(count == num_times)
{
list.add(num_year);
}
num_year ++;
}
i++;
}
for(i = 0; i < list.size(); i++)
{
System.out.println(list.get(i));
}
}
}
~~~
杭电ACM 1020 Encoding java解析
最后更新于：2022-04-01 09:48:39
~~~
# Encoding
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 34681 Accepted Submission(s): 15377
~~~
Problem Description
Given a string containing only 'A' - 'Z', we could encode it using the following method:
1. Each sub-string containing k same characters should be encoded to "kX" where "X" is the only character in this sub-string.
2. If the length of the sub-string is 1, '1' should be ignored.
Input
The first line contains an integer N (1 <= N <= 100) which indicates the number of test cases. The next N lines contain N strings. Each string consists of only 'A' - 'Z' and the length is less than 10000.
Output
For each test case, output the encoded string in a line.
Sample Input
~~~
2
ABC
ABBCCC
~~~
Sample Output
ABC
A2B3C解题思路整理：对字符串进行遍历，如果当前的字符与前面的字符相同的话那么我加1记录其个数，如果不相同的时候，排除只有1个的情况，只有在字符重复个数大于1的时候那么认为是有多个在一起，这是将字符串拼接组成新的串继续下一步操作。
~~~
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int count = scanner.nextInt();
int i = 0, countNum = 0, j = 0, j2 = 0;
String str ;
String str2 = "";
char sCopy = 0;
List<String> list = new ArrayList<String>();
while(i < count)
{
str = scanner.next();
sCopy = 0;
j = 0;
str2 = "";
countNum = 0;
while(j < str.length())
{
if(sCopy != str.charAt(j))
{
if(countNum > 1)
{
str2 = str2 + countNum + sCopy;
}
else if(j != 0)
str2 = str2 + sCopy;
countNum = 0;
sCopy = str.charAt(j);
}
if(sCopy == str.charAt(j))
{
countNum++;
}
j++;
if(j == str.length())
{
if(countNum > 1)
{
str2 = str2 + countNum + sCopy;
}
else if(j != 0)
str2 = str2 + sCopy;
list.add(str2);
}
}
i++;
}
for(i = 0; i < count; i++)
{
System.out.println(list.get(i));
}
}
}
~~~
杭电ACM 1012 u Calculate e java
最后更新于：2022-04-01 09:48:37
~~~
# u Calculate e
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 37341 Accepted Submission(s): 16897
~~~
Problem Description
A simple mathematical formula for e is
where n is allowed to go to infinity. This can actually yield very accurate approximations of e using relatively small values of n.
Output
Output the approximations of e generated by the above formula for the values of n from 0 to 9. The beginning of your output should appear similar to that shown below.
Sample Output
~~~
n e
- -----------
0 1
1 2
2 2.5
3 2.666666667
4 2.708333333
题目大意为：求出0-9的情况下这个公式求出来的e的值是多少，从结果可以看出来，0和1的时候保留整数部分，2的时候保留一位小数，3,4以及以后的时候保留九位小数。
~~~
~~~
import java.text.DecimalFormat;
public class Main{
public static void main(String[] args) {
double sum = 0;
System.out.println("n e");
System.out.println("- -----------");
for(int i = 0; i < 10; i++)
{
sum += 1.0 / functionMuti(i);
if( i == 0 || i == 1)
{
DecimalFormat decimalForm = new DecimalFormat("0");
System.out.println(i + " " + decimalForm.format(sum));
}
else if(i == 2)
{
DecimalFormat decimalForm = new DecimalFormat("0.0");
System.out.println(i + " " + decimalForm.format(sum));
}
else
{
DecimalFormat decimalForm = new DecimalFormat("0.000000000");
System.out.println(i + " " + decimalForm.format(sum));
}
}
}
private static int functionMuti(int i) {
if(i == 1)
return 1;
else if(i == 0)
return 1;
else
{
return i * functionMuti(--i);
}
}
}
~~~
杭电ACM1106排序Java代码
最后更新于：2022-04-01 09:48:35
#### 排序
~~~
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 43680 Accepted Submission(s): 12476
~~~
Problem Description
输入一行数字，如果我们把这行数字中的‘5’都看成空格，那么就得到一行用空格分割的若干非负整数（可能有些整数以‘0’开头，这些头部的‘0’应该被忽略掉，除非这个整数就是由若干个‘0’组成的，这时这个整数就是0）。
你的任务是：对这些分割得到的整数，依从小到大的顺序排序输出。
Input
输入包含多组测试用例，每组输入数据只有一行数字（数字之间没有空格），这行数字的长度不大于1000。
输入数据保证：分割得到的非负整数不会大于100000000；输入数据不可能全由‘5’组成。
Output
对于每个测试用例，输出分割得到的整数排序的结果，相邻的两个整数之间用一个空格分开，每组输出占一行。
Sample Input
~~~
0051231232050775
~~~
Sample Output
0 77 12312320
该题看起来简单，但是实际上则没那么简单，给出的测试用例只是普通的情况，有很多情况并没有给你列出来，比如5551、255、1552等等的情况我思路是先去掉头部和尾部的5，然后将字符串中间的临近的几个5合并为1个5那么这样再通过字符串的切割即可以保证切割出来的数组中不存在空的情况，这样也就保证了转为整形时候的正确性，然后再对数组进行排序就可以了
~~~
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String str = "";
int indexStart = -1;
int indexEnd = -1;
int count = 0;
while(scanner.hasNext())
{
str = scanner.nextLine();
if(str != "" && str.trim().length() > 0)
{
while(str.charAt(0) == '5'|| str.charAt(str.length()-1) == '5')
{
if(str.charAt(0) == '5')
str = str.substring(1, str.length());
if(str.charAt(str.length()-1) == '5')
str = str.substring(0, str.length()-1);
}
// System.out.println(str);
int i = 0;
boolean bool = false;
while(i < str.length() )
{
if(str.charAt(i) == '5' && count == 0)
{
indexStart = i;
}
if(str.charAt(i) == '5')
{
count++;
indexEnd = i;
}
if(str.charAt(i) != '5')
{
if(count > 1 && indexStart != -1 && indexEnd != -1)
{
if(indexEnd < str.length() && indexStart > 0)
str = str.subSequence(0, indexStart) +""+ str.subSequence(indexEnd, str.length());
else if(indexEnd == str.length())
str = str.subSequence(0, indexStart) + "";
else if(indexStart == 0 && indexEnd < str.length())
str = str.subSequence(indexEnd, str.length()) + "";
bool = true;
}
count = 0;
indexStart = -1;
indexEnd = -1;
}
if(bool)
{
i = 0;
bool = false;
}
else
{
i++;
}
}
// System.out.println(str);
String[] numStr = str.split("5");
int[] nums = new int[numStr.length];
for(i =0; i < numStr.length; i++)
{
if(numStr[i] != "")
nums[i] = Integer.parseInt(numStr[i]);
}
nums = sort(nums);
for(int m =0; m < nums.length; m++)
{
if(m != 0)
System.out.print(" " + nums[m]);
else
System.out.print(nums[m]);
}
System.out.println();
}
}
}
private static int[] sort(int[] nums) {
// TODO Auto-generated method stub
for(int j = 0; j < nums.length - 1; j++)
{
for(int k = j + 1; k < nums.length; k++)
{
if(nums[j] > nums[k])
{
int temp = nums[j];
nums[j] = nums[k];
nums[k] = temp;
}
}
}
return nums;
}
}
~~~
杭电ACM1088 Write a simple HTML Browser Java
最后更新于：2022-04-01 09:48:33
~~~
# Write a simple HTML Browser
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 9459 Accepted Submission(s): 2678
~~~
Problem Description
If you ever tried to read a html document on a Macintosh, you know how hard it is if no Netscape is installed.
Now, who can forget to install a HTML browser? This is very easy because most of the times you don't need one on a MAC because there is a Acrobate Reader which is native to MAC. But if you ever need one, what do you do?
Your task is to write a small html-browser. It should only display the content of the input-file and knows only the html commands (tags) <br> which is a linebreak and <hr> which is a horizontal ruler. Then you should treat all tabulators, spaces and newlines as one space and display the resulting text with no more than 80 characters on a line.
Input
The input consists of a text you should display. This text consists of words and HTML tags separated by one or more spaces, tabulators or newlines.
A word is a sequence of letters, numbers and punctuation. For example, "abc,123" is one word, but "abc, 123" are two words, namely "abc," and "123". A word is always shorter than 81 characters and does not contain any '<' or '>'. All HTML tags are either <br> or <hr>.
Output
You should display the the resulting text using this rules:
. If you read a word in the input and the resulting line does not get longer than 80 chars, print it, else print it on a new line.
. If you read a <br> in the input, start a new line.
. If you read a <hr> in the input, start a new line unless you already are at the beginning of a line, display 80 characters of '-' and start a new line (again).
The last line is ended by a newline character.
Sample Input
~~~
Hallo, dies ist eine
ziemlich lange Zeile, die in Html
aber nicht umgebrochen wird.
<br>
Zwei <br> <br> produzieren zwei Newlines.
Es gibt auch noch das tag <hr> was einen Trenner darstellt.
Zwei <hr> <hr> produzieren zwei Horizontal Rulers.
Achtung mehrere Leerzeichen irritieren
Html genauso wenig wie
mehrere Leerzeilen.
~~~
Sample Output
~~~
Hallo, dies ist eine ziemlich lange Zeile, die in Html aber nicht umgebrochen
wird.
Zwei
produzieren zwei Newlines. Es gibt auch noch das tag
--------------------------------------------------------------------------------
was einen Trenner darstellt. Zwei
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
produzieren zwei Horizontal Rulers. Achtung mehrere Leerzeichen irritieren Html
genauso wenig wie mehrere Leerzeilen.
~~~
~~~
import java.util.Scanner;
public class Main{
/**
* @param args
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String str = "",strCom = "",strComCopys = "", strCopy = "";
int countNum = 0;
while(scanner.hasNext())
{
str = scanner.next();
if(str.equals("<br>"))
{
strCom = "";
System.out.println();
}
else if(str.equals("<hr>"))
{
if(strCom.length() > 0)
System.out.println("\r\n--------------------------------------------------------------------------------");
else
System.out.println("--------------------------------------------------------------------------------");
strCom = "";
}
else if(str != " " && str.trim().length() > 0)
{
strComCopys = strCom;
if(strCom.length() > 0)
strCom += " " + str;
else
strCom += str;
countNum = strComCopys.length();
if(strCom.length() > 80)
{
System.out.println();
strCom = str;
countNum = 0;
strComCopys = "";
}
if(countNum == 0)
System.out.print(str);
else
System.out.print(" " + str);
}
strCopy = str;
}
System.out.println();
scanner.close();
}
}
~~~
杭电ACM1018BigNumber解析
最后更新于：2022-04-01 09:48:30
~~~
# Big Number
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 31542 Accepted Submission(s): 14684
~~~
Problem Description
In many applications very large integers numbers are required. Some of these applications are using keys for secure transmission of data, encryption, etc. In this problem you are given a number, you have to determine the number of digits in the factorial of the number.
Input
Input consists of several lines of integer numbers. The first line contains an integer n, which is the number of cases to be tested, followed by n lines, one integer 1 ≤ n ≤ 107 on each line.
Output
The output contains the number of digits in the factorial of the integers appearing in the input.
Sample Input
~~~
2
10
20
~~~
Sample Output
~~~
7
19
一开始看见这道题目不是很明白到底是什么意思，搞了好久才明白是：给一个数规定输入数字的个数，案例中给出了2也就是输入2个数，输入的这两个数求它的阶乘的位数，一开始想着是这样做：直接求指出然后求长度，这是最不需要动脑子的方法，但是，这个方法并不奏效，因为阶乘的数值是很大的，普通的int,long类型一旦求比较大的数的阶乘的时候往往会溢出，所以最好的方法应该是避免求他的值才行。
斯特林公式就可以用于求这个阶乘的位数，斯特林公式（Stirling's approximation）是一条用来取n的阶乘的近似值的数学公式。一般来说，当n很大的时候，n阶乘的计算量十分大，所以斯特林公式十分好用，而且，即使在n很小的时候，斯特林公式的取值已经十分准确。
上式两边同时取log10，得到的是log10(n!) = log10(2*pi*n)/2+n*log10(n/e)所以其位数应该可以表示为： log10(2*pi*n)/2+n*log10(n/e)+1
~~~
~~~~
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
int[] nums = new int[num];
int num_digit = 0;
double d = 1;
int i = 0;
while(i < num)
{
num_digit = scanner.nextInt();
if(num_digit >= 2)
{
d = Math.log10(2 * Math.PI * num_digit) / 2 + num_digit * Math.log10(num_digit / Math.E) + 1;
}
nums[i] = (int)d;
i++;
}
//System.out.println("=====");
for(i = 0 ; i < num; i++)
{
System.out.println(nums[i]);
}
}
}
~~~
另外其他的方法还有
位数= log10(1) + log10(2) + log10(3) + ...... + log10(n) 取整数部分后+1
杭电ACMA + B Problem II问题解析
最后更新于：2022-04-01 09:48:28
~~~
# A + B Problem II
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 273307 Accepted Submission(s): 52784
~~~
Problem Description
I have a very simple problem for you. Given two integers A and B, your job is to calculate the Sum of A + B.
Input
The first line of the input contains an integer T(1<=T<=20) which means the number of test cases. Then T lines follow, each line consists of two positive integers, A and B. Notice that the integers are very large, that means you should not process them by using 32-bit integer. You may assume the length of each integer will not exceed 1000.
Output
For each test case, you should output two lines. The first line is "Case #:", # means the number of the test case. The second line is the an equation "A + B = Sum", Sum means the result of A + B. Note there are some spaces int the equation. Output a blank line between two test cases.
Sample Input
~~~
2
1 2
112233445566778899 998877665544332211
~~~
Sample Output
~~~
Case 1:
1 + 2 = 3
Case 2:
112233445566778899 + 998877665544332211 = 1111111111111111110
~~~
~~~
import java.math.BigDecimal;
import java.util.Scanner;
// 代码提交时改为Main且去掉当前文件的包名
public class Main {
public static void main(String[] args) {
/**
* 从题目中可以看出来，数据比较大，只是用普通的整形或者别的恐怕是无能为力，不过BigDecimal对于数据较大的数处理十分的方便
* 而且封装好了函数只需要调用就可以了
*/
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
// 这里的二维数组也需要有些讲究，一般一行中查找不同的列的速度要比一列中查找不同的行的数据要快
BigDecimal[][] bigNum = new BigDecimal[num][2];
for(int i = 0; i < num; i++)
{
bigNum[i][0] = scanner.nextBigDecimal();
bigNum[i][1] = scanner.nextBigDecimal();
}
// 输出的时候注意空格，以及的空行
for(int j = 0; j < num; j++)
{
if(j != 0)
System.out.println();
System.out.println("Case "+(j+1)+":");
System.out.println(bigNum[j][0] +" + "+ bigNum[j][1]+" = "+ bigNum[j][0].add(bigNum[j][1]));
}
}
}
~~~
Java经典算法四十例编程详解+程序实例
最后更新于：2022-04-01 09:48:26
~~~
JAVA经典算法40例
【程序1】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？
1.程序分析： 兔子的规律为数列1,1,2,3,5,8,13,21....
public class exp2{
public static void main(String args[]){
int i=0;
for(i=1;i<=20;i++)
System.out.println(f(i));
}
public static int f(int x)
{
if(x==1 || x==2)
return 1;
else
return f(x-1)+f(x-2);
}
}
或
public class exp2{
public static void main(String args[]){
int i=0;
math mymath = new math();
for(i=1;i<=20;i++)
System.out.println(mymath.f(i));
}
}
class math
{
public int f(int x)
{
if(x==1 || x==2)
return 1;
else
return f(x-1)+f(x-2);
}
}
【程序2】 题目：判断101-200之间有多少个素数，并输出所有素数。
1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，
则表明此数不是素数，反之是素数。
public class exp2{
public static void main(String args[]){
int i=0;
math mymath = new math();
for(i=2;i<=200;i++)
if(mymath.iszhishu(i)==true)
System.out.println(i);
}
}
class math
{
public int f(int x)
{
if(x==1 || x==2)
return 1;
else
return f(x-1)+f(x-2);
}
public boolean iszhishu(int x)
{
for(int i=2;i<=x/2;i++)
if (x % 2==0 )
return false;
return true;
}
}
【程序3】 题目：打印出所有的 "水仙花数 "，所谓 "水仙花数 "是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个 "水仙花数 "，因为153=1的三次方＋5的三次方＋3的三次方。
1.程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。
public class exp2{
public static void main(String args[]){
int i=0;
math mymath = new math();
for(i=100;i<=999;i++)
if(mymath.shuixianhua(i)==true)
System.out.println(i);
}
}
class math
{
public int f(int x)
{
if(x==1 || x==2)
return 1;
else
return f(x-1)+f(x-2);
}
public boolean iszhishu(int x)
{
for(int i=2;i<=x/2;i++)
if (x % i==0 )
return false;
return true;
}
public boolean shuixianhua(int x)
{
int i=0,j=0,k=0;
i=x / 100;
j=(x % 100) /10;
k=x % 10;
if(x==i*i*i+j*j*j+k*k*k)
return true;
else
return false;
}
}
【程序4】 题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。
程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果n <> k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你,重复执行第一步。
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
public class exp2{
public exp2(){}
public void fengjie(int n){
for(int i=2;i<=n/2;i++){
if(n%i==0){
System.out.print(i+"*");
fengjie(n/i);
}
}
System.out.print(n);
System.exit(0);///不能少这句，否则结果会出错
}
public static void main(String[] args){
String str="";
exp2 c=new exp2();
str=javax.swing.JOptionPane.showInputDialog("请输入N的值（输入exit退出）：");
int N;
N=0;
try{
N=Integer.parseInt(str);
}catch(NumberFormatException e){
e.printStackTrace();
}
System.out.print(N+"分解质因数："+N+"=");
c.fengjie(N);
}
}
【程序5】 题目：利用条件运算符的嵌套来完成此题：学习成绩> =90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
1.程序分析：(a> b)?a:b这是条件运算符的基本例子。
import javax.swing.*;
public class ex5 {
public static void main(String[] args){
String str="";
str=JOptionPane.showInputDialog("请输入N的值（输入exit退出）：");
int N;
N=0;
try{
N=Integer.parseInt(str);
}
catch(NumberFormatException e){
e.printStackTrace();
}
str=(N>90?"A":(N>60?"B":"C"));
System.out.println(str);
}
}
【程序6】 题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
1.程序分析：利用辗除法。
最大公约数：
public class CommonDivisor{
public static void main(String args[])
{
commonDivisor(24,32);
}
static int commonDivisor(int M, int N)
{
if(N<0||M<0)
{
System.out.println("ERROR!");
return -1;
}
if(N==0)
{
System.out.println("the biggest common divisor is :"+M);
return M;
}
return commonDivisor(N,M%N);
}
}
最小公倍数和最大公约数：
import java.util.Scanner;
public class CandC
{
//下面的方法是求出最大公约数
public static int gcd(int m, int n)
{
while (true)
{
if ((m = m % n) == 0)
return n;
if ((n = n % m) == 0)
return m;
}
}
public static void main(String args[]) throws Exception
{
//取得输入值
//Scanner chin = new Scanner(System.in);
//int a = chin.nextInt(), b = chin.nextInt();
int a=23; int b=32;
int c = gcd(a, b);
System.out.println("最小公倍数：" + a * b / c + "\n最大公约数：" + c);
}
}
【程序7】 题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
1.程序分析：利用while语句,条件为输入的字符不为 '\n '.
import java.util.Scanner;
public class ex7 {
public static void main(String args[])
{
System.out.println("请输入字符串：");
Scanner scan=new Scanner(System.in);
String str=scan.next();
String E1="[\u4e00-\u9fa5]";
String E2="[a-zA-Z]";
int countH=0;
int countE=0;
char[] arrChar=str.toCharArray();
String[] arrStr=new String[arrChar.length];
for (int i=0;i<arrChar.length ;i++ )
{
arrStr[i]=String.valueOf(arrChar[i]);
}
for (String i: arrStr )
{
if (i.matches(E1))
{
countH++;
}
if (i.matches(E2))
{
countE++;
}
}
System.out.println("汉字的个数"+countH);
System.out.println("字母的个数"+countE);
}
}
【程序8】 题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。
1.程序分析：关键是计算出每一项的值。
import java.io.*;
public class Sumloop {
public static void main(String[] args) throws IOException
{
int s=0;
String output="";
BufferedReader stadin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入a的值");
String input =stadin.readLine();
for(int i =1;i<=Integer.parseInt(input);i++)
{
output+=input;
int a=Integer.parseInt(output);
s+=a;
}
System.out.println(s);
}
}
另解:
import java.io.*;
public class Sumloop {
public static void main(String[] args) throws IOException
{
int s=0;
int n;
int t=0;
BufferedReader stadin = new BufferedReader(new InputStreamReader(System.in));
String input = stadin.readLine();
n=Integer.parseInt(input);
for(int i=1;i<=n;i++){
t=t*10+n;
s=s+t;
System.out.println(t);
}
System.out.println(s);
}
}
【程序9】 题目：一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3.编程 找出1000以内的所有完数。
public class Wanshu {
public static void main(String[] args)
{
int s;
for(int i=1;i<=1000;i++)
{
s=0;
for(int j=1;j<i;j++)
if(i % j==0)
s=s+j;
if(s==i)
System.out.print(i+" ");
}
System.out.println();
}
}
【程序10】 题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第10次落地时，共经过多少米？第10次反弹多高？
public class Ex10 {
public static void main(String[] args)
{
double s=0;
double t=100;
for(int i=1;i<=10;i++)
{
s+=t;
t=t/2;
}
System.out.println(s);
System.out.println(t);
}
}
【程序11】 题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
1.程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。
public class Wanshu {
public static void main(String[] args)
{
int i=0;
int j=0;
int k=0;
int t=0;
for(i=1;i<=4;i++)
for(j=1;j<=4;j++)
for(k=1;k<=4;k++)
if(i!=j && j!=k && i!=k)
{t+=1;
System.out.println(i*100+j*10+k);
}
System.out.println (t);
}
}
【程序12】 题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？
1.程序分析：请利用数轴来分界，定位。注意定义时需把奖金定义成长整型。
import java .util.*;
public class test {
public static void main (String[]args){
double sum;//声明要储存的变量应发的奖金
Scanner input =new Scanner (System.in);//导入扫描器
System.out.print ("输入当月利润");
double lirun=input .nextDouble();//从控制台录入利润
if(lirun<=100000){
sum=lirun*0.1;
}else if (lirun<=200000){
sum=10000+lirun*0.075;
}else if (lirun<=400000){
sum=17500+lirun*0.05;
}else if (lirun<=600000){
sum=lirun*0.03;
}else if (lirun<=1000000){
sum=lirun*0.015;
} else{
sum=lirun*0.01;
}
System.out.println("应发的奖金是"+sum);
}
}
后面其他情况的代码可以由读者自行完善.
【程序13】
题目：一个整数，它加上100后是一个完全平方数，加上168又是一个完全平方数，请问该数是多少？
1.程序分析：在10万以内判断，先将该数加上100后再开方，再将该数加上268后再开方，如果开方后的结果满足如下条件，即是结果。请看具体分析：
public class test {
public static void main (String[]args){
long k=0;
for(k=1;k<=100000l;k++)
if(Math.floor(Math.sqrt(k+100))==Math.sqrt(k+100) && Math.floor(Math.sqrt(k+168))==Math.sqrt(k+168))
System.out.println(k);
}
}
【程序14】 题目：输入某年某月某日，判断这一天是这一年的第几天？
1.程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且输入月份大于3时需考虑多加一天。
import java.util.*;
public class test {
public static void main (String[]args){
int day=0;
int month=0;
int year=0;
int sum=0;
int leap;
System.out.print("请输入年,月,日\n");
Scanner input = new Scanner(System.in);
year=input.nextInt();
month=input.nextInt();
day=input.nextInt();
switch(month) /*先计算某月以前月份的总天数*/
{
case 1:
sum=0;break;
case 2:
sum=31;break;
case 3:
sum=59;break;
case 4:
sum=90;break;
case 5:
sum=120;break;
case 6:
sum=151;break;
case 7:
sum=181;break;
case 8:
sum=212;break;
case 9:
sum=243;break;
case 10:
sum=273;break;
case 11:
sum=304;break;
case 12:
sum=334;break;
default:
System.out.println("data error");break;
}
sum=sum+day; /*再加上某天的天数*/
if(year%400==0||(year%4==0&&year%100!=0))/*判断是不是闰年*/
leap=1;
else
leap=0;
if(leap==1 && month>2)/*如果是闰年且月份大于2,总天数应该加一天*/
sum++;
System.out.println("It is the the day:"+sum);
}
}
【程序15】 题目：输入三个整数x,y,z，请把这三个数由小到大输出。
1.程序分析：我们想办法把最小的数放到x上，先将x与y进行比较，如果x> y则将x与y的值进行交换，然后再用x与z进行比较，如果x> z则将x与z的值进行交换，这样能使x最小。
import java.util.*;
public class test {
public static void main (String[]args){
int i=0;
int j=0;
int k=0;
int x=0;
System.out.print("请输入三个数\n");
Scanner input = new Scanner(System.in);
i=input.nextInt();
j=input.nextInt();
k=input.nextInt();
if(i>j)
{
x=i;
i=j;
j=x;
}
if(i>k)
{
x=i;
i=k;
k=x;
}
if(j>k)
{
x=j;
j=k;
k=x;
}
System.out.println(i+", "+j+", "+k);
}
}
【程序16】 题目：输出9*9口诀。
1.程序分析：分行与列考虑，共9行9列，i控制行，j控制列。
public class jiujiu {
public static void main(String[] args)
{
int i=0;
int j=0;
for(i=1;i<=9;i++)
{ for(j=1;j<=9;j++)
System.out.print(i+"*"+j+"="+i*j+"\t");
System.out.println();
}
}
}
不出现重复的乘积(下三角)
public class jiujiu {
public static void main(String[] args)
{
int i=0;
int j=0;
for(i=1;i<=9;i++)
{ for(j=1;j<=i;j++)
System.out.print(i+"*"+j+"="+i*j+"\t");
System.out.println();
}
}
}
上三角
public class jiujiu {
public static void main(String[] args)
{
int i=0;
int j=0;
for(i=1;i<=9;i++)
{ for(j=i;j<=9;j++)
System.out.print(i+"*"+j+"="+i*j+"\t");
System.out.println();
}
}
}
【程序17】 题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个 第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下 的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
1.程序分析：采取逆向思维的方法，从后往前推断。
public class 猴子吃桃 {
static int total(int day){
if(day == 10){
return 1;
}
else{
return (total(day+1)+1)*2;
}
}
public static void main(String[] args)
{
System.out.println(total(1));
}
}
【程序18】 题目：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。
import java.util.ArrayList;
public class pingpang {
String a,b,c;
public static void main(String[] args) {
String[] op = { "x", "y", "z" };
ArrayList<pingpang> arrayList=new ArrayList<pingpang>();
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++) {
pingpang a=new pingpang(op[i],op[j],op[k]);
if(!a.a.equals(a.b)&&!a.b.equals(a.c)&&!a.a.equals("x")
&&!a.c.equals("x")&&!a.c.equals("z")){
arrayList.add(a);
}
}
for(Object a:arrayList){
System.out.println(a);
}
}
public pingpang(String a, String b, String c) {
super();
this.a = a;
this.b = b;
this.c = c;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "a的对手是"+a+","+"b的对手是"+b+","+"c的对手是"+c+"\n";
}
}
【程序19】 题目：打印出如下图案（菱形）
*
***
******
********
******
***
*
1.程序分析：先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重 for循环，第一层控制行，第二层控制列。
三角形：
public class StartG {
public static void main(String [] args)
{
int i=0;
int j=0;
for(i=1;i<=4;i++)
{ for(j=1;j<=2*i-1;j++)
System.out.print("*");
System.out.println("");
}
for(i=4;i>=1;i--)
{ for(j=1;j<=2*i-3;j++)
System.out.print("*");
System.out.println("");
}
}
}
菱形：
public class StartG {
public static void main(String [] args)
{
int i=0;
int j=0;
for(i=1;i<=4;i++)
{
for(int k=1; k<=4-i;k++)
System.out.print(" ");
for(j=1;j<=2*i-1;j++)
System.out.print("*");
System.out.println("");
}
for(i=4;i>=1;i--)
{
for(int k=1; k<=5-i;k++)
System.out.print(" ");
for(j=1;j<=2*i-3;j++)
System.out.print("*");
System.out.println("");
}
}
}
【程序20】 题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
1.程序分析：请抓住分子与分母的变化规律。
public class test20 {
public static void main(String[] args) {
float fm = 1f;
float fz = 1f;
float temp;
float sum = 0f;
for (int i=0;i<20;i++){
temp = fm;
fm = fz;
fz = fz + temp;
sum += fz/fm;
//System.out.println(sum);
}
System.out.println(sum);
}
}
【程序21】 题目：求1+2!+3!+...+20!的和
1.程序分析：此程序只是把累加变成了累乘。
public class Ex21 {
static long sum = 0;
static long fac = 0;
public static void main(String[] args) {
long sum = 0;
long fac = 1;
for(int i=1; i<=10; i++) {
fac = fac * i;
sum += fac;
}
System.out.println(sum);
}
}
【程序22】 题目：利用递归方法求5!。
1.程序分析：递归公式：fn=fn_1*4!
import java.util.Scanner;
public class Ex22 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
Ex22 tfr = new Ex22();
System.out.println(tfr.recursion(n));
}
public long recursion(int n) {
long value = 0 ;
if(n ==1 || n == 0) {
value = 1;
} else if(n > 1) {
value = n * recursion(n-1);
}
return value;
}
}
【程序23】 题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
1.程序分析：利用递归的方法，递归分为回推和递推两个阶段。要想知道第五个人岁数，需知道第四人的岁数，依次类推，推到第一人（10岁），再往回推。
public class Ex23 {
static int getAge(int n){
if (n==1){
return 10;
}
return 2 + getAge(n-1);
}
public static void main(String[] args) {
System.out.println("第五个的年龄为:"+getAge(5));
}
}
【程序24】 题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
import java.util.Scanner;
public class Ex24 {
public static void main(String[] args) {
Ex24 tn = new Ex24();
Scanner s = new Scanner(System.in);
long a = s.nextLong();
if(a < 0 || a > 100000) {
System.out.println("Error Input, please run this program Again");
System.exit(0);
}
if(a >=0 && a <=9) {
System.out.println( a + "是一位数");
System.out.println("按逆序输出是" + '\n' + a);
} else if(a >= 10 && a <= 99) {
System.out.println(a + "是二位数");
System.out.println("按逆序输出是" );
tn.converse(a);
} else if(a >= 100 && a <= 999) {
System.out.println(a + "是三位数");
System.out.println("按逆序输出是" );
tn.converse(a);
} else if(a >= 1000 && a <= 9999) {
System.out.println(a + "是四位数");
System.out.println("按逆序输出是" );
tn.converse(a);
} else if(a >= 10000 && a <= 99999) {
System.out.println(a + "是五位数");
System.out.println("按逆序输出是" );
tn.converse(a);
}
}
public void converse(long l) {
String s = Long.toString(l);
char[] ch = s.toCharArray();
for(int i=ch.length-1; i>=0; i--) {
System.out.print(ch[i]);
}
}
}
【程序25】 题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。
import java.util.Scanner;
public class Ex25 {
static int[] a = new int[5];
static int[] b = new int[5];
public static void main(String[] args) {
boolean is =false;
Scanner s = new Scanner(System.in);
long l = s.nextLong();
if (l > 99999 || l < 10000) {
System.out.println("Input error, please input again!");
l = s.nextLong();
}
for (int i = 4; i >= 0; i--) {
a[i] = (int) (l / (long) Math.pow(10, i));
l =(l % ( long) Math.pow(10, i));
}
System.out.println();
for(int i=0,j=0; i<5; i++, j++) {
b[j] = a[i];
}
for(int i=0,j=4; i<5; i++, j--) {
if(a[i] != b[j]) {
is = false;
break;
} else {
is = true;
}
}
if(is == false) {
System.out.println("is not a Palindrom!");
} else if(is == true) {
System.out.println("is a Palindrom!");
}
}
}
【程序26】 题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续 判断第二个字母。
1.程序分析：用情况语句比较好，如果第一个字母一样，则判断用情况语句或if语句判断第二个字母。
import java.util.Scanner;
public class Ex26 {
public static void main(String[] args){
//保存用户输入的第二个字母
char weekSecond;
//将Scanner类示例化为input对象，用于接收用户输入
Scanner input = new Scanner(System.in);
//开始提示并接收用户控制台输入
System.out.print("请输入星期值英文的第一个字母，我来帮您判断是星期几：");
String letter = input.next();
//判断用户控制台输入字符串长度是否是一个字母
if (letter.length() == 1){
//利用取第一个索引位的字符来实现让Scanner接收char类型输入
char weekFirst = letter.charAt(0);
switch (weekFirst){
case 'm':
//当输入小写字母时，利用switch结构特性执行下一个带break语句的case分支，以实现忽略用户控制台输入大小写敏感的功能
case 'M':
System.out.println("星期一(Monday)");
break;
case 't':
//当输入小写字母时，利用switch结构特性执行下一个带break语句的case分支，以实现忽略用户控制台输入大小写敏感的功能
case 'T':
System.out.print("由于星期二(Tuesday)与星期四(Thursday)均以字母T开头，故需输入第二个字母才能正确判断：");
letter = input.next();
//判断用户控制台输入字符串长度是否是一个字母
if (letter.length() == 1){
//利用取第一个索引位的字符来实现让Scanner接收char类型输入
weekSecond = letter.charAt(0);
//利用或（||）运算符来实现忽略用户控制台输入大小写敏感的功能
if (weekSecond == 'U' || weekSecond == 'u'){
System.out.println("星期二(Tuesday)");
break;
//利用或（||）运算符来实现忽略用户控制台输入大小写敏感的功能
} else if (weekSecond == 'H' || weekSecond == 'h'){
System.out.println("星期四(Thursday)");
break;
//控制台错误提示
} else{
System.out.println("输入错误，不能识别的星期值第二个字母，程序结束！");
break;
}
} else {
//控制台错误提示
System.out.println("输入错误，只能输入一个字母，程序结束！");
break;
}
case 'w':
//当输入小写字母时，利用switch结构特性执行下一个带break语句的case分支，以实现忽略用户控制台输入大小写敏感的功能
case 'W':
System.out.println("星期三(Wednesday)");
break;
case 'f':
//当输入小写字母时，利用switch结构特性执行下一个带break语句的case分支，以实现忽略用户控制台输入大小写敏感的功能
case 'F':
System.out.println("星期五(Friday)");
break;
case 's':
//当输入小写字母时，利用switch结构特性执行下一个带break语句的case分支，以实现忽略用户控制台输入大小写敏感的功能
case 'S':
System.out.print("由于星期六(Saturday)与星期日(Sunday)均以字母S开头，故需输入第二个字母才能正确判断：");
letter = input.next();
//判断用户控制台输入字符串长度是否是一个字母
if (letter.length() == 1){
//利用取第一个索引位的字符来实现让Scanner接收char类型输入
weekSecond = letter.charAt(0);
//利用或（||）运算符来实现忽略用户控制台输入大小写敏感的功能
if (weekSecond == 'A' || weekSecond == 'a'){
System.out.println("星期六(Saturday)");
break;
//利用或（||）运算符来实现忽略用户控制台输入大小写敏感的功能
} else if (weekSecond == 'U' || weekSecond == 'u'){
System.out.println("星期日(Sunday)");
break;
//控制台错误提示
} else{
System.out.println("输入错误，不能识别的星期值第二个字母，程序结束！");
break;
}
} else{
//控制台错误提示
System.out.println("输入错误，只能输入一个字母，程序结束！");
break;
}
default:
//控制台错误提示
System.out.println("输入错误，不能识别的星期值第一个字母，程序结束！");
break;
}
} else{
//控制台错误提示
System.out.println("输入错误，只能输入一个字母，程序结束！");
}
}
}
【程序27】 题目：求100之内的素数
public class Ex27 {
public static void main(String args[])
{
int sum,i;
for(sum=2;sum<=100;sum++)
{
for(i=2;i<=sum/2;i++)
{
if(sum%i==0)
break;
}
if(i>sum/2)
System.out.println(sum+"是素数");
}
}
}
【程序28】 题目：对10个数进行排序
1.程序分析：可以利用选择法，即从后9个比较过程中，选择一个最小的与第一个元素交换， 下次类推，即用第二个元素与后8个进行比较，并进行交换。
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class Ex28 {
public static void main(String[] args) {
int arr[] = new int[11];
Random r=new Random();
for(int i=0;i<10;i++){
arr[i]=r.nextInt(100)+1;//得到10个100以内的整数
}
Arrays.sort(arr);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.print("\nPlease Input a int number: ");
Scanner sc=new Scanner(System.in);
arr[10]=sc.nextInt();//输入一个int值
Arrays.sort(arr);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}
【程序29】 题目：求一个3*3矩阵对角线元素之和
1.程序分析：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出。
public class Ex29 {
public static void main(String[] args){
double sum=0;
int array[][]={{1,2,3},{4,5, 6},{7,7,8}};
for(int i=0;i<3;i++)
for(int j=0;j<3;j++){
if(i==j)
sum=sum + array[i][j];
}
System.out.println( sum);
}
}
【程序30】 题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
1. 程序分析：首先判断此数是否大于最后一个数，然后再考虑插入中间的数的情况，插入后此元素之后的数，依次后移一个位置。
import java.util.Random;
public class ArraySort {
public static void main(String[] args)
{ int temp=0;
int myarr[] = new int[12];
Random r=new Random();
for(int i=1;i<=10;i++)
myarr[i]=r.nextInt(1000);
for (int k=1;k<=10;k++)
System.out.print(myarr[k]+",");
for(int i=1;i<=9;i++)
for(int k=i+1;k<=10;k++)
if(myarr[i]>myarr[k])
{
temp=myarr[i];
myarr[i]=myarr[k];
myarr[k]=temp;
}
System.out.println("");
for (int k=1;k<=10;k++)
System.out.print(myarr[k]+",");
myarr[11]=r.nextInt(1000);
for(int k=1;k<=10;k++)
if(myarr[k]>myarr[11])
{
temp=myarr[11];
for(int j=11;j>=k+1;j--)
myarr[j]=myarr[j-1];
myarr[k]=temp;
}
System.out.println("");
for (int k=1;k<=11;k++)
System.out.print(myarr[k]+",");
}
}
【程序31】 题目：将一个数组逆序输出。
程序分析：用第一个与最后一个交换。
其实，用循环控制变量更简单：
for(int k=11;k>=1;k--)
System.out.print(myarr[k]+",");
【程序32】 题目：取一个整数a从右端开始的4～7位。
程序分析：可以这样考虑：
(1)先使a右移4位。
(2)设置一个低4位全为1,其余全为0的数。可用~(~0 < <4)
(3)将上面二者进行&运算。
public class Ex32 {
public static void main(String[] args)
{
int a=0;
long b=18745678;
a=(int) Math.floor(b % Math.pow(10,7)/Math.pow(10, 3));
System.out.println(a);
}
}
【程序33】
题目：打印出杨辉三角形（要求打印出10行如下图）
1.程序分析：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
public class Ex33 {
public static void main(String args[]){
int i,j;
int a[][];
a=new int[8][8];
for(i=0;i<8;i++){
a[i][i]=1;
a[i][0]=1;
}
for(i=2;i<8;i++){
for(j=1;j<=i-1;j++){
a[i][j]=a[i-1][j-1]+a[i-1][j];
}
}
for(i=0;i<8;i++){
for(j=0;j<i;j++){
System.out.printf(" "+a[i][j]);
}
System.out.println();
}
}
}
【程序34】 题目：输入3个数a,b,c，按大小顺序输出。
1.程序分析：利用指针方法。
public class Ex34 {
public static void main(String[] args)
{
int []arrays = {800,56,500};
for(int i=arrays.length;--i>=0;)
{
for(int j=0;j<i;j++)
{
if(arrays[j]>arrays[j+1])
{
int temp=arrays[j];
arrays[j]=arrays[j+1];
arrays[j+1]=temp;
}
}
}
for(int n=0;n<arrays.length;n++)
System.out.println(arrays[n]);
}
}
【程序35】 题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
import java.util.*;
public class Ex35 {
public static void main(String[] args) {
int i, min, max, n, temp1, temp2;
int a[];
System.out.println("输入数组的长度:");
Scanner keyboard = new Scanner(System.in);
n = keyboard.nextInt();
a = new int[n];
for (i = 0; i < n; i++) {
System.out.print("输入第" + (i + 1) + "个数据");
a[i] = keyboard.nextInt();
}
//以上是输入整个数组
max = 0;
min = 0;
//设置两个标志,开始都指向第一个数
for (i = 1; i < n; i++) {
if (a[i] > a[max])
max = i; //遍历数组,如果大于a[max]，就把他的数组下标赋给max
if (a[i] < a[min])
min = i; //同上，如果小于a[min],就把他的数组下标赋给min
}
//以上for循环找到最大值和最小值，max是最大值的下标，min是最小值的下标
temp1 = a[0];
temp2 = a[min]; //这两个temp只是为了在交换时使用
a[0] = a[max];
a[max] = temp1; //首先交换a[0]和最大值a[max]
if (min != 0) { //如果最小值不是a[0]，执行下面
a[min] = a[n - 1];
a[n - 1] = temp2; //交换a[min]和a[n-1]
} else { //如果最小值是a[0],执行下面
a[max] = a[n - 1];
a[n - 1] = temp1;
}
for (i = 0; i < n; i++) { //输出数组
System.out.print(a[i] + " ");
}
}
}
【程序36】 题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
【程序37】
题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
import java.util.Scanner;
public class Ex37 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
boolean[] arr = new boolean[n];
for(int i=0; i<arr.length; i++) {
arr[i] = true;//下标为TRUE时说明还在圈里
}
int leftCount = n;
int countNum = 0;
int index = 0;
while(leftCount > 1) {
if(arr[index] == true) {//当在圈里时
countNum ++; //报数递加
if(countNum == 3) {//报道3时
countNum =0;//从零开始继续报数
arr[index] = false;//此人退出圈子
leftCount --;//剩余人数减一
}
}
index ++;//每报一次数，下标加一
if(index == n) {//是循环数数，当下标大于n时，说明已经数了一圈，
index = 0;//将下标设为零重新开始。
}
}
for(int i=0; i<n; i++) {
if(arr[i] == true) {
System.out.println(i);
}
}
}
}
【程序38】
题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。
import java.util.Scanner;
public class Ex38 {
public static void main(String [] args)
{
Scanner s = new Scanner(System.in);
System.out.println("请输入一个字符串");
String mys= s.next();
System.out.println(str_len(mys));
}
public static int str_len(String x)
{
return x.length();
}
}
题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n,当输入n为奇数时，调用函数1/1+1/3+...+1/n
【程序39】
题目：字符串排序。
import java.util.*;
public class test{
public static void main(String[] args)
{
ArrayList<String> list=new ArrayList<String>();
list.add("010101");
list.add("010003");
list.add("010201");
Collections.sort(list);
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
}
【程序40】
题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？
public class Dg {
static int ts=0;//桃子总数
int fs=1;//记录分的次数
static int hs=5;//猴子数...
int tsscope=5000;//桃子数的取值范围.太大容易溢出.
public int fT(int t){
if(t==tsscope){
//当桃子数到了最大的取值范围时取消递归
System.out.println("结束");
return 0;
}
else{
if((t-1)%hs==0 && fs <=hs){
if(fs==hs)
{
System.out.println("桃子数 = "+ts +" 时满足分桃条件");
}
fs+=1;
return fT((t-1)/5*4);// 返回猴子拿走一份后的剩下的总数
}
else
{
//没满足条件
fs=1;//分的次数重置为1
return fT(ts+=1);//桃子数加+1
}
}
}
public static void main(String[] args) {
new Dg().fT(0);
}
}
【程序41】
java排序算法的比较
import java.util.*;
import java.io.*;
public class SortAlgorithm
{
static Random rand = new Random();
void bubbleSort(int[] numlist) // 冒泡排序算法
{
int temp;
for(int j=1;j<numlist.length;j++)
for(int i=0;i<numlist.length-j;i++)
if(numlist>numlist[i+1])
{
temp = numlist[i+1];
numlist[i+1] = numlist;
numlist = temp;
}
}
void selectionSort (int[] numlist) //选择排序算法
{
int temp;
for(int i=0;i<numlist.length-1;i++)
for(int j=i+1;j<numlist.length;j++)
if(numlist>numlist[j])
{
temp = numlist[j];
numlist[j] = numlist;
numlist = temp;
}
}
void insertSort (int[] numlist) //插入排序算法
{
int temp,in,out;
for(out=1;out<numlist.length;out++)
{
temp=numlist[out];
in=out;
while(in>0 && numlist[in-1]>=temp)
{
numlist[in]=numlist[in-1];
--in;
}
numlist[in]=temp;
}
}
void display (int[] num) // 打印出排序结果
{
for(int i = 0;i<num.length;i++)
System.out.print(num+" ");
System.out.println("");
}
static int pRand(int mod) // 生成随即数组
{
return Math.abs(rand.nextInt())%mod;
}
public static void main(String args[])throws IOException
{
SortAlgorithm sortAlgorithm = new SortAlgorithm();
int[] numList = new int[10];
for(int i = 0;i<numList.length;i++)
numList = pRand(100); //调用pRand方法，把随即生成的数据输入到
// 数组中
System.out.println("随即生成的数组是：");
// 打印出原数组，
for(int j =0;j<numList.length;j++)
System.out.print(numList[j]+" ");
System.out.println("");
long begin = System.currentTimeMillis(); //排序开始时间，调用系统的当前时间
sortAlgorithm.bubbleSort(numList); //执行冒泡排序
long end = System.currentTimeMillis(); //排序结束时间，调用系统当前时间
System.out.println("冒泡排序用时为：" + (end-begin)); //排序用时
System.out.println("排序后的数组为：");
sortAlgorithm.display(numList);
begin = System.currentTimeMillis();
sortAlgorithm.selectionSort(numList);
end = System.currentTimeMillis();
System.out.println("选择排序用时为：" +(end-begin));
System.out.println("排序后的数组为：");
sortAlgorithm.display(numList);
begin = System.currentTimeMillis();
sortAlgorithm.insertSort(numList);
end = System.currentTimeMillis();
System.out.println("插入排序用时为：" + (end-begin));
System.out.println("排序后的数组为：");
sortAlgorithm.display(numList);
}
}
【程序42】
题目如下：用1、2、2、3、4、5这六个数字，用java写一个main函数，打印出所有不同的排列，如：512234、412345等，要求："4"不能在第三位，"3"与"5"不能相连。
static int[] bits = new int[] { 1, 2, 3, 4, 5 };
/**
* @param args
*/
public static void main(String[] args) {
sort("", bits);
}
private static void sort(String prefix, int[] a) {
if (a.length == 1) {
System.out.println(prefix + a[0]);
}
for (int i = 0; i < a.length; i++) {
sort(prefix + a, copy(a, i));
}
}
private static int[] copy(int[] a,int index){
int[] b = new int[a.length-1];
System.arraycopy(a, 0, b, 0, index);
System.arraycopy(a, index+1, b, index, a.length-index-1);
return b;
}
~~~
全国软件———欧拉与鸡蛋
最后更新于：2022-04-01 09:48:23
1.欧拉与鸡蛋
大数学家欧拉在集市上遇到了本村的两个农妇，每人跨着个空篮子。她们和欧拉打招呼说两人刚刚卖完了所有的鸡蛋。
欧拉随便问：“卖了多少鸡蛋呢？”
不料一个说：“我们两人自己卖自己的，一共卖了150个鸡蛋，虽然我们卖的鸡蛋有多有少，但刚好得了同样的钱数。你猜猜看！”
欧拉猜不出。
另一个补充道：“如果我按她那样的价格卖，可以得到32元；如果她按我的价格卖，可以得到24.5元”。
欧拉想了想，说出了正确答案。
我们不是数学家，懒得列出公式来分析。但计算机可以“暴力破解”，就是把所有可能情况都试验一遍，撞上为止！
请写出每人鸡蛋的数目（顺序不限），用逗号隔开。
答案写在“解答.txt”中，不要写在这里！
**参考答案：**
70,80 或 80,70
~~~
#include <iostream>
using namespace std;
int main()
{
for(int i=1;i<150;i++)
{
for(int j=1;j<150;j++)
{
if(i+j==150&&64*i*i==49*j*j)
{
cout<<i<<" "<<j<<endl;
}
}
}
return 0;
}
~~~
全国软件———–猜生日
最后更新于：2022-04-01 09:48:21
1.猜生日
今年的植树节（2012年3月12日），小明和他的叔叔还有小伙伴们一起去植树。休息的时候，小明的同学问他叔叔多大年纪，他叔叔说：“我说个题目，看你们谁先猜出来！”
“把我出生的年月日连起来拼成一个8位数（月、日不足两位前补0）正好可以被今天的年、月、日整除！”
他想了想，又补充到：“再给个提示，我是6月出生的。”
根据这些信息，请你帮小明算一下，他叔叔的出生年月日。
答案写在“解答.txt”中，不要写在这里！
格式是年月日连成的8位数。
~~~
#include <iostream>
using namespace std;
int main()
{
for(int i=19120600;i<20120312;i++)
{
if(i%2012==0&&i%3==0&&i%12==0)
cout<<i<<endl;
}
return 0;
}
~~~
例如，如果是1948年6月12日，就写：19480612
**参考答案：**
19550604
全国软件填写算式
最后更新于：2022-04-01 09:48:19
~~~
#include <iostream>
using namespace std;
int main()
{
int i,j,k;
int i1,i2,i3;
int j1,j2,j3;
int k1,k2,k3;
int sum=0;
for(i=1;i<=9;i++)
for(j=1;j<=9;j++)
for(k=1;k<=9;k++)
for(i2=1;i2<=9;i2++)
for(i3=1;i3<=9;i3++)
for(j1=1;j1<=9;j1++)
for(j2=1;j2<=9;j2++)
for(j3=1;j3<=9;j3++)
for(k1=1;k1<=9;k1++)
{
int m1;
int m2;
int m3;
m1=i*100+j*10+k;
m2=i2*100+i3*10+j1;
m3=j2*100+j3*10+k1;
if(m1+m2==m3&&i!=j&&i!=k&&i!=i2&&i!=i3&&i!=j1&&i!=j2&&i!=j3&&i!=k1&&j!=k&&j!=i2&&j!=i3&&j!=j1&&j!=j2&&j!=j3&&j!=k1&&k!=i2&&k!=i3&&k!=j1&&k!=j2&&k!=j3&&k!=k1&&i2!=i3&&i2!=j1&&i2!=j2&&i2!=j3&&i2!=k1&&i3!=j1&&i3!=j2&&i3!=j3&&i3!=k1&&j1!=j2&&j1!=j3&&j1!=k1&&j2!=j3&&j2!=k1&&j3!=k1)
sum+=1;
else sum+=0;
}
cout<<sum<<endl;
return 0;
}
~~~
1. 填写算式
看这个算式：
☆☆☆ + ☆☆☆ = ☆☆☆
如果每个五角星代表 1 ~ 9的不同的数字。
这个算式有多少种可能的正确填写方法？
173 + 286 = 459
295 + 173 = 468
173 + 295 = 468
183 + 492 = 675
以上都是正确的填写法！
注意：
111 + 222 = 333 是错误的填写法！
因为每个数字必须是不同的！
也就是说：1~9中的所有数字，每个必须出现且仅出现一次！
注意：
不包括数字“0”！
注意：
满足加法交换率的式子算两种不同的答案。
所以答案肯定是个偶数！
注意：
只要求计算不同的填法的数目
不要求列出所有填写法
更不要求填写源代码！
答案不要写在这里，请写在“解答.txt”中！
**参考答案：**
336
全国软件–微生物增殖
最后更新于：2022-04-01 09:48:16
1.微生物增殖
假设有两种微生物 X和 Y
X出生后每隔3分钟分裂一次（数目加倍），Y出生后每隔2分钟分裂一次（数目加倍）。
一个新出生的X，半分钟之后吃掉1个Y，并且，从此开始，每隔1分钟吃1个Y。
现在已知有新出生的 X=10, Y=89，求60分钟后Y的数目。
如果X=10，Y=90 呢？
本题的要求就是写出这两种初始条件下，60分钟后Y的数目。
题目的结果令你震惊吗？这不是简单的数字游戏！真实的生物圈有着同样脆弱的性质！也许因为你消灭的那只 Y就是最终导致 Y 种群灭绝的最后一根稻草！
请忍住悲伤，把答案写在“解答.txt”中，不要写在这里！
两个整数，每个1行。
**参考答案：**
0
94371840
~~~
#include <iostream>
using namespace std;
int main()
{
int i;
int y=90,x=10;
for(i=1;i<=120;i++)
{
if(i%2==1)
y=y-x;
if(i%4==0)
y=y*2;
if(i%6==0)
x=x*2;
}
cout<<y<<endl;
}
~~~
全国软件3. 考察团组成
最后更新于：2022-04-01 09:48:14
某饭店招待国外考察团。按照标准，对领导是400元/人，随团职员200元/人，对司机50元/人。
考察团共36人，招待费结算为3600元，请问领导、职员、司机各几人。
答案是三个整数，用逗号分隔。
**参考答案：**
3,5,28
~~~
#include <iostream>
using namespace std;
int main()
{
int l,z,s;
for(int i=0;i<9;i++)
for(int j=0;j<12;j++)
for(int k=0;k<60;k++)
{
if(i+j+k==36&&i*400+j*200+k*50==3600)
cout<<i<<" "<<j<<" "<<k<<endl;
}
return 0;
}
~~~
全国软件2. 三人年龄
最后更新于：2022-04-01 09:48:12
三个神秘蒙面人来访F博士。
博士询问他们年龄时，他们说：我们中年龄最小的不超过19岁。我们3人年龄总和为70岁。且我们三人年龄的乘积是所有可能情况中最大的。
请帮助F博士计算他们的年龄，从小到大排列，用逗号分开。
参考答案：
19,25,26
我的答案是23 23 24
~~~
#include <iostream>
using namespace std;
int main()
{
int x,y,z;
int max=0,im=0,jm=0,km=0;
for(int i=19;i<61;i++)
for(int j=19;j<61;j++)
for(int k=19;k<61;k++)
{
if(i+j+k==70)
{
if(max<i*j*k)
{
max=i*j*k;
im=i;
jm=j;
km=k;
}
}
}
cout<<im<<" "<<jm<<" "<<km<<endl;
return 0;
}
~~~
卢卡斯队列
最后更新于：2022-04-01 09:48:10
~~~
/*
黄金分割数0.618与美学有重要的关系。舞台上报幕员所站的位置大约就是舞台宽度的0.618处，墙上的画像一般也挂在房间高度的0.618处，甚至股票的波动据说也能找到0.618的影子....
黄金分割数是个无理数，也就是无法表示为两个整数的比值。0.618只是它的近似值，其真值可以通过对5开方减去1再除以2来获得，我们取它的一个较精确的近似值：0.618034
有趣的是，一些简单的数列中也会包含这个无理数，这很令数学家震惊！
1 3 4 7 11 18 29 47 .... 称为“鲁卡斯队列”。它后面的每一个项都是前边两项的和。
如果观察前后两项的比值，即：1/3,3/4,4/7,7/11,11/18 ... 会发现它越来越接近于黄金分割数！
你的任务就是计算出从哪一项开始，这个比值四舍五入后已经达到了与0.618034一致的精度。
请写出该比值。格式是：分子/分母。比如：29/47
答案写在“解答.txt”中，不要写在这里！
*/
//#include <iostream>
#include <stdio.h>
//using namespace std;
int main()
{
float a;
float b=1,n,sum=3;
for(int i=0;i<50;i++)
{
if(a==0.618034001)
break;
else
{
a=b/sum;
printf("%f/%f=%.7f\n",b,sum,a);
n=sum;
sum=sum+b;
b=n;
}
}
}
//1364/2207=0.6180335
~~~
杭电ACM2007平方和与立方和
最后更新于：2022-04-01 09:48:07
~~~
#include <iostream>
using namespace std;
int main()
{
int m,n;
int x=0,y=0;
while (cin>>m>>n)
{
x=0,y=0;
if(m>n)
{
m=m+n;
n=m-n;
m=m-n;
}
for(int i=m;i<=n;i++)
{
if(i%2==0)
x=x+i*i;
else
y=y+i*i*i;
}
cout<<x<<" "<<y<<endl;
}
}
~~~
杭电ACM—-2018母牛的故事
最后更新于：2022-04-01 09:48:05
~~~
#include <iostream>
using namespace std;
int main()
{
int n;
int a[56]={0,1,2,3};
while(cin>>n&&n)
{
switch(n)
{
case 1:
cout<<a[n]<<endl;
break;
case 2:
cout<<a[n]<<endl;
break;
case 3:
cout<<a[n]<<endl;
break;
default:
for(int i=4;i<56;i++)
a[i]=a[i-1]+a[i-3];
cout<<a[n]<<endl;
break;
}
}
}
~~~