java基础题代码

74 阅读 0 评论 49 点赞

我是靠谱客的博主甜美缘分，最近开发中收集的这篇文章主要介绍java基础题代码，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

题中不排除存在错误的地方，若发现望评论告知，我将尽力更正，谢谢。

0031:全排列

描述

给定一个由不同的小写字母组成的字符串，输出这个字符串的所有全排列。我们假设对于小写字母有'a' < 'b' < ... < 'y' < 'z'，而且给定的字符串中的字母已经按照从小到大的顺序排列。

输入

输入只有一行，是一个由不同的小写字母组成的字符串，已知字符串的长度在1到6之间。

输出

输出这个字符串的所有排列方式，每行一个排列。要求字母序比较小的排列在前面。字母序如下定义：

已知S = s1s2...sk , T = t1t2...tk，则S < T 等价于，存在p (1 <= p <= k)，使得
s1 = t1, s2 = t2, ..., sp - 1 = tp - 1, sp < tp成立。

样例输入

abc

样例输出

abc
acb
bac
bca
cab
cba

代码：递归实现（参考大佬思路：java 全组合与全排列）

import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner in=new Scanner(System.in);
String s=in.nextLine();
int len=s.length();
String result="";
permutation(s,result,len);
}
/*
定义递归实现全排列的方法
*/
public static void permutation(String s,String result,int len) {
if(result.length()==len){
System.out.println(result);
}
else {
for(int i=0;i<s.length();i++) {
if((result.indexOf(s.charAt(i))<0)) {
permutation(s,result+s.charAt(i),len);//递归实现这个地方自己写写以abc为例就知道为什么用递归了
}
}
}
}
}

0032:数字求和

描述

给定一个正整数a，以及另外的5个正整数，问题是：这5个整数中，小于a的整数的和是多少？

输入

输入一行，只包括6个小于100的正整数，其中第一个正整数就是a。

输出

输出一行，给出一个正整数，是5个数中小于a的数的和。

样例输入

10 1 2 3 4 11

样例输出

import java.util.Scanner;
import java.math.*;
//import java.text.DecimalFormat;
public class Main{
public static void main(String[]args) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int ans=0;
for(int i=1;i<=5;i++) {
int temp=in.nextInt();
if(temp<n) {
ans+=temp;
}
}
System.out.println(ans);
// DecimalFormat df=new DecimalFormat(".00");
//System.out.println(df.format(rest));
}
}

0034:Checking order

描述

输入长度为5的数字串，检查是否是按从小到大的顺序排列，如果是，输出Yes；否则，输出No，并输出从小到大排序后的结果。

输入

长度为5的一串数字；

输出

判断结果及排序后的结果。

样例输入

1 3 5 7 9
5 3 44 7 3
1 1 2 2 3

样例输出

Yes
No 3 3 5 7 44
Yes

提示

1.测试数据很多组，采用如下的方式进行输入，每输入一组进行判断并输出，可以参考下面的模版：

int a[5];
while(cin>>a[0]>>a[1]>>a[2]>>a[3]>>a[4])
{
…
…
if (SORTED) // 输入数串已排好序
cout<<”Yes”< else
//输出No，并输出排序后的结果，注意换行！
}

2.注意ACM题目的特点，不要输出额外的信息。

import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int oldnum[]=new int[5];
int s;
try {
while((s=in.nextInt())!=Integer.MAX_VALUE)
{
boolean flag=true;
oldnum[0]=s;
for(int i=1;i<5;i++) {
oldnum[i]=in.nextInt();
if(oldnum[i]<oldnum[i-1]) {
flag=false;
}
}
if(flag)
System.out.println("Yes");
else{
Arrays.sort(oldnum);
System.out.print("No ");
for(int i:oldnum)
System.out.print(i+" ");
System.out.println();
}
}
}catch(NoSuchElementException e){
return;
}
}
}

0035:首字母大写

描述

对一个字符串中的所有单词，如果单词的首字母不是大写字母，则把单词的首字母变成大写字母。在字符串中，单词之间通过空白符分隔，空白符包括：空格(' ')、制表符('t')、回车符('r')、换行符('n')。

输入

输入一行：待处理的字符串（长度小于80）。

输出

输出一行：转换后的字符串。

样例输入

if so, you already have a google account. you can sign in on the right.

样例输出

If So, You Already Have A Google Account. You Can Sign In On The Right.

