配置文件恢复

先用map<Key, Value>存储完整命令→输出的关系，首先判断输入的字符串序列的字符串个数，①若为1，看“reset”是否该改字符串开头，是则输出map.get("reset")，不是则返回unkonw
②若为2，遍历每一个key，看输入key的第1~2个字符串是否分别以第1~2个输入的字符串开头，是则记录找到结果+1，遍历结束的结果为1则输出值，否则unkonw，
③若为3，没有符合条件的，不需要遍历key了，直接输出unkonw即可。
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Map<String, String> map = new HashMap<>();
        map.put("reset", "reset what");
        map.put("reset board", "board fault");
        map.put("board add", "where to add");
        map.put("board delete", "no board at all");
        map.put("reboot backplane", "impossible");
        map.put("backplane abort", "install first");
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String[] strs = in.nextLine().split(" ");
            if (strs.length == 1){
                if ("reset".startsWith(strs[0])){
                    System.out.println("reset what");
                }else System.out.println("unknown command");
            }else if (strs.length == 2){
                int count = 0;
                String res = " ";
                for (String key : map.keySet()){
                    String[] keys = key.split(" ");
                    if (keys.length == 1){
                        continue;
                    }else{
                        if (keys[0].startsWith(strs[0]) && keys[1].startsWith(strs[1])){
                            count++;
                            res = map.get(key);
                        }
                    }
                }
                if (count != 1){
                    System.out.println("unknown command");
                }else{
                    System.out.println(res);
                }
            }else System.out.println("unknown command");
        }
    }

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static String RESET = "reset";
    public static String UNKNOWN_COMMAND = "unknown command";
    public static Map map = new HashMap<String, String>() {
        {
            put("reset", "reset what");
            put("reset board", "board fault");
            put("board add", "where to add");
            put("board delete", "no board at all");
            put("reboot backplane", "impossible");
            put("backplane abort", "install first");
        }
    };
    public static List<String> list = new
    ArrayList<String>() {//命令列表，存储除了reset的其他两个字符串的命令
        {
            add("reset board");
            add("board add");
            add("board delete");
            add("reboot backplane");
            add("backplane abort");
        }
    };
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String a = in.nextLine();
            String[] arr = a.split(" ");
            if (arr.length > 2 ||
                    arr.length <= 0) {//长度不正确，不是正确的指令
                System.out.println(UNKNOWN_COMMAND);
                continue;
            } else if (arr.length == 1) {//长度为1时，与rest去匹配
                if (check(arr[0], RESET)) {
                    System.out.println(map.get(RESET));
                } else {
                    System.out.println(UNKNOWN_COMMAND);
                }
                continue;
            } else {//其他命令按照两个的匹配
                boolean flag = false;
                String command = null;
                for (int i = 0; i < list.size(); i++) {//按照命令列表去匹配
                    String[] commands = list.get(i).split(" ");
                    if (check(arr[0], commands[0]) &&
                            check(arr[1], commands[1])) {//检查两个命令都匹配
                        if (flag) { //如果之前已经有匹配的命令，且再次匹配了一次，说明重复匹配，命令有问题
                            flag = false;
                            break;
                        }
                        flag = true; //如果两个字符串的命令都匹配成功，设置flag，让后续可以以此来做判断
                        command = list.get(i); //记录此时的命令
                    }
                }
                if (flag) { //如果只有一个命令匹配，则输出这个命令
                    System.out.println(map.get(command));
                } else {//如果没有命令匹配或者匹配了多个命令，则输出未知命令
                    System.out.println(UNKNOWN_COMMAND);
                }
            }
        }
    }
    //检查命令是否符合要求
    public static boolean check(String input, String command) {
        if (input.length() >
                command.length()) {//如果是输入的命令长度超过配置的命令，则返回false
            return false;
        } else if (input.length() == command.length()) {//命令长度相同的情况
            if (input.equals(
                        command)) {//命令完全一致，则命令为正确的，否则为错误的
                return true;
            } else {
                return false;
            }
        }
        //一个个字符进行对比，按照输入的命令的长度进行比较，如果比较出不一样的则返回错误，如果比较完都是一致的，说明这个输入的命令符合要求，返回true
        for (int i = 0 ; i < input.length(); i++) {
            if (input.charAt(i) != command.charAt(i)) {
                return false;
            }
        }
        return true;
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String cmd = in.nextLine();
            String[] outputs = {"reset what", "board fault", "where to add",
                                "no board at all", "impossible", "install first"};
            int ret = match(cmd);
            if (ret == -1) {
                System.out.println("unknown command");
            } else {
                System.out.println(outputs[ret]);
            }
        }
    }

    public static int match(String cmd) {
        String[] correct = {"reset", "reset board", "board add", "board delete",
                            "reboot backplane", "backplane abort"};
        String[] mat = cmd.split(" ");
        int count = 0, index = -1;  // 存储匹配到的数量和索引
        for (int i = 0; i < correct.length; i++) {
            String[] reg = correct[i].split(" ");
            boolean flag = true;  // 初始化
            if (reg.length != mat.length) {
                flag = false;
                continue;
            }
            for (int j = 0; j < reg.length; j++) {
                if (mat[j].length() > reg[j].length()) {
                    flag = false;
                    break;
                }
                if (!reg[j].substring(0, mat[j].length()).equals(mat[j])) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                count++;
                if (count == 1) {
                    index = i;
                } else {
                    index = -1;
                }
            }
        }
        return index;
    }
}

