目录
1:明明的随机数
总时间限制: 1000ms 内存限制: 65536kB
描述
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤100），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。
输入
有2行，第1行为1个正整数，表示所生成的随机数的个数：N；
第2行有N个用空格隔开的正整数，为所产生的随机数。
输出
也是2行，第1行为1个正整数M，表示不相同的随机数的个数。第2行为M个用空格隔开的正整数，为从小到大排好序的不相同的随机数。
样例输入
10
20 40 32 67 40 20 89 300 400 15
样例输出
8
15 20 32 40 67 89 300 400
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
Arrays.sort(a);
List list = new ArrayList();
for (int x = 0; x < a.length; x++) {
if (!list.contains(a[x])) {
list.add(a[x]);
}
}
System.out.println(list.size());
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
}
}2:合影效果
总时间限制: 1000ms 内存限制: 65536kB
描述
小云和朋友们去爬香山，为美丽的景色所陶醉，想合影留念。如果他们站成一排，男生全部在左（从拍照者的角度），并按照从矮到高的顺序从左到右排，女生全部在右，并按照从高到矮的顺序从左到右排，请问他们合影的效果是什么样的（所有人的身高都不同）？
输入
第一行是人数n（2 <= n <= 40，且至少有1个男生和1个女生）。
后面紧跟n行，每行输入一个人的性别（男male或女female）和身高（浮点数，单位米），两个数据之间以空格分隔。
输出
n个浮点数，模拟站好队后，拍照者眼中从左到右每个人的身高。每个浮点数需保留到小数点后2位，相邻两个数之间用单个空格隔开。
样例输入
6
male 1.72
male 1.78
female 1.61
male 1.65
female 1.70
female 1.56
样例输出
1.65 1.72 1.78 1.70 1.61 1.56
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Ren[] ren = new Ren[n];
List boys = new ArrayList();
List girls = new ArrayList();
for (int i = 0; i < n; i++) {
ren[i] = new Ren(sc.next(), sc.nextDouble());
if (ren[i].sex.equals("male")) {
boys.add(ren[i].h);
} else if (ren[i].sex.equals("female")) {
girls.add(ren[i].h);
}
}
Collections.sort(boys);
Collections.sort(girls);
for (int i = 0; i < boys.size(); i++) {
System.out.printf("%.2f", boys.get(i));
System.out.print(" ");
}
for (int i = girls.size() - 1; i >= 0; i--) {
System.out.printf("%.2f", girls.get(i));
System.out.print(" ");
}
}
}
class Ren {
String sex;
double h;
public Ren(String sex, double h) {
super();
this.sex = sex;
this.h = h;
}
}3:不重复的单词
总时间限制: 1000ms 内存限制: 65535kB
描述
map、vector和sort的组合使用。输入一个句子（以单独的一个英文句号.作为结束判断标志），按照字典顺序由小到大输出该句子中不重复的单词。
输入
以.作为结尾的句子
输出
多行字符串
样例输入
jin tian de tian qi bu cuo .
样例输出
bu
cuo
de
jin
qi
tian
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List ss = new ArrayList<>();
while (sc.hasNext()) {
String word = sc.next();
if (word.equals(".")) {
break;
}
if (!ss.contains(word)) {
ss.add(word);
}
}
Collections.sort(ss); //自然顺序
for (int i = 0; i < ss.size(); i++) {
System.out.println(ss.get(i));
}
}
}4:和为给定数
描述
给出若干个整数，询问其中是否有一对数的和等于给定的数。
输入
共三行：
第一行是整数n(0 < n <= 100,000)，表示有n个整数。
第二行是n个整数。整数的范围是在0到10^8之间。
第三行是一个整数m（0 <= m <= 2^30)，表示需要得到的和。
输出
若存在和为m的数对，输出两个整数，小的在前，大的在后，中间用单个空格隔开。若有多个数对满足条件，选择数对中较小的数更小的。若找不到符合要求的数对，输出一行No。
样例输入
4
2 5 1 4
6
样例输出
1 5
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
Arrays.sort(a);
int m = sc.nextInt();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (a[i] + a[j] == m) {
System.out.print(a[i] + " " + a[j]);
return;
}
}
if (i == n - 1) {
System.out.println("No");
break;
}
}
}
}5:字符串数组排序问题
总时间限制: 1000ms 内存限制: 65536kB
描述
给定一组字符串，按指定的排序方式输出这些字符串。排序可是自然顺序（inc）、自然逆序（dec）、忽略大小写顺序（ncinc）、忽略大小写逆序（ncdec）等。
输入
输入有多行，第一行为一个表明排序方式的字符串见题面，第二行为字符串的数目。
其余各行每行一个字符串，字符串中间可能空格，前后也可能有空格，但前后的空格要忽略。
输出
输出也有多行，按指定的顺序输出输入的字符串。
样例输入
ncdec
3
Hello World!
You're right!
haha! you're wrong!
样例输出
You're right!
Hello World!
haha! you're wrong!
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s1 = sc.next();
int a1 = sc.nextInt();
sc.nextLine();
List<String> slist = new ArrayList<String>();
for (int i = 0; i < a1; i++) {
slist.add(sc.nextLine());
}
if ("inc".equals(s1)) {
Collections.sort(slist);
} else if ("dec".equals(s1)) {
Collections.sort(slist, (p1, p2) -> p2.compareTo(p1));
} else if ("ncinc".equals(s1)) {
Collections.sort(slist,
(p1, p2) -> p1.toLowerCase().compareTo(p2.toLowerCase()));
} else if ("ncdec".equals(s1)) {
Collections.sort(slist,
(p1, p2) -> p2.toLowerCase().compareTo(p1.toLowerCase()));
}
for (String s : slist) {
System.out.println(s);
}
}
}import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String meathed = sc.next();
int n = sc.nextInt();
sc.nextLine();
String[] ss = new String[n];
for (int i = 0; i < n; i++) {
ss[i] = sc.nextLine().trim();
}
if (meathed.equals("inc")) Arrays.sort(ss); //自然顺序
if (meathed.equals("dec")) Arrays.sort(ss, Collections.reverseOrder()); //自然逆序
if (meathed.equals("ncinc")) Arrays.sort(ss, String.CASE_INSENSITIVE_ORDER); //忽略大小写顺序
if (meathed.equals("ncdec")) { //忽略大小写逆序
Arrays.sort(ss, String.CASE_INSENSITIVE_ORDER);
Collections.reverse(Arrays.asList(ss));
}
for (String s : ss) {
System.out.println(s);
}
}
}6:字符串排序
总时间限制: 1000ms 内存限制: 65536kB
描述
现在有一些长度不等的字符串（只由26个大写字母组成），请将它们按照逆序对的数量多少排序。
逆序对指的是字符串A中的两个字符A[i]、A[j]，具有i < j 且A[i] > A[j] 的性质。如字符串”ATCG”中，T和C是一个逆序对，T和G是另一个逆序对，这个字符串的逆序对数为2。
字符的大小按照字母表的ASCII值大小来比较。
输入
第1行：1个整数m表示字符串数量，且0 < m <= 100。
第2至m+1行：每行是一个字符串，字符全为大写，长度不超多50。
可能会有重复的字符串出现。
输出
按逆序对数从少到多输出字符串，逆序对数一样多的字符串按照输入的顺序输出。
样例输入
3
ACBCDEFG
GFEDCBA
AEDEFG
样例输出
ACBCDEFG
AEDEFG
GFEDCBA
import java.util.Arrays;
import java.util.Scanner;
public class Main {
static int nixudui(String s) {
int len = s.length();
int sum = 0;
for (int i = 0; i < len - 1; i++) {
for (int j = i + 1; j < len; j++) {
if (s.charAt(i) > s.charAt(j)) {
sum++;
}
}
}
return sum;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String[] a = new String[n];
for (int i = 0; i < n; i++) {
a[i] = sc.next();
}
Arrays.sort(a, (s1, s2) -> nixudui(s1) - nixudui(s2));
for (String s : a) {
System.out.println(s);
}
}
}7:求序列中的众数
总时间限制: 1000ms 内存限制: 65536kB
描述
输入一个长度为N的整数序列 (不多于128个整数)，每个整数的范围在[-1052,1052]，计算这个序列的众数。
众数是指出现次数最多的那个数。
如果有多个数出现的次数都达到最多，则取在原序列最先出现的数为众数；如果所有的数都相等，则返回"no"。
输入
第一行为序列长度N。
然后是N个数，每一个数的范围都是在[-10^52,10^52]。 注意，这N个数之间可能有若干个空行隔开。
注意，输入数据可能有一些冗余表达信息，具体来说：
1） 正数和0前面可能有前导 0和 '+' 符号，例如
+000123=123
+0000=0
-0000=0
2）每个数字中不含有空格和其他非数字字符，例如不会出现"100 0"或者"- 100"。
3）每个数字前面至多有一个符号，即不会出现+(-1)、-(+4)和-(-1)等情况。
输出
输出只有 1 行：
该序列的众数或者”no”。
如果有多个数出现的次数都达到最多，则取最先出现的数为众数，并且输出形式应该最简形式。
例如，如果原序列众数为+000123，则输出123；如果原序列众数为+0000或者-0000或者0000,输出0。
负数正常输出，例如：如果原序列众数为-000000001111，就输出-1111。
样例输入
6
-00001
10000
00011111111111111111111111111111111111
-01
+000000011111111111111111111111111111111111
-00000000000001
样例输出
-1
import java.math.BigInteger;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n=sc.nextInt();
Map<BigInteger,Integer> map1=new LinkedHashMap<BigInteger,Integer>();
for(int i=0;i<n;i++){
BigInteger b1=sc.nextBigInteger();
Integer v1=map1.get(b1);
if(v1==null){
map1.put(b1,1);
}
else{
map1.put(b1,v1+1);
}
}
if(map1.size()==1){
System.out.println("no");
return;
}
int max=-1;
BigInteger b2=null;
for(BigInteger b3:map1.keySet()){
int t1=map1.get(b3);
if(t1>max){
max=t1;
b2=b3;
}
}
System.out.println(b2);
}
}
扫一扫
6578
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
