目录
1:字符串排序
总时间限制: 10000ms 单个测试点时间限制: 1000ms 内存限制: 65536kB
描述
给定N个字符串，将这N个字符串按照长度从小到大排序，对于长度相同的字符串按照字典序从大到小排序。
输入
第一行一个整数N（不超过100）
接下来N行每行一个长度不超过50的字符串，仅包含小写字母
输出
N行，表示排序后的字符串
样例输入
3
zzz
ab
ba
样例输出
ba
ab
zzz
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.nextLine();
List<String> list1 = new ArrayList<>();
for (int i = 0; i < n; i++) {
String s = sc.nextLine();
list1.add(s);
}
Collections.sort(list1, new Comparator1());
for (String ss : list1) {
System.out.println(ss);
}
}
}
class Comparator1 implements Comparator<String> {
public int compare(String a, String b) {
if (a.length() == b.length()) {
return b.compareTo(a);
}
return a.length() - b.length();
}
}2:翻转后排序
总时间限制: 5000ms 单个测试点时间限制: 1000ms 内存限制: 65535kB
描述
给定整数n，请将1到n的所有整数重新排序，使得翻转后越大的数排名越靠前。这里翻转指将一个数的十进制表示翻转，例如123翻转后是321；100翻转后是1。如果两个数翻转后大小相同，则翻转前越小的数排名越靠前。
输入
一个整数n（n<=1000）
输出
一行n个整数表示排序后的结果
样例输入
11
样例输出
11 9 8 7 6 5 4 3 2 1 10
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
for (int i = 1; i <= n; i++) {
String s = i + "";
StringBuffer ss = new StringBuffer(s);
String reverse_s = ss.reverse().toString();
// int r_s = Integer.parseInt(reverse_s);
map.put(i, Integer.parseInt(reverse_s));
}
List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer, Integer>>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
@Override
public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
if (o1.getValue() == o2.getValue()) {
return o1.getKey() - o2.getKey();
}
return o2.getValue() - o1.getValue();
}
});
for (Map.Entry<Integer, Integer> num : list) {
// System.out.println("key:" + entry.getKey() + ";value:" + entry.getValue());
System.out.print(num.getKey() + " ");
}
}
}3:括号匹配2
总时间限制: 5000ms 单个测试点时间限制: 500ms 内存限制: 262144kB
描述
给出一个由小括号、中括号、大括号组成的括号字符串，判断它是否合法。
输入
第一行包含1个正整数 T，表示测试数据组数。
接下去 T 行，每行一个仅由小括号、中括号、大括号组成的字符串。
对于 100% 的数据，1<=T<=10，1<=每行的字符串长度<=10000；
输出
一共 T 行，每行一个答案，如果为合法括号串，则输出yes；否则输出no；
样例输入
4
([]){}
)([]
{({})()[{}[[]]]}
[]{)}((()
样例输出
yes
no
yes
no
import java.util.Scanner;
import java.util.Stack;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.nextLine();
for (int i = 0; i < n; i++) {
String s = sc.nextLine();
if (isGoodBracket(s)) System.out.println("yes");
else System.out.println("no");
}
}
public static boolean isGoodBracket(String s) {
Stack<Character> stack = new Stack<Character>();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == '(') stack.push(')');
if (c == '[') stack.push(']');
if (c == '{') stack.push('}');
if (c == ')' || c == ']' || c == '}') {
if (stack.empty()) {
return false;
}
if (stack.pop() != c) {
return false;
}
}
}
if (!stack.empty()) {
return false;
}
return true;
}
}4:求课程交集
总时间限制: 65535ms 内存限制: 65535kB
描述
输入多个同学所选的课程，求这些同学所选课程的交集。
输入
首先输入一个数n，表示一共有几位同学，接着输入n行，每行表示该名同学所选的课程编号，每个课程编号之间有空格间隔。
输出
输出n位同学都选了的课程编号，即所选课程的交集，若有多个课程，则每行输出一个，输出顺序由课程编号从小到大，若无交集，则输出None
样例输入
3
122 221 110
110 222 334
110 222 234
样例输出
110
方法一：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.nextLine();
List<String> list1=new ArrayList<>();
for (String s : sc.nextLine().split(" ")) {
list1.add(s);
}
for (int i = 0; i < n-1; i++) {
List<String> list2=new ArrayList<>();
for (String s : sc.nextLine().split(" ")) {
list2.add(s);
}
list1.retainAll(list2);
if(list1.size()==0){
System.out.println("None");
return;
}
}
Collections.sort(list1);
for (String s : list1) {
System.out.println(s);
}
}
}方法二：
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class Main {
public static void main(String[] args) {
Scanner p = new Scanner(System.in);
Map<String, Integer> k = new TreeMap<String, Integer>();
int n = p.nextInt();
p.nextLine();
for (int i = 0; i < n; i++) {
String m = p.nextLine();
String[] s1 = m.split(" ");
for (String str : s1) {
if (k.get(str) == null)
k.put(str, 1);
else
k.put(str, k.get(str) + 1);
}
}
Boolean flag = true;
for (String str : k.keySet()) {
if (k.get(str) == n) {
System.out.println(str);
flag = false;
}
}
if (flag)
System.out.println("None");
}
}5:扑克牌排序
总时间限制: 1000ms 内存限制: 262144kB
描述
桥牌是一项两人对两人的四人扑克游戏。游戏过程分为叫牌和打牌，需要精确计算牌力，并和队友默契配合，是一项普及面很广的、有趣、益智的游戏。
这里我们不讨论复杂的叫牌体系和打牌规则，只讨论拿到一手牌后的排序过程（俗称理牌）。下图就是一副已经理好的牌。
理牌规则如下：
1. 同花色放在一起，花色之间按照 黑桃S、红心H、草花C、方片D 的顺序排放（为了使颜色交替，容易区分，本题理牌顺序如图为 黑桃 > 红心 > 草花 > 方片，与桥牌叫牌的顺序不同）；
2. 同花色中，按从大到小的顺序排放，即 A > K > Q > J > 10 > 9 > 8 > 7 > 6 > 5 > 4 > 3 > 2（即A最大，2最小）；
现在给你一手牌，请按照上述理牌规则将其排序。
输入
输入一行，表示一手牌（保证为 13 张牌），每张牌用花色+大小表示。
花色为：S (表示Spade黑桃)、H (表示Heart红心)、C (表示Club草花)、D (表示Diamond方片)；
大小为：A > K > Q > J > 10 > 9 > 8 > 7 > 6 > 5 > 4 > 3 > 2；
一张牌的花色和大小之间无空格，所有字母均大写，保证没有重复的牌。牌与牌之间有 1 个空格。行首行尾均无多余空格。
输出
输出一行，即排好序的这手牌。输出格式与输入一致。
样例输入
#样例输入1
H2 S3 C3 D5 H6 C9 H9 C10 HJ SQ DQ SK CA
#样例输入2
CA CK CQ CJ C10 C9 S2 S3 S4 S5 S6 S7 S8
#样例输入3
SA HA CA DA SK HK CK DK SQ HQ DQ CQ SJ
样例输出
#样例输出1
SK SQ S3 HJ H9 H6 H2 CA C10 C9 C3 DQ D5
#样例输出2
S8 S7 S6 S5 S4 S3 S2 CA CK CQ CJ C10 C9
#样例输出3
SA SK SQ SJ HA HK HQ CA CK CQ DA DK DQ
方法一：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
LinkedList<String> list1 = new LinkedList<>();
for (int i = 0; i < 13; i++) {
list1.add(sc.next());
}
Collections.sort(list1, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
String[] t1={"S","H","C","D","A","K","Q","J","10","9","8","7","6","5","4","3","2"};
String[] t2={"d","c","b","a","z","y","x","w","v","u","t","s","r","q","p","o","n"};
for (int i = 0; i < t1.length; i++)
{
o1=o1.replace(t1[i],t2[i]);
o2=o2.replace(t1[i],t2[i]);
}
return o2.compareTo(o1);
}
});
for (String s : list1) {
System.out.print(s+" ");
}
}
}方法二：
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] arg) {
Scanner sc = new Scanner(System.in);
String[] s1 = { "S", "H", "C", "D" };
String[] s2 = { "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3", "2" };
ArrayList<String> s = new ArrayList<String>();
for (int i = 0; i < 13; i++)
s.add(sc.next());
for (int i = 0; i < 4; i++) {
for (int j = 0; j < s2.length; j++) {
if (s.contains(s1[i] + s2[j])) {
System.out.print(s1[i] + s2[j] + " ");
}
}
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