import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner in=new Scanner(System.in);
String s=in.nextLine();
char a[]=s.toCharArray();
for(int i=0;i<s.length();i++) {
if(a[i]==' ') {
if(a[i+1]>='a'&&a[i+1]<='z')
a[i+1]=(char)(a[i+1]-32);
}
}
if(a[0]>='a'&&a[0]<='z')
a[0]=(char)(a[0]-32);
for(int i=0;i<s.length();i++) {
System.out.print(a[i]);
}
}

0037:小白鼠再排队

描述

N只小白鼠(1 < N < 100)，每只鼠头上戴着一顶有颜色的帽子。现在称出每只白鼠的重量，要求按照白鼠重量从小到大的顺序输出它们头上帽子的颜色。帽子的颜色用 “red”，“blue”等字符串来表示。不同的小白鼠可以戴相同颜色的帽子。白鼠的重量用整数表示。

输入

输入第一行为一个整数N，表示小白鼠的数目。
下面有N行，每行是一只白鼠的信息。第一个为正整数，表示白鼠的重量，；第二个为字符串，表示白鼠的帽子颜色，字符串长度不超过10个字符。

注意：白鼠的重量各不相同。

输出

按照白鼠的重量从小到大的顺序输出白鼠的帽子颜色。

样例输入

3
30 red
50 blue
40 green

样例输出

red
green
blue

import java.util.Arrays;
import java.util.Scanner;
class Mous implements Comparable<Mous>{///自定义排序
int num;
String color;
public int compareTo(Mous i) {
if(this.num<i.num){
return -1;
}else{
return 1;
}
}
}
public class Main{
static Mous mous[];
static Mous mou;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()){
int n = in.nextInt();
mous = new Mous[n];
for(int i=0;i<n;i++){
mou = new Mous();
mou.num=in.nextInt();
mou.color=in.next();
mous[i]=mou;
}
Arrays.sort(mous);
for(int i=0;i<n;i++){
System.out.println(mous[i].color);
}
}
}
}

0040:中位数

描述

中位数定义：一组数据按从小到大的顺序依次排列，处在中间位置的一个数或最中间两个数据的平均值（如果这组数的个数为奇数，则中位数为位于中间位置的那个数；如果这组数的个数为偶数，则中位数是位于中间位置的两个数的平均值）.
给出一组无序整数，求出中位数，如果求最中间两个数的平均数，向下取整即可（不需要使用浮点数）

输入

该程序包含多组测试数据，每一组测试数据的第一行为N，代表该组测试数据包含的数据个数，1 <= N <= 15000.
接着N行为N个数据的输入，N=0时结束输入

输出

输出中位数，每一组测试数据输出一行

样例输入

样例输出

25
40
2

import java.util.Scanner;
import java.util.Arrays;
//import java.math.*;
//import java.text.DecimalFormat;
public class Main{
public static void main(String[]args) {
Scanner in=new Scanner(System.in);
int arr[]=new int[15008];
while(true) {
int n=in.nextInt();
in.nextLine();
if(n==0) break;
for(int i=1;i<=n;i++) {
arr[i]=in.nextInt();
}
Arrays.sort(arr,1,n+1);
if(n%2==0) {
int t=n/2;
int ans=(arr[t]+arr[t+1])/2;
System.out.println(ans);
}
else {
System.out.println(arr[n/2+1]);
}
}
}
}
// DecimalFormat df=new DecimalFormat(".00");
//System.out.println(df.format(rest));

0042:Problem N:矩阵交换行

描述

编写一个函数，输入参数是5*5的二维数组，和n，m两个行下标。功能：判断n，m是否在数组范围内，如果不在，则返回0；如果在范围内，则将n行和m行交换，并返回1。
在main函数中，生成一个5*5的矩阵，输入矩阵数据，并输入n，m的值。调用前面的函数。如果返回值为0，输出error。如果返回值为1，输出交换n，m后的新矩阵。

输入

5*5矩阵的数据，以及n和m的值。

输出

如果不可交换，则输出error；
如果可交换，则输出新矩阵

样例输入

样例输出

提示

不需要用while循环来反复读取文件中的测试集。
输出error格式如下：
cout<< "error" << endl;
输出矩阵格式如下：
cout<< setw(4)<< num;
输出矩阵一行后要输出cout<< endl;

PS：注意输出格式，四个宽度右对齐，结果错了无数次，感谢于衡大佬的help

