湘潭大学Java练习题
Java练习题
第22题 编写程序：斐波那契图形
编写一个求斐波那契数列的递归函数，输入n值，使用该递归函数，输出如样例输出的斐波那契数列。
输入：
一个整型数n
输出：
题目可能有多组不同的测试数据，对于每组输入数据，
按题目的要求输出相应的斐波那契图形。
注意输出换行前不能有多余的空格。
样例输入：
6
样例输出：
0
0 1 1
0 1 1 2 3
0 1 1 2 3 5 8
0 1 1 2 3 5 8 13 21
0 1 1 2 3 5 8 13 21 34 55
import java.util.Scanner;
public class Main {
//递归方法求斐波那契数列
public static int fun(int n)
{
if(n==1)
return 0;
if(n==2)
return 1;
else
return fun(n-2)+fun(n-1);
}
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
while(s.hasNext()) {
int n=s.nextInt();
for(int i=1;i<=n;i++){
for(int j=1;j<=2*i-1;j++){
if(j!=2*i-1)
System.out.print(fun(j)+" ");
if(j==2*i-1)
System.out.println(fun(j));
}
}
}
}
}
第23题 编程：求奇数的倒数之和值
Time Limit : 1.0 s Memory Limit : 32 MB
问题描述: 输入格式 样例输入 此题的上机步骤是: 第29题 编写程序输出对称平方数 第30题 编写程序：递推数列 第31题 编写程序求各位数字之和 第32题 与7无关的数平方和 第33题 编程题：最大公约数 第35题 编程题：输出字符串中的大写字母 将有多组数据，组数预先未知。 输入格式 数据规模与约定 说明：有一些试题会给出多组样例输入输出以帮助你更好的做题。 此题的上机步骤是: 第37题 编程:n个整数的逆序输出 输入格式 样例输入 此题的上机步骤是: 第38题 编程：计算M以内最大的10个能被3整除的自然数之和 输入格式 样例输入 此题的上机步骤是: 第41题 编程求数组最大值及其下标 对于给定整数数组a[],寻找其中最大值，并返回下标。 第41题 编程求数组最大值及其下标 对于给定整数数组a[],寻找其中最大值，并返回下标。 第43题 编写. 计算某日是星期几 输入： 样例输入： 第44题 编写程序：分解质因数(10分) 第54题 编写程序：完美(回文串)的代价(10分) 第55题 编写程序：字符串对比(10分) 第65题 编写部分代码, 使用内部类判断一个long型整数n是否为回文数(10分) 第83题 编写程序：关联矩阵(10分)
编写程序求1/1+1/3+…+1/(2n+1)的和值，其中整数n从键盘输入（0=
整数n
输出格式
1/1+1/3+…+1/(2n+1)的和值
1
2
样例输出
Sum is 1.3333333333333333
Sum is 1.5333333333333332
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
while(s.hasNext()) {
int n=s.nextInt();
double sum=0;
for(int i=1;i<=2*n+1;i=i+2){
sum+=1.0/i;
}
System.out.println("Sum is "+sum);
}
s.close();
}
}
题目描述：
打印所有不超过n(0<=n<256)的，其平方具有对称性质的数。
如11*11=121
输入：
无任何输入数据
输出：
输出具有题目要求的性质的数。如果输出数据不止一个，各个数据之间以回车隔开。public class Main {
//判定是否为回文数
public static boolean isPalindrome(int n) {
int temp=0;
int m=n;
while(m!=0) {
temp=temp*10+m%10;
m/=10;
}
if(temp==n)
return true;
else
return false;
}
public static void main(String[] args) {
for(int i=0;i<256;i++) {
int num=i*i;
if(isPalindrome(num)==true) {
System.out.println(i);
}
}
}
}
题目描述：
给定a0,a1,以及an=pa(n-1) + qa(n-2)中的p,q。这里n >= 2。 求第k个数对10000的模。
输入：
输入包括5个整数：a0、a1、p、q、k。
输出：
第k个数a(k)对10000的模。
样例输入：
20 1 1 14 5
样例输出：
8359import java.util.Scanner;
public class Main {
public static long getAn(int a0,int a1,int p,int q,int k) {
if(k==0)
return a0;
if(k==1)
return a1;
else
return p*getAn(a0,a1,p,q,k-1)+q*getAn(a0,a1,p,q,k-2);
}
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
int[] n=new int[5];
for(int i=0;i<5;i++) {
n[i]=s.nextInt();
}
long an=getAn(n[0],n[1],n[2],n[3],n[4]);
long result=an%10000;
System.out.println(result);
s.close();
}
}
题目描述：
对于给定的正整数 n，计算其十进制形式下所有位置数字之和，并计算其平方的各位数字之和。
输入：
每行输入数据包括一个正整数n(0
对于每个输入数据，计算其各位数字之和，以及其平方值的数字之和，输出在一行中，之间用一个空格分隔，但行末不要有空格。
样例输入：
4
12
97
39999
0
样例输出：
4 7
3 9
16 22
39 36import java.util.Scanner;
public class Main {
//计算数字各个位数之和
public static int getSum(int n) {
int temp=0;
while(n!=0) {
temp+=n%10;
n/=10;
}
return temp;
}
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
while(s.hasNext()) {
int n=s.nextInt();
if(n==0)
break;
System.out.println(getSum(n)+" "+getSum(n*n));
}
s.close();
}
}
时间限制：1 秒 内存限制：32 兆
题目描述：
一个正整数,如果它能被7整除,或者它的十进制表示法中某个位数上的数字为7,
则称其为与7相关的数.现求所有小于等于n(n<100)的与7无关的正整数的平方和。
输入：
案例可能有多组。对于每个测试案例输入为一行,正整数n,(n<100)
输出：
对于每个测试案例输出一行，输出小于等于n的与7无关的正整数的平方和。
样例输入：
21
样例输出：
2336import java.util.Scanner;
public class Main {
public static boolean isWithSeven(int n) {
int temp=0;
if(n%7==0)
return true;
else {
while(n!=0) {
temp=n%10;
n/=10;
if(temp==7)
return true;
}
}
return false;
}
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
while(s.hasNext()) {
int n=s.nextInt();
int Sum=0;
for(int i=0;i<=n;i++) {
if(isWithSeven(i)==false) {
Sum+=i*i;
}
}
System.out.println(Sum);
}
s.close();
}
}
时间限制：1 秒内存限制：32 兆
题目描述：
输入两个正整数，求其最大公约数。
输入：
测试数据有多组，每组输入两个正整数。
输出：
对于每组输入,请输出其最大公约数。
样例输入：
49 14
样例输出：
7import java.util.Scanner;
public class Main {
public static int gcd(int a,int b)
{
if(b==0)
return a;
else
return gcd(b,a%b);
}
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
while(s.hasNext()) {
int n=s.nextInt();
int m=s.nextInt();
int num=gcd(n,m);
System.out.println(num);
}
s.close();
}
}
输入n个字符串,输出字符串中的大写字母。
每组数据第一行为整数n，表示字符串的个数。
每组数据第二行开始有n个字符串，每个字符串的长度都小于10000。
输出格式
每组数据输出n行，每行为对应字符串中的大写字母
样例输入
2
123Rtii
erYY09
1
fg*&KK
样例输出
R
YY
KK
1 <= n <= 10000。
在输出时，你的程序必须满足要求，不能少任何内容，也不能多任何内容。如果你的内容和输出要求不一样，你的程序会被判断为错误，包括你输出了提示信息、中间调试信息、标点符号、计时或者统计的信息等。
所有这些样例都测试通过，也不代表你的程序就是完全正确的，潜在的错误可能仍然导致你的得分较低。
import java.util.*;
public class Main {
//判断字符串中大写字母
public static String newStr(String str)
{
String s1="",s2="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for(int i=0;i
请编写程序:对输入的n个整数进行逆序并输出.
n
n个用空格分隔开的整数。
输出格式
逆序(n个用一个空格分隔开的整数)。
3
1 3 2
样例输出
2 3 1
注意: 2 3 1 中间只有一个空格, 尾部1的后面一个空格
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
int n=s.nextInt();
int[] m=new int[n];
for(int i=0;i
问题描述:
题目：计算并输出M以内最大的10个能被3整除的自然数之和，其中100<=M<=5000。
测试数据可能有多组，组数未知。
自然数n
输出格式
M以内最大的10个能被3整除的自然数之和
270
120
样例输出
Sum is 2565
Sum is 1065
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
while(s.hasNext()) {
int n=s.nextInt();
int sum=0,k=0;
for(int i=n;i>=100;i--) {
if(i%3==0) {
sum+=i;
k++;
if(k==10)
break;
}
}
System.out.println("Sum is "+sum);
}
s.close();
}
}
输入格式
整数数组a[],数组元素个数小于1等于100。输出数据分作两行：第一行只有一个数，表示数组元素个数；第二行为数组的各个元素。
输出格式
输出最大值，及其下标
样例输入
3
33 2 1
样例输出
33 0import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
int n=s.nextInt();
int[] a=new int[n];
int[] b=new int[n];
for(int i=0;i
输入格式
整数数组a[],数组元素个数小于1等于100。输出数据分作两行：第一行只有一个数，表示数组元素个数；第二行为数组的各个元素。
输出格式
输出最大值，及其下标
样例输入
3
33 2 1
样例输出
33 0import java.util.*;
public class Main {
public static void bSort(int n,int[] b) {
int[] a=new int[n];
for(int i=0;i
下面程序计算某日是星期几。
此题的上机步骤是:
以空格分隔的日期，形式为YYYY MM DD
输出：
星期=n, 这里n是数字
The Main class is end.
1990 2 12
样例输出：
星期=1
The Main class is end.import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
int W;
int y=cin.nextInt();
int m=cin.nextInt();
int d=cin.nextInt();
if(m==1||m==2) {
m+=12;
y--;}
W=(d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7+1;
System.out.println("星期="+W);
System.out.println("The Main class is end.");
}
}
/*基姆拉尔森计算公式
W= (d+2*m+3*(m+1)/5+y+y/4-y/100+y/400) mod 7
在公式中d表示日期中的日数，m表示月份数，y表示年数。
注意：在公式中有个与其他公式不同的地方：
把一月和二月看成是上一年的十三月和十四月，例：如果是2004-1-10则换算成：2003-13-10来代入公式计算。*/
求出区间[a,b]中所有整数的质因数分解。
输入格式
输入两个整数a，b。
输出格式
每行输出一个数的分解，形如k=a1a2a3…(a1<=a2<=a3…，k也是从小到大的)(具体可看样例)
样例输入
3 10
样例输出
3=3
4=22
5=5
6=23
7=7
8=222
9=33
10=25
提示
先筛出所有素数，然后再分解。
数据规模和约定
2<=a<=b<=10000import java.util.Scanner;
public class Main {
/**
* (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
* (2)如果n>k，但n能被k整除，则应打印出k的值，并用n除以k的商作为新的正整数n，重复执行第一步。
* (3)如果n不能被k整除，则用k+1作为k的值，重复执行第一步。
*
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Integer a = sc.nextInt();
Integer b = sc.nextInt();
for (int i = a; i <= b; i++) {
// 输入值大于等于3
if (i >= 3) {
String m = "";
int k = 2;
int j = i;
while (j != k) {
// 如果n>k，但n能被k整除，则应打印出k的值，并用n除以k的商作为新的正整数n
if (j % k == 0) {
m = m + k + "*";
j = j / k;
}
// 如果n不能被k整除，则用k+1作为k的值
else if (j % k != 0) {
k++;
}
}
m = m + k;
System.out.println(i + "=" + m);
} else {
System.out.println(i + "=" + i);
}
}
}
}
回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
交换的定义是：交换两个相邻的字符
例如mamad
第一次交换 ad : mamda
第二次交换 md : madma
第三次交换 ma : madam (回文！完美！)
输入格式
第一行是一个整数N，表示接下来的字符串的长度(N <= 8000)
第二行是一个字符串，长度为N.只包含小写字母
输出格式
如果可能，输出最少的交换次数。
否则输出Impossible
样例输入
5
mamad
样例输出
3import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = Integer.parseInt(scanner.nextLine());
String str = scanner.nextLine();
char[] chs = str.toCharArray();
int[] count = new int[26];
char ch = '0';
int oddchar = 0;
for (int j = 0; j < chs.length; j++) {
int index = chs[j] - 'a';
count[index]++;
}
for (int i = 0; i < 26; i++) {
if (count[i] % 2 != 0) {
oddchar++;
ch = (char) (i + 'a');
}
}
if (oddchar > 1) {
System.out.println("Impossible");
} else {
int result = exchange(chs, n, ch);
System.out.println(result);
}
}
}
private static int exchange(char[] chs, int n, char ch) {
int count = 0, i, j, k;
for (i = 0; i < n / 2; i++) {
if (chs[i] == ch) {
for (j = i; j < n - i - 1; j++) {
if (chs[j] == chs[n - i - 1]) {
break;
}
}
count += j - i;
for (k = j; k > i; k--) {
chs[k] = chs[k - 1];
}
chs[i] = chs[n - i - 1];
} else {
for (j = n - i - 1; j >= i; j--) {
if (chs[j] == chs[i]) {
break;
}
}
count += n - i - 1 - j;
for (k = j; k < n - i - 1; k++) {
chs[k] = chs[k + 1];
}
chs[n - i - 1] = chs[i];
}
}
return count;
}
}
给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：
1：两个字符串长度不等。比如 Beijing 和 Hebei
2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing
3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing
4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing
编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。
输入格式
包括两行，每行都是一个字符串
输出格式
仅有一个数字，表明这两个字符串的关系编号
样例输入
BEIjing
beiJing
样例输出
3import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner r=new Scanner(System.in);
String str1=r.nextLine();
String str2=r.nextLine();
String strTem1=str1.toLowerCase();
String strTem2=str2.toLowerCase();
if(str1.length()!=str2.length()){
System.out.println("1");
}
else{
if(str1.equals(str2)){
System.out.println("2");
}
if((str1.equals(str2)==false)&&(strTem1.equals(strTem2)==true)){
System.out.println("3");
}
if((str1.equals(str2)==false)&&(strTem1.equals(strTem2)==false)){
System.out.println("4");
}
}
}
}
下面程序判断一个long型整数n是否为回文数.如果是回文数,则输出"yes",否则输出"no".
回文数是它从左边读和从右边读是一样,例如121和55666655都是回文数.
但内部类Calc中部分代码缺失.请编写程序代码，使程序运行正确。import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner reader=new Scanner(System.in);
long n=reader.nextLong();
Calc a=new Calc();
boolean b=a.judge(n);
if(b==true)
System.out.println("yes");
if(b==false)
System.out.println("no");
System.out.println("The Main class is end.");
}
}
class Calc {
public Calc(){
}
public boolean judge(long n){
/*-----请编写代码-----*/
boolean flag=true;
long newed=0,p;
while(p>0){
newed=newed*10+p%10;
p/=10;
}
if(newed==n)
flag=true;
else
flag=false;
return flag;
/*-----编写的代码结束-----*/
}
}
有一个n个结点m条边的有向图，请输出他的关联矩阵。
输入格式
第一行两个整数n、m，表示图中结点和边的数目。n<=100,m<=1000。
接下来m行，每行两个整数a、b，表示图中有(a,b)边。
注意图中可能含有重边，但不会有自环。
输出格式
输出该图的关联矩阵，注意请勿改变边和结点的顺序。
样例输入
5 9
1 2
3 1
1 5
2 5
2 3
2 3
3 2
4 3
5 4
样例输出
1 -1 1 0 0 0 0 0 0
-1 0 0 1 1 1 -1 0 0
0 1 0 0 -1 -1 1 -1 0
0 0 0 0 0 0 0 1 -1
0 0 -1 -1 0 0 0 0 1#include