Algorithm Practice Record【4】

风再起时_k

已于 2023-10-20 15:48:04 修改

阅读量41

点赞数

文章标签： java

于 2023-10-20 15:16:39 首次发布

本文链接：https://blog.csdn.net/weixin_44669698/article/details/133947216

版权

「奖牌排行」

题目描述
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("+"));
        }
    }
}