import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int[][] a=new int[5][5];
for(int c=0;c<5;c++){
for(int d=0;d<5;d++){
a[c][d]=sc.nextInt();
}
}
int m=sc.nextInt();
int n=sc.nextInt();
if(f(m,n)){//n，m是否在数组范围内
for(int i=0;i<5;i++){
for(int j=0;j<5;j++){
int k=a[m][j];
a[m][j]=a[n][j];
a[n][j]=k;
System.out.printf("%4d",a[i][j]);
}
System.out.println();
}
}
else
System.out.print("error");
}
public static boolean f(int x,int y){
if((x>=0&&x<5)&&(y>=0&&y<5))
return true;
return false;
}
}

0043:求字符串长度

描述

求一个长度不大于100的字符串的长度，要求不使用strlen方法，并且使用到字符指针。

输入

输出

字符串的长度。

样例输入

I love Beijing.

样例输出

import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner in=new Scanner(System.in);
String s=in.nextLine();
System.out.println(s.length());
}
}

0044:计算反序数

描述

编写函数，参数为一个整数，返回这个整数的反序数，例如参数是1576，返回一个整数6751，如果输入时1230，则返回321。在main函数中调用此函数，并将结果输出。

输入

一个整数

输出

它的反序数

样例输入

样例输出

提示

需要保留数字的符号.负数的反序数仍然是负数,正数的反序数不用添加符号.
要求以子函数的形式计算此反序数,子函数的形式为:
int reverse(int num);

输入不会超出int的大小.

因为有多组测试数据,读取输入的时候建议采用如下形式:
int i = 0;
while(cin>>i)
{
//你的代码

import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner in=new Scanner(System.in);
int a[]=new int[100];
int n;
while(in.hasNext())
{
n=in.nextInt();
if(n==0) {
System.out.println(0);
}
else {
boolean flag=true;
if(n<0) {
flag=false;
n=-n;
}
int i=0;
while(n!=0) {
a[i]=n%10;
n/=10;
i++;
}
if(!flag) {
System.out.print("-");
}
boolean flag2=true;
for(int j=0;j<i;j++){
if((flag2&&a[j]==0))
{
continue;
}
else flag2=false;
System.out.print(a[j]);
}
System.out.println();
}
}
}
}

0046:循环移动

描述

给定一组整数，要求利用数组把这组数保存起来，再利用指针实现对数组中的数循环移动。假定共有n个整数，则要使前面各数顺序向后移m个位置，并使最后m各数变为最前面的m各数。

注意，不要用先输出后m个数，再输出前n-m个数的方法实现，也不要用两个数组的方式实现。

要求只用一个数组的方式实现，一定要保证在输出结果时，输出的顺序和数组中数的顺序是一致的。

输入

输入有两行：第一行包含一个正整数n和一个正整数m，第二行包含n个正整数。每两个正整数中间用一个空格分开。

输出

输出有一行：经过循环移动后数组中整数的顺序依次输出，每两个整数之间用空格分隔。

样例输入

11 4
15 3 76 67 84 87 13 67 45 34 45

样例输出

67 45 34 45 15 3 76 67 84 87 13

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int a[]=new int[108];
int n=in.nextInt();
int m=in.nextInt();
for(int i=1;i<=n;i++) {
a[i]=in.nextInt();
}
for(int i=n-m+1;i<=n;i++) {
System.out.print(a[i]+" ");
}
for(int i=1;i<=n-m;i++) {
System.out.print(a[i]+" ");
}
}
}

0047:约瑟夫问题

描述

约瑟夫问题：有ｎ只猴子，按顺时针方向围成一圈选大王（编号从１到ｎ），从第１号开始报数，一直数到ｍ，数到ｍ的猴子退出圈外，剩下的猴子再接着从1开始报数。就这样，直到圈内只剩下一只猴子时，这个猴子就是猴王，编程求输入ｎ，ｍ后，输出最后猴王的编号。

输入

每行是用空格分开的两个整数，第一个是 n, 第二个是 m ( 0 < m,n <=300)。最后一行是：

0 0

输出

对于每行输入数据（最后一行除外)，输出数据也是一行，即最后猴王的编号

样例输入

样例输出

5
1
7

PS：推一遍吗，不存在的直接套公式，伤心后面有道类似的题不会做，不要套公式了

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
while(true) {
int n=in.nextInt();
int m=in.nextInt();
if(n==0&&m==0) break;
int ans=0;
for(int i=2;i<=n;i++) {
ans=(ans+m)%i;
}
System.out.println(ans+1);
}
}
}

集合Linkedlist实现：

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner sc=new Scanner(System.in);
while(true) {
int n=sc.nextInt();
int m=sc.nextInt();
if(n==0&&m==0) break;
List<Integer> list=new LinkedList<Integer>();
for(int i=1;i<=n;i++) {
list.add(i);
}
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
list.add(list.remove(0));
}
list.remove(0);
}
System.out.println(list.get(0));
}
}
}

0048:小孩报数问题

描述

有N个小孩围成一圈，给他们从1开始依次编号，现指定从第W个开始报数，报到第S个时，该小孩出列，然后从下一个小孩开始报数，仍是报到S个出列，如此重复下去，直到所有的小孩都出列（总人数不足S个时将循环报数），求小孩出列的顺序。

输入

第一行输入小孩的人数N（N<=64）
接下来每行输入一个小孩的名字(人名不超过15个字符)
最后一行输入asdasdasdasdW,S (W < N)，用逗号”,”间隔

输出

按人名输出小孩按顺序出列的顺序，每行输出一个人名

样例输入

5
Xiaoming
Xiaohua
Xiaowang
Zhangsan
Lisi
2,3

样例输出

Zhangsan
Xiaohua
Xiaoming
Xiaowang
Lisi

老师的思路：代码我又手敲一遍

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner sc=new Scanner(System.in);
List<String> list=new LinkedList<String>();
int n=sc.nextInt();
for(int i=1;i<=n;i++) {
String s=sc.next();
list.add(s);
}
sc.nextLine();
String s=sc.nextLine();
String[] arr=s.split(",");
int b=Integer.parseInt(arr[0]);
int e=Integer.parseInt(arr[1]);
for(int i=1;i<b;i++) {
list.add(list.remove(0));///这个思路真惊悚啊，太TIm的优秀了
}
for(int i=1;i<=n;i++) {
for(int j=1;j<e;j++) {
list.add(list.remove(0));
}
System.out.println(list.remove(0));///虽然没有删除元素，但都移到l后面
}
}
}

0052:扩号匹配

描述

判断一组匹配的左右扩号序列中，每一个右扩号与之相匹配成对的左扩号是整个扩号序列的第几个扩号。输出所有判断结果。

输入

输入有两行。
第一行输入一个整数（该整数必定是偶数），该整数表示扩号序列中一共有多少个扩号。
第二行输入用1和2分别代表左右扩号的扩号序列。例如输入序列11211222，表示扩号序列(()(()))。

输出

输出为一行。即挨个输出每个2（右扩号‘）’）与之相匹配的1（左扩号‘（’）在扩号序列中是第几个，用空格格开。

样例输入

4
1212
4
1122
6
112122
8
11211222
20
11211122122121122212

样例输出

1 3
2 1
2 4 1
2 5 4 1
2 6 5 9 4 12 15 14 1 19

提示

输入的扩号总数一定为偶数。输入的12序列必定是匹配的，1和2的个数相等，必为扩号总数的一半。
测试数据有多组，采用while()循环输入。

import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner in= new Scanner(System.in);
while(in.hasNext()) {
int n=in.nextInt();
in.nextLine();
String s=in.nextLine();
char a[]=s.toCharArray();
for(int i=1;i<n;i++){
if(a[i]=='2') {
for(int j=i;j>=0;--j) {
if(a[j]=='1'){
a[j]=' ';
System.out.print((j+1)+" ");
break;
}
}
}
}
System.out.println();
}
}
}

0053:集合合并

描述

已知集合A与集合B，且第个集合内数据是唯一的。求A，B集合合并成新的集合C，要求C集合内的数据也是唯一的。并指出C集合的个数。

输入

三行，第一行分别为集合A，B的个数
第二行为A集合的数据
第三行为B集合的数据

输出

两行
第一行集合C的个数
第二行为C集合的数据

样例输入

4 5
12 34 56 78
34 67 89 34 76

样例输出

7
12 34 56 78 67 89 76