//贴个自己写的，应该算是比较好理解的了


import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] cmds1 = new String[]{"reset","reset","board","board","reboot","backplane"};
        String[] cmds2 = new String[]{" ","board","add","delete","backplane","abort"};
        String[] operations = new String[]{"reset what","board fault",
        "where to add","no board at all","impossible","install first"};
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String[] str = in.nextLine().split(" ");
            
            String cmd1 = str[0],cmd2 = str.length==1?" ":str[1];
            
            int count = 0,res_idx = -1;
            for(int idx = 0;idx<6;idx++){
                if(cmds1[idx].startsWith(cmd1)&&cmds2[idx].startsWith(cmd2)){
                    count++;
                    if(count>1){
                        System.out.println("unknown command");
                        break;
                    }
                    res_idx = idx;
                }
            }
            if(count==0)  System.out.println("unknown command");
            if(count==1)  System.out.println(operations[res_idx]);
        }
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Map<String, String> map = new HashMap();
        map.put("reset", "reset what");
        map.put("reset board", "board fault");
        map.put("board add", "where to add");
        map.put("board delete", "no board at all");
        map.put("reboot backplane", "impossible");
        map.put("backplane abort", "install first");
        String err = "unknown command";
        while(in.hasNextLine()){
            String [] cmd = in.nextLine().split(" ");
            String result = "";
            for(Map.Entry<String, String> entry : map.entrySet()){
                String [] m = entry.getKey().split(" ");
                boolean flag = false;
                if(m.length == cmd.length){
                   if(cmd.length == 1){
                        flag = m[0].startsWith(cmd[0]);
                   }else if(cmd.length == 2){
                        flag = m[0].startsWith(cmd[0]) && m[1].startsWith(cmd[1]);
                   }
                }
                //匹配多个
                if(flag && result != ""){
                    result = err;
                    break;
                }else if(flag){
                    result = entry.getValue();
                }
            }
            System.out.println(result == "" ? err : result);
        }
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[][] ins = new String[][] {{"reset", " ", "reset what"}, {"reset", "board", "board fault"}, {"board", "add", "where to add"}, {"board", "delete", "no board at all"}, {"reboot", "backplane", "impossible"}, {"backplane", "abort", "install first"}};
        while(in.hasNextLine()){
            handleInput(in.nextLine(),ins);
        }
    }

    private static void handleInput(String input,String[][] ins){
        String[] info=input.split(" ");
        if(info.length==1){
            if(matched(info[0],ins[0][0])){
                System.out.println(ins[0][2]);
                return;
            }
        }else if(info.length==2){
            int index=0;
            for(int i=1;i<ins.length;i++){
                if(matched(info[0],ins[i][0])){
                    if(matched(info[1],ins[i][1])){
                        if(index==0){
                            index=i;
                        }else{
                            index=0;
                            break;
                        }
                    }
                }
            }
            if(index>0){
                System.out.println(ins[index][2]);
                return;
            }
            
        }
        System.out.println("unknown command");
    }

    private static boolean matched(String input,String target){
        if(input.length()<=target.length()){
            if(target.substring(0,input.length()).equals(input)){
                return true;
            }
        }
        return false;
    }
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Map<String,String> map=new HashMap<>();
        map.put("reset","reset what");map.put("reset board","board fault");
        map.put("board add","where to add");map.put("board delete","no board at all");
        map.put("reboot backplane","impossible");map.put("backplane abort","install first");
        Set<String[]> set=new HashSet<>();
        for(String s:map.keySet()){
            set.add(s.split(" "));
        }
        while(sc.hasNextLine()){
            String[] strs=sc.nextLine().split(" ");
            String ss=null;
            int time=0;
            for(String[] s:set){
                if(strs.length==1){
                    if(s.length!=1) continue;
                    else{
                        if(s[0].startsWith(strs[0])){
                            ss=s[0];
                            time++; 
                        }
                        continue;
                    }
                }
                if(strs.length==2){
                    if(s.length!=2) continue;
                    else{
                        if(s[0].startsWith(strs[0])&&s[1].startsWith(strs[1])){
                            ss=s[0]+" "+s[1];
                            time++;
                        }
                        continue;
                    }
                }
            }
            System.out.println(time!=1?"unknown command":map.get(ss));
        }
    }
}

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        Map<String,String> map = new HashMap<>();
        map.put("reset","reset what");
        map.put("reset board","board fault");
        map.put("board add","where to add");
        map.put("board delete","no board at all");
        map.put("reboot backplane","impossible");
        map.put("backplane abort","install first");
        Set<String> set = map.keySet();

        while (in.hasNextLine()) {
            String[] input = in.nextLine().split(" ");
            String command = "";

            //遍历命令
            for(String s : set){
                String[] com = s.split(" ");

                if(com.length == 1){
                    if(input.length==1&& com[0].startsWith(input[0])){
                        command =com[0];
                        break;
                    }
                }else{
                    if(input.length==2 && com[0].startsWith(input[0])&& com[1].startsWith(input[1])){
                        //使用+=避免多次匹配
                        command += s;
                    }
                }
            }

            String result = map.get(command);
            if(result==null){
                System.out.println("unknown command");
            }else{
                System.out.println(result);
            }
        }
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String key[] = new String[] {"reset", "reset board", "board add",
                                     "board delete", "reboot backplane", "backplane abort"
                                    };
        String value[] = new String[] {"reset what", "board fault", "where to add",
                                       "no board at all", "impossible", "install first"
                                      };
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String s = in.nextLine();
            String command[] = s.split(" ");
            int len = command.length;
            if (len ==
                    1) { //若只输入一字串，则只匹配一个关键字的命令行
                if ("reset".startsWith(command[0])) {
                    System.out.println("reset what");
                } else {
                    System.out.println("unknown command");
                }
            } else {
                int matchNum = 0;
                String matchValue = "";
                for (int i = 0; i < 6; i++) {
                    if (key[i].startsWith(command[0])) {
                        if (key[i].contains(" ")) {
                            String keys[] = key[i].split(" ");
                            if (keys[1].startsWith(command[1])) {
                                matchNum++;
                                matchValue = value[i];
                            }
                        }
                    }
                }
                if (matchNum == 1) {
                    System.out.println(matchValue);
                } else {
                    System.out.println("unknown command");
                }

            }
        }
    }
}

import java.util.*;

public class Main {
    static String[] coms = {"reset","reset board","board add","board delete","reboot backplane",
                            "backplane abort"};
    static String[] ress = {"reset what","board fault","where to add","no board at all",
                            "impossible","install first"};
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while(in.hasNextLine()){
            List<String> list = new ArrayList<>();
            //输入的命令
            String[] com = in.nextLine().split(" ");
            
            for(int i = 0;i < coms.length;i++){
                String[] temp = coms[i].split(" ");
                if(com.length == 1){
                    if(temp.length == 2){
                        continue;
                    }
                    if(temp[0].startsWith(com[0])){
                        list.add(ress[i]);
                        break;
                    }
                }
                
                if(com.length == 2){
                    if(temp.length == 1){
                        continue;
                    }else if(temp[0].startsWith(com[0]) && temp[1].startsWith(com[1])){
                        list.add(ress[i]);
                    }
                }
            }
            
            if(list.size() > 1 || list.size() == 0){
                System.out.println("unknown command");
            }else{
                System.out.println(list.get(0));
            }
            
        }
    }
}