「奖牌排行」
题目描述
2012伦敦奥运会即将到来,大家都非常关注奖牌榜的情况,现在我们假设奖牌榜的排名规则如下:
1、首先gold medal数量多的排在前面;
2、其次silver medal数量多的排在前面;
3、然后bronze medal数量多的排在前面;
4、若以上三个条件仍无法区分名次,则以国家名称的字典序排定。
我们假设国家名称不超过20个字符、各种奖牌数不超过100,且大于等于0。
输入
第一行输入一个整数N(0<N<21),代表国家数量;
然后接下来的N行,每行包含一个字符串Namei表示每个国家的名称,和三个整数Gi、Si、Bi表示每个获得的gold medal、silver medal、bronze medal的数量,以空格隔开,如(China 51 20 21),具体见样例输入。
输出
输出奖牌榜的依次顺序,只输出国家名称,各占一行,具体见样例输出。
输入样例
5
China 32 28 34
England 12 34 22
France 23 33 2
Japan 12 34 25
Rusia 23 43 0
输出样例
China
Rusia
France
Japan
England
代码案例解析
Scanner已注释,用固定的初始化用来测试,提交网页测试代码时候用Scanner录入方法。
其中包含了多种排序方法,注释的内容可自行替换,只是排序方式的不同写法,思路一样。
import java.util.*;
import java.util.Scanner;
public class 奖牌排行 {
public static void main(String[] args) {
/**
* 5
* China 32 28 34
* England 12 34 22
* France 23 33 2
* Japan 12 34 25
* Rusia 23 43 0
*/
// Scanner s = new Scanner(System.in);
// int size = Integer.parseInt(s.nextLine());
//
// List<Country> list = new ArrayList();
// for (int i=0;i<size;i++){
// list.add(new Country(s.nextLine().split(" ")));
// }
int size = 5;
List<Country> list = new ArrayList();
list.add(new Country("China 32 28 34".split(" ")));
list.add(new Country("England 12 34 22".split(" ")));
list.add(new Country("France 23 33 2".split(" ")));
list.add(new Country("Japan 12 34 25".split(" ")));
list.add(new Country("Rusia 23 43 0".split(" ")));
/**
* stream的排序
*/
// list.stream().sorted(new Comparator<Country>() {
// @Override
// public int compare(Country o1, Country o2) {
// int ret = o2.getGold()-o1.getGold();
// if (ret==0){
// ret = o2.getSilver()-o1.getSilver();
// if (ret == 0){
// ret = o2.getBronze()-o1.getBronze();
// if (ret == 0){
// return o1.getName().compareTo(o2.getName());
// }
// }
// }
// return ret;
// }
// }).forEach(country -> System.out.println(country.getName()));
/**
* stream的排序,lambda表达式
*/
// list.stream().sorted((o1,o2) -> {
// if (o2.getGold()-o1.getGold()!=0){
// return o2.getGold()-o1.getGold();
// }
// if (o2.getSilver()-o1.getSilver()!=0){
// return o2.getSilver()-o1.getSilver();
// }
// if (o2.getBronze()-o1.getBronze()!=0){
// return o2.getBronze()-o1.getBronze();
// }
// return o1.getName().compareTo(o2.getName());
// }).map(Country::getName).forEach(System.out::println);
/**
* stream的Comparator排序器
*/
list.stream().sorted(Comparator.comparing(Country::getGold)
.thenComparing(Country::getSilver)
.thenComparing(Country::getBronze).reversed()
.thenComparing(Country::getName))
.forEach(country -> System.out.println(country.getName()));
/**
* list.sort排序,改变原list
*/
// list.sort(new Comparator<Country>() {
// @Override
// public int compare(Country o1, Country o2) {
// if (o2.getGold()-o1.getGold()!=0){
// return o2.getGold()-o1.getGold();
// }
// if (o2.getSilver()-o1.getSilver()!=0){
// return o2.getSilver()-o1.getSilver();
// }
// if (o2.getBronze()-o1.getBronze()!=0){
// return o2.getBronze()-o1.getBronze();
// }
// return o1.getName().compareTo(o2.getName());
// }
// });
// list.forEach(System.out::println);
/**
* list.sort排序lambda表达式,改变原list
*/
list.sort((o1,o2) -> {
// ------比较规则
return 0;
});
list.forEach(System.out::println);
}
}
class Country{
private String name;
private int gold;
private int silver;
private int bronze;
public Country(String[] args) {
this.name = args[0];
this.gold = Integer.parseInt(args[1]);
this.silver = Integer.parseInt(args[2]);
this.bronze = Integer.parseInt(args[3]);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getGold() {
return gold;
}
public void setGold(int gold) {
this.gold = gold;
}
public int getSilver() {
return silver;
}
public void setSilver(int silver) {
this.silver = silver;
}
public int getBronze() {
return bronze;
}
public void setBronze(int bronze) {
this.bronze = bronze;
}
@Override
public String toString() {
return "Country{" +
"name='" + name + '\'' +
", gold=" + gold +
", silver=" + silver +
", bronze=" + bronze +
'}';
}
}
「形成目标字符串的最短路径A」
题目描述
形成目标字符串的最短路径方案A(双循环,找头再继续)
对于任何字符串,我们可以通过删除其中一些字符(也可能不删除)来构造该字符串的子序列。
给定源字符串 source 和目标字符串 target,找出源字符串中能通过串联形成目标字符串的子序列的最小数量。如果无法通过串联源字符串中的子序列来构造目标字符串,则返回 -1。
示例 1:
输入:source = “abc”, target = “abcbc”
输出:2
解释:目标字符串 “abcbc” 可以由 “abc” 和 “bc” 形成,它们都是源字符串 “abc” 的子序列。
示例 2:
输入:source = “abc”, target = “acdbc”
输出:-1
解释:由于目标字符串中包含字符 “d”,所以无法由源字符串的子序列构建目标字符串。
示例 3:
输入:source = “xyz”, target = “xzyxz”
输出:3
解释:目标字符串可以按如下方式构建: “xz” + “y” + “xz”。
代码案例解析
import java.util.Scanner;
public class 形成目标字符串的最短路径A {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextLine()){
String sourceStr = in.nextLine();
String targetStr = in.nextLine();
String[] source = sourceStr.split("");
String[] target = targetStr.split("");
int i = 0; // 记录已匹配的字符索引
int start = 0; // 记录source匹配开始位置
int count = 0; // 共进行了多少轮(多少个字符串)
StringBuffer sb = new StringBuffer();
while(i<target.length){ // 从第target一位开始匹配
String s = target[i];
while (!source[start].equals(s)){ //找到source中开始匹配的位置
start++;
if (start>=(source.length-1)){
System.out.println(-1);
return;
}
}
sb.append(source[start]); // 本轮拼接第一位匹配字符
i++;
while (i<target.length && (start+1)<source.length){ // 从第二位开始遍历source匹配下一位
if (source[start+1].equals(target[i])){
sb.append(source[start+1]); // 本轮拼接下一位
i++;
}
start++;
}
System.out.print("\""+sb.toString()+"\""); // 打印本轮字符串
sb.delete(0,sb.length()); // 充值暂存的本轮字符串
count++; // 本轮匹配结束,得出一个字符串,count+1
start = 0; // 重置source下一次的匹配起点
}
System.out.println("需"+count+"个字符串");
}
}
}
「形成目标字符串的最短路径B」
代码案例解析
import java.util.Scanner;
public class 形成目标字符串的最短路径B {
/**
* 形成目标字符串的最短路径方案B(单个循环)
* 具体看A
* @param args
*/
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextLine()){
String sourceStr = in.nextLine();
String targetStr = in.nextLine();
String[] source = sourceStr.split("");
String[] target = targetStr.split("");
int i = 0; // 记录要匹配的字符索引
int start = 0; // 记录source匹配的位置
int count = 0; // 共进行了多少轮(多少个字符串)
StringBuffer sb = new StringBuffer(); // 基本本轮串联匹配的字符串结果
while(i<target.length){ // 从第target一位开始匹配
while (i<target.length && start<source.length){ // 遍历source匹配下一位
if (source[start].equals(target[i])){
sb.append(source[start]); // 拼接本轮已匹配的字符串
i++; // target位移下一位
}
start++; // source位移下一位
}
if (sb.length()==0){
System.out.println(-1);
return;
}
System.out.print("\""+sb.toString()+"\""); // 打印本轮字符串
sb.delete(0,sb.length()); // 充值暂存的本轮字符串
count++; // 本轮匹配结束,得出一个字符串,count+1
start = 0; // 重置source下一次的匹配起点
}
System.out.println("需"+count+"个字符串");
}
}
}
「形成目标字符串的最短路径C」
代码案例解析
import java.util.Scanner;
public class 形成目标字符串的最短路径C {
/**
* 形成目标字符串的最短路径方案C(for循环解决)
* 具体看A
* @param args
*/
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextLine()){
String sourceStr = in.nextLine();
String targetStr = in.nextLine();
String[] source = sourceStr.split("");
String[] target = targetStr.split("");
int count = 0; // 共进行了多少轮(多少个字符串)
StringBuffer sb = new StringBuffer(); // 基本本轮串联匹配的字符串结果
for (int i=0;i<target.length; ){
for (int j=0;j<source.length && i<target.length;j++){
if (source[j].equals(target[i])){
sb.append(source[j]);
i++;
}
}
if (sb.length()==0){
System.out.println(-1);
return;
}
System.out.print("\""+sb.toString()+"\"");
sb.delete(0,sb.length());
count++;
}
System.out.println("需"+count+"个字符串");
}
}
}
「形成目标字符串的最短路径D」
代码案例解析
import java.util.Scanner;
public class 形成目标字符串的最短路径D {
/**
* 形成目标字符串的最短路径方案D(for循环解决,不打印每个字符串)
* 具体看A
* @param args
*/
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextLine()){
String sourceStr = in.nextLine();
String targetStr = in.nextLine();
String[] source = sourceStr.split("");
String[] target = targetStr.split("");
int count = 0; // 共进行了多少轮(多少个字符串)
for (int i=0;i<target.length; ){
int startNum = i; // 记录初始下标
for (int j=0;j<source.length && i<target.length;j++){
if (source[j].equals(target[i])){
i++;
}
}
if (startNum == i){ //未匹配到相同字符则失败
System.out.println(-1);
return;
}
count++;
}
System.out.println("需"+count+"个字符串");
}
}
}
「打印Mysql结果样式矩阵」
题目描述
上图是一个Mysql查询结果图,我们看到这个表格非常漂亮,只需要使用”+”和”-”两个符号就可以打印,现在你的任务是打印一个n×m的表格我们定义单位长度(水平方向有三个”-”,竖直方向有一个”| ”,”|”对齐”+”)的矩形表格为
输入
输入只有一行包含两个整数n和m(0<n,m<13)。
输出
输出n×m的表格。
样例
输入样例 1
1 1
输出样例 1
±–+
| |
±–+
代码案例解析
import java.util.Scanner;
public class 打印Mysql结果样式矩阵 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int row = in.nextInt();
int clo = in.nextInt();
// 打印第一行
// +---+---+
StringBuffer topLine = new StringBuffer();
for (int i = 0; i < clo; i++) {
topLine.append("+---");
}
System.out.println(topLine.append("+"));
// 后面每行拼接如下U型
// | | |
// +---+---+
for (int i = 0; i < row; i++) {
StringBuffer midLine = new StringBuffer();
StringBuffer lowLine = new StringBuffer();
for (int j = 0; j < clo; j++) {
midLine.append("| ");
lowLine.append("+---");
}
System.out.println(midLine.append("|"));
System.out.println(lowLine.append("+"));
}
}
}