import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner in= new Scanner(System.in);
int a[]=new int[1008];
int n=in.nextInt();
int m=in.nextInt();
for(int i=1;i<=n;i++ ) {
a[i]=in.nextInt();
}
int t=n+m;
for(int i=n+1;i<=t;i++) {
a[i]=in.nextInt();
}
int ans=0;
for(int i=1;i<=t;i++) {
for(int j=1;j<i;j++) {
if(a[i]==a[j]&&a[i]!=300000) {
ans++;
a[i]=300000;
}
}
}
System.out.println(t-ans);
for(int i=1;i<=t;i++) {
if(a[i]!=300000) {
System.out.print(a[i]+" ");
}
}
}
}

0059:验证“歌德巴赫猜想”

描述

验证“歌德巴赫猜想”，即：任意一个大于等于6的偶数均可表示成两个素数之和。

输入

输入只有一个正整数x。(x<=2000)

输出

如果x不是“大于等于6的偶数”，则输出一行：
Error!
否则输出这个数的所有分解形式，形式为：
x=y+z
其中x为待验证的数，y和z满足y+z=x，而且y<=z，y和z均是素数。
如果存在多组分解形式，则按照y的升序输出所有的分解，每行一个分解表达式。

注意输出不要有多余的空格。

样例输入

输入样例1:
7
输入样例2:
10
输入样例3:
100

样例输出

输出样例1:
Error!
输出样例2:
10=3+7
10=5+5
输出样例3:
100=3+97
100=11+89
100=17+83
100=29+71
100=41+59
100=47+53

import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner in= new Scanner(System.in);
int isprime[]=new int[2008];//将素数都标记为0
int n=in.nextInt();
if(n<6||n%2==1)
System.out.println("Error!");
else {
for(int i=2;i<=n;i++) {
for(int j=i*2;j<=n;j+=i) {
isprime[j]=1;
}
}
boolean flag=true;
for(int i=2;i<=n/2;i++) {
if(isprime[i]==0&&isprime[n-i]==0){
System.out.println(n+"="+i+"+"+(n-i));
flag=false;
}
}
if(flag) {
System.out.println("Error!");
}
}
}
}

0060:肿瘤检测

描述

一张CT扫描的灰度图像可以用一个N*N（0 < N <= 100）的矩阵描述，矩阵上的每个点对应一个灰度值（整数），其取值范围是0-255。我们假设给定的图像中有且只有一个肿瘤。在图上监测肿瘤的方法如下：如果某个点对应的灰度值小于等于50，则这个点在肿瘤上，否则不在肿瘤上。我们把在肿瘤上的点的数目加起来，就得到了肿瘤在图上的面积。任何在肿瘤上的点，如果它是图像的边界或者它的上下左右四个相邻点中至少有一个是非肿瘤上的点，则该点称为肿瘤的边界点。肿瘤的边界点的个数称为肿瘤的周长。现在给定一个图像，要求计算其中的肿瘤的面积和周长。

输入

输入第一行包含一个正整数N（0 < N <= 100），表示图像的大小；接下来N行，每行包含图像的一行。图像的一行用N个整数表示（所有整数大于等于0，小于等于255），两个整数之间用一个空格隔开。

输出

输出只有一行，该行包含两个正整数，分别为给定图像中肿瘤的面积和周长，用一个空格分开。

样例输入

6
99 99 99 99 99 99
99 99 99 50 99 99
99 99 49 49 50 51
99 50 20 25 52 99
40 50 99 99 99 99
99 99 99 99 99 99

样例输出

9 8

import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner in= new Scanner(System.in);
int a[][]=new int[108][108];
int n=in.nextInt();
int length=0,area=0;
for(int i=1;i<=n;i++) {
for(int j=1;j<=n;j++){
a[i][j]=in.nextInt();
if(a[i][j]<=50) {
area++;
}
}
}
for(int i=2;i<=n-1;i++) {
for(int j=2;j<=n-1;j++) {
if(a[i][j]<=50&&a[i-1][j]<=50&&a[i][j-1]<=50&&a[i][j+1]<=50&&a[i+1][j]<=50) {
length++;
}
}
}
System.out.println(area+" "+(area-length));
}
}

0063:不吉利日期

描述

在国外，每月的13号和每周的星期5都是不吉利的。特别是当13号那天恰好是星期5时，更不吉利。已知某年的一月一日是星期w，并且这一年一定不是闰年，求出这一年所有13号那天是星期5的月份，按从小到大的顺序输出月份数字。（w=1..7）

输入

输入有一行，即一月一日星期几（w）。（1 <= w <= 7）

输出

输出有一到多行，每行一个月份，表示该月的13日是星期五。

样例输入

样例输出

1
10

提示

1、3、5、7、8、10、12月各有31天
4、6、9、11月各有30天
2月有28天

import java.util.Scanner;
public class Main {
public static
void main(String[]args){
Scanner in=new Scanner(System.in);
int a[]={31,28,31,30,31,30,31,31,30,31,30,31};
int n=in.nextInt();
n+=12;
n%=7;
if(n==5){
System.out.println("1");
}
for(int i=0;i<11;i++){
n+=a[i];
n%=7;
if(n==5){
System.out.println(i+2);
}
}
}
}

0066:奇数单增序列

描述

给定一个长度为N（不大于500）的正整数序列，请将其中的所有奇数取出，并按升序输出。

输入

共2行：
第1行为 N；
第2行为 N 个正整数，其间用空格间隔。

输出

增序输出的奇数序列，数据之间以逗号间隔。数据保证至少有一个奇数。

样例输入

10
1 3 2 6 5 4 9 8 7 10

样例输出

1,3,5,7,9

import java.util.Scanner;
import java.util.Arrays;
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int a[]=new int[608];
int n=in.nextInt();
int j=0;
for(int i=1;i<=n;i++) {
int temp=in.nextInt();
if(temp%2==1) {
a[++j]=temp;
}
}
Arrays.sort(a, 1,j+1);
for(int i=1;i<=j;i++) {
if(i!=j)
System.out.print(a[i]+",");
else System.out.println(a[i]);
}
}
}

0067:整数奇偶排序

描述

给定10个整数的序列，要求对其重新排序。排序要求:

1.奇数在前，偶数在后；

2.奇数按从大到小排序；

3.偶数按从小到大排序。

输入

输入一行，包含10个整数，彼此以一个空格分开，每个整数的范围是大于等于0，小于等于100。

输出

按照要求排序后输出一行，包含排序后的10个整数，数与数之间以一个空格分开。

样例输入

4 7 3 13 11 12 0 47 34 98

样例输出

47 13 11 7 3 0 4 12 34 98

import java.util.Comparator;
import java.util.Scanner;
import java.util.Arrays;
import java.util.*;
class shu{
int x;
}
class cmp implements Comparator<shu>{
public int compare(shu A,shu B) {
if(A.x<B.x) {
return 1;
}
else return -1;
}
}
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
shu a[]=new shu[18];
int b[]=new int[18];
//int n=in.nextInt();
int j=1,k=0;
for(int i=1;i<=10;i++) {
int temp=in.nextInt();
if(temp%2==1) {
a[j]=new shu();
a[j].x=temp;
j++;
}else {
b[++k]=temp;
}
}
j--;
Arrays.sort(a,1,j+1,new cmp());
Arrays.sort(b,1,k+1);
for(int i=1;i<=j;i++) {
System.out.print(a[i].x+" ");
}
for(int i=1;i<=k;i++) {
if(i!=k)
System.out.print(b[i]+" ");
else System.out.println(b[i]);
}
}
}

0068:整数去重

输入

输入包含两行：
第一行包含一个正整数n（1 <= n <= 20000），表示第二行序列中数字的个数；
第二行包含n个整数，整数之间以一个空格分开。每个整数大于等于10、小于等于100。

输出

输出只有一行，按照输入的顺序输出其中不重复的数字，整数之间用一个空格分开。

样例输入

5
10 12 93 12 75

样例输出

10 12 93 75

import java.util.Scanner;
public class Main{
public static void main(String[]agrs) {
Scanner in=new Scanner(System.in);
int a[]=new int[20008];
int n=in.nextInt();
for(int i=1;i<=n;i++) {
a[i]=in.nextInt();
for(int j=1;j<i;j++) {
if(a[i]==a[j]) {
i--;
n--;
}
}
}
for(int i=1;i<=n;i++) {
if(i!=n)
System.out.print(a[i]+" ");
else System.out.println(a[i]);
}
}

0072:敲七

描述

输出7和7的倍数，还有包含7的数字。例如（17，27，37...70，71，72，73...）

输入

一个整数N。(N不大于30000)

输出

从小到大排列的不大于N的与7有关的数字，每行一个。

样例输入

样例输出

7
14
17

import java.util.Scanner;
public class Main{
public static void main(String[]agrs) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
for(int i=1;i<=n;i++) {
if(i%7==0) System.out.println(i);
else {
int temp=i;
while(temp>0){
if(temp%10==7) {
System.out.println(i);
break;
}
temp/=10;
}
}
}
}
}

0074:等比数列末项计算

描述

已知等比数列的公比是2，现给出等比数列的第一项a1，求第n项是多少？

输入

一行，包含三个整数a1，n。-100 <= a1<= 100，0 < n <= 1000。

输出

一个整数，即第n项的值。

样例输入

1 3

样例输出

import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int m=in.nextInt();
for(int i=1;i<=m-1;i++){
n*=2;
}
System.out.println(n);
}
}

0076:二项式系数

描述

二项式系数C(n, k)因它在组合数学中的重要性而被广泛地研究。二项式系数可以如下递归的定义：

C(1, 0) = C(1, 1) = 1；
C(n, 0) = 1对于所有n > 0；
C(n, k) = C(n − 1, k − 1) + C(n − 1, k)对于所有0 < k ≤ n。

给出n和k，你要确定C(n, k)的奇偶性。

输入

输入包含多组测试数据。每组测试数据一对整数n和k(0 ≤ k ≤ n < 231)，占据独立一行。

文件结束符（EOF）表示输入结束。

输出

对每组测试数据，输出一行，包含一个“0” 或一个“1”，即C(n, k)除以2的余数。

样例输入

1 1
1 0
2 1

样例输出

1
1
0

思路：根据lucass定理的一个推论，对于C（n,m）当n&m==m是为奇数，不等于为偶数。当然当n=

0或者等于1是C(1,m)或者C（0，m）必为1。关于此推论的证明自行解决，通过二进制计算证明的较难理解。

代码：

import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner in=new Scanner(System.in);
while(in.hasNext()) {
int n=in.nextInt();
int m=in.nextInt();
if(n==0||n==1) System.out.println("1111");
else if((n&m)==m) System.out.println("1");
else System.out.println("0");
}
}
}

0087:计算矩阵边缘元素之和

描述

输入一个整数矩阵，计算位于矩阵边缘的元素之和。所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。

输入

第一行分别为矩阵的行数m和列数n（m < 100，n < 100），两者之间以一个空格分开。
接下来输入的m行数据中，每行包含n个整数，整数之间以一个空格分开。

输出

输出对应矩阵的边缘元素和

样例输入

样例输出

import java.util.Scanner;
public class Main
{
public static void main(String []args){
Scanner in=new Scanner(System.in);
int m=in.nextInt();
int n=in.nextInt();
int ans=0;
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++){
int temp=in.nextInt();
if(i==1||i==m){
ans+=temp;
}
if((j==1||j==n)&&(i!=1&&i!=m)){
ans+=temp;
}
}
}
System.out.println(ans);
}

0093:校门外的树

描述

某校大门外长度为L的马路上有一排树，每两棵相邻的树之间的间隔都是1米。我们可以把马路看成一个数轴，马路的一端在数轴0的位置，另一端在L的位置；数轴上的每个整数点，即0，1，2，……，L，都种有一棵树。

由于马路上有一些区域要用来建地铁。这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。现在要把这些区域中的树（包括区域端点处的两棵树）移走。你的任务是计算将这些树都移走后，马路上还有多少棵树。

输入

第一行有两个整数L（1 <= L <= 10000）和 M（1 <= M <= 100），L代表马路的长度，M代表区域的数目，L和M之间用一个空格隔开。接下来的M行每行包含两个不同的整数，用一个空格隔开，表示一个区域的起始点和终止点的坐标。

对于20%的数据，区域之间没有重合的部分；
对于其它的数据，区域之间有重合的情况。

输出

包括一行，这一行只包含一个整数，表示马路上剩余的树的数目。

样例输入

样例输出

import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int a[]=new int[10008];
int L=in.nextInt();
int t=in.nextInt();
for(int j=1;j<=t;j++){
int star=in.nextInt();
int over=in.nextInt();
for(int i=star;i<=over;i++) {
a[i]=1;
}
}
int ans=0;
for(int i=0;i<=L;i++) {
if(a[i]==0) ans++;
}
System.out.println(ans);
}
}

0095:数组逆序重放

描述

将一个数组中的值按逆序重新存放。例如，原来的顺序为8,6,5,4,1。要求改为1,4,5,6,8。

输入

输入为两行：第一行数组中元素的个数n（1<n<100)，第二行是n个整数，每两个整数之间用空格分隔。

输出

输出为一行：输出逆序后数组的整数，每两个整数之间用空格分隔。

样例输入

5
8 6 5 4 1

样例输出

1 4 5 6 8

import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int a[]=new int[108];
for(int i=1;i<=n;i++) {
a[i]=in.nextInt();
}
for(int i=n;i>=1;i--) {
if(i!=1)
System.out.print(a[i]+" ");
else System.out.println(a[i]);
}
}
}

0096:正方形长方形的个数

描述

设有一个n*m方格的棋盘（1≤m,n≤100）。

求出该棋盘中包含多少个正方形、多少个长方形（不包括正方形）。

例如：当n=2，m=3时

正方形的个数有8个；即边长为1的正方形有6个；

边长为2的正方形有2个。

长方形的个数有10个

即2*1的长方形有4个

1*2的长方形有3个

3*1的长方形有2个

3*2的长方形有1个

输入

n和m

输出

正方形的个数与长方形的个数，用逗号分隔

样例输入

2 3

样例输出

8,10

import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int m=in.nextInt();
if(n<m) {
int temp=n;
n=m;
m=temp;
}
int juxing=(m*(m+1)/2)*(n*(n+1)/2);
int zheng=m*n;
for(int i=1;i<=m;i++) {
zheng+=(m-i)*(n-i);
}
System.out.println(zheng+","+(juxing-zheng));
}
}
/*对于一个n*m的棋盘，共有矩形 (m+m-1+m-2+...+1)*(n+n-1+n-2+...+1)
即[m*(m+1)/2]*[n*(n+1)/2]个，这一步可用前一个式子循环加，也可用后一个式子直接算；
共有正方形（假设m>n) m*n+(m-1)*(n-1)+...+(m-n+1)*1 个，这步用循环做就行；
你所说的长方形就用 矩形数 减去 正方形数 就行*/

0097:与指定数字相同的数的个数

描述

输出一个整数序列中与指定数字相同的数的个数。

输入

输入包含三行：
第一行为N，表示整数序列的长度(N <= 100)；
第二行为N个整数，整数之间以一个空格分开；
第三行包含一个整数，为指定的整数m。

输出

输出为N个数中与m相同的数的个数。

样例输入

3
2 3 2
2

样例输出

import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int a[]=new int[108];
int n=in.nextInt();
for(int i=1;i<=n;i++) {
a[i]=in.nextInt();
}
int t=in.nextInt();
int ans=0;
for(int i=1;i<=n;i++) {
if(a[i]==t) {
ans++;
}
}
System.out.println(ans);
}
}

0099:数字求和

描述

Tom最近喜欢数字加法，她最喜欢把一行数据加在一起，然后输出。

输入

第一行有一个数字n,表示后面有n行数字。
以后的每一行数字，第一个数字m表示，该行要计算从该行第2个数字到m+1个数字之和。

输出

每一行对应一组输入数据的结果。

样例输入

样例输出

6
30
7

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int a[]=new int[108];
int n=in.nextInt();
for(int i=1;i<=n;i++) {
int temp=in.nextInt();
for(int j=1;j<=temp;j++) {
int temp2=in.nextInt();
a[i]+=temp2;
}
}
for(int i=1;i<=n;i++) {
System.out.println(a[i]);
}
}
}

0100:向量点积计算

描述

在线性代数、计算几何中，向量点积是一种十分重要的运算。

给定两个n维向量a=(a1,a2,...,an)和b=(b1,b2,...,bn)，求点积a·b=a1b1+a2b2+...+anbn。

输入

第一行是一个整数n。1 <= n <= 1000。
第二行包含n个整数a1,a2,...,an。
第三行包含n个整数b1,b2,...,bn。
相邻整数之间用单个空格隔开。每个整数的绝对值都不超过1000。

输出

一个整数，即两个向量的点积结果。

样例输入

3
1 4 6
2 1 5

样例输出

import java.util.Scanner;
public class Main
{
public static void main(String []args){
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int a[]=new int[1008];
int b[]=new int[1008];
for(int i=1;i<=n;i++){
a[i]=in.nextInt();
}
for(int i=1;i<=n;i++){
b[i]=in.nextInt();
}
int ans=0;
for(int i=1;i<=n;i++){
ans+=a[i]*b[i];
}
System.out.println(ans);
}
}