配置文件恢复

import java.util.*;

public class Main {
	
	public static boolean isMatch(String src, String des){
		char[] c1 = src.toCharArray();
		char[] c2 = des.toCharArray();
		int i = 0;
		while(i < c1.length && i < c2.length){
			if(c1[i] == c2[i])
				i++;
			else
				break;
		}
		if(i == c1.length)
			return true;
		else 
			return false;
	}
	
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        HashMap<String, String> hMap = new HashMap<>();
        hMap.put("reset", "reset what");
        hMap.put("reset board", "board fault");
        hMap.put("board add", "where to add");
        hMap.put("board delet", "no board at all");
        hMap.put("reboot backplane", "impossible");
        hMap.put("backplane abort", "install first");
        while (scanner.hasNext()) {
        	String[] strs = scanner.nextLine().split(" ");
        	int count = 0; // 记录匹配个数
        	Set<String> set = hMap.keySet();
        	String key = "";
        	for(String s : set){
        		String[] temps = s.split(" ");
        		if(temps.length == strs.length){
        			int i = 0;
        			while(i < temps.length){
        				if(isMatch(strs[i], temps[i]))
        					i++;
        				else
        					break;
        			}
        			if(i == temps.length){ // 找到匹配
        				key = s;
        				count++;
        			}       				
        		}
        	}
        	if(count != 1)
        		System.out.println("unkown command");
        	else
        		System.out.println(hMap.get(key));
        		
        }
        scanner.close();
    }
}

import java.util.*;
public class Main{
    public static void main(String[]args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String s=sc.nextLine();
            recover(s);
        }
    }
    public static void recover(String s){
        String[]strings={"reset","reset board","board add","board delete","reboot backplane","backplane abort","he he"};
        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");
        map.put("he he","unknown command");
        String[]str=s.split(" ");
        if (str.length==1){
            String ss=strings[0].substring(0,str[0].length());
            if (ss.equals(str[0])){
                System.out.println("reset what");
            }else {
                System.out.println("unknown command");
            }
        }else {
            int count=0;
            String flag="";
            for (int i=1;i<strings.length;i++){
                String st=strings[i];
                String[]st1=st.split(" ");
                if (st1.length==2){
                    if (st1[0].length()<str[0].length() || st1[1].length()<str[1].length()){
                        continue;
                    }
                    String s1=st1[0].substring(0,str[0].length());
                    String s2=st1[1].substring(0,str[1].length());
                    if (s1.equals(str[0]) && s2.equals(str[1])){
                        count++;
                        flag=st;
                    }
                }
            }
            if (count==1){
                System.out.println(map.get(flag));
            }else {
                System.out.println("unknown command");
            }
        }
    }

}

import re
cmd = ('reset', 'reset board', 'board add', 'board delete', 'reboot backplane', 'backplane abort')
res = ('reset what', 'board fault', 'where to add', 'no board at all', 'impossible', 'install first', 'unknown command')
while True:
    try:
        s = input().strip().split()
        match1_cmd = [] # 第一个关键字 匹配到的
        for j, v in enumerate(cmd):
            if re.match(s[0], v):   # 匹配以该关键字开头的
                if len(s) == 1 and len(v.split()) == 1:
                    match1_cmd.append((cmd[j], res[j]))
                elif len(s) == 2 and len(v.split()) ==2:
                    match1_cmd.append((cmd[j], res[j]))
        if len(s) == 1:
            if len(match1_cmd) == 1:
                print(match1_cmd[0][1])
            else:
                print(res[-1])
        else:
            match2_cmd = [] # 如果关键字 长度为2 继续匹配后一个管关键字
            for i in match1_cmd:
                if re.match(s[1], i[0].split()[1]):
                    match2_cmd.append(i)
            if len(match2_cmd) == 1:
                print(match2_cmd[0][1])
            else:
                print(res[-1])
    except:
        break
        

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
vector<pair<pair<string, string>, string>> helper{
	{{"reset",""},"reset what"},{ {"reset","board"},"board fault" },{ {"board","add"},"where to add" },
	{ {"board","delet"},"no board at all" }, { {"reboot","backplane"},"impossible" },
	{ {"backplane","abort"},"install first" } };
int main() {
	string str;
	while (getline(cin,str)) {
		int _count = count(str.begin(), str.end(), ' ');
		if (_count == 0)
			if (helper[0].first.first.find(str) != string::npos)
				cout << helper[0].second << endl;
			else cout << "unkown command" << endl;
		else if (_count == 1 && str[str.size() - 1] != ' ') {
			int flag = 0;
			string tmp;
			string part1 = str.substr(0, str.find(' '));
			string part2 = str.substr(str.find(' ') + 1);
			for (auto p : helper) {
				if (p.first.first.find(part1) != string::npos &&
					p.first.second.find(part2) != string::npos) {
					++flag;
					if (flag == 2) break;
					tmp = p.second;
				}
			}
			if (flag == 1) cout << tmp << endl;
			else cout<< "unkown command" << endl;
		}
		else cout << "unkown command" << endl;
	}
}

while True:
    try:
        command_keys = [
            "reset",
            "reset board",
            "board add",
            "board delete",
            "reboot backplane",
            "backplane abort",
        ]
        command_values = [
            "reset what",
            "board fault",
            "where to add",
            "no board at all",
            "impossible",
            "install first",
        ]

        cmd = input()
        cmd_split = cmd.split()

        if len(cmd_split) == 1 and cmd == command_keys[0][0 : len(cmd)]:
            print(command_values[0])
        elif len(cmd_split) == 2:
            flag = 0  # 保存第二个匹配次数，若为1，则返回对应命令；若大于1，则返回unknown command
            match_cmd = ""  # 保存匹配到的命令

            # 遍历，如果遇到匹配的，flag + 1
            # 匹配到的条件是第一个字串和第二各字串同时匹配上
            # flag = 1，说明只有一个匹配的
            # flag > 1，说明有多于一个匹配的，根据题设，则匹配失败
            for i in range(1, 6):
                command_keys_split = command_keys[i].split()
                if command_keys_split[0].startswith(
                    cmd_split[0]
                ) and command_keys_split[1].startswith(cmd_split[1]):
                    flag += 1
                    match_cmd = i  # 多个匹配match_cmd被覆盖也没关系，最后也是输出unknown command
            if flag == 1:
                print(command_values[match_cmd])
            else:
                print("unknown command")
        else:
            print("unknown command")

    except:
        break

import sys

commands = {}
commands['reset'] = 'reset what'
commands['reset board'] = 'board fault'
commands['board add'] = 'where to add'
commands['board delete'] = 'no board at all'
commands['reboot backplane'] = 'impossible'
commands['backplane abort'] = 'install first'

def isMatch(myCommand, command):
    if command[:len(myCommand)].find(myCommand) != -1:
        return True
    else:
        return False

for myCommand in sys.stdin:
    myCommand = myCommand.strip()
    space = myCommand.count(' ')
    match = 0 #计量匹配了几次
    output = '' #存储输出
    if myCommand == '':
        output = ''
        match += 1
    elif space == 0 and isMatch(myCommand, 'reset'):
        output = commands['reset']
        match += 1
    elif space == 1:
        myCommand = myCommand.split(' ')
        for command in commands.keys():
            if command.find(' ') != -1:
                command = command.split(' ')
                if isMatch(myCommand[0], command[0]) and isMatch(myCommand[1], command[1]):
                    command = ' '.join(command)
                    output = commands[command]
                    match += 1
    if match == 1:
        print(output)
    else:
        print('unknown command')
        

s={'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','board delete':'no board at all'}
while True:
    try:
        a=input()
        if a in s.keys():
            print(s[a])
        else:
            print('unknown command')
    except:
        break

#include <iostream>
#include <map>
#include <vector>
using namespace std;

int main() 
{
    map<string,string> c***p;
	c***p["reset"] = "reset what";
	c***p["reset board"] = "board fault";
	c***p["board add"] = "where to add";
	c***p["board delete"] = "no board at all";
	c***p["reboot backplane"] = "impossible";
	c***p["backplane abort"] = "install first";

	string scmd;
	while(getline(cin,scmd))
	{
		vector<string> cmd_vec;
		string scmd1;
		string scmd2;
		int ipos = scmd.find(' ');
		if (string::npos == ipos)
		{
			scmd1 = scmd;
			cmd_vec.push_back(scmd1);
		}
		else
		{
			scmd1 = scmd.substr(0,ipos);
			scmd2 = scmd.substr(ipos+1,scmd.size()-ipos-1);
			cmd_vec.push_back(scmd1);
			cmd_vec.push_back(scmd2);
		}

		if (1==cmd_vec.size())
		{			
			vector<string> temp_vec;
			for (map<string,string>::iterator iter = c***p.begin();
				iter != c***p.end(); iter++)
			{
				if (iter->first.find(scmd1) != string::npos)
				{
					temp_vec.push_back(iter->first);
				}
			}

			bool bfind = false;
			for (int i=0;i<temp_vec.size();i++)
			{				
				if (temp_vec[i].find(' ')==string::npos)
				{
					bfind = true;
					cout << c***p[temp_vec[i]] <<endl;
				}
			}

			if (!bfind)
			{
				cout << "unknown command" <<endl;
			}

		}
		else
		{

			vector<string> temp_vec;
			for (map<string,string>::iterator iter = c***p.begin();
				iter != c***p.end(); iter++)
			{
				if (iter->first.find(' ') == string::npos)
				{
					continue;
				}
				int ipos = iter->first.find(' ');
				string scomp1 = iter->first.substr(0,ipos);
				string scomp2 = iter->first.substr(ipos+1,iter->first.size()-ipos-1);

				if (scomp1.find(scmd1) == string::npos)
				{
					continue;
				}
				if (scomp2.find(scmd2) == string::npos)
				{
					continue;
				}

				temp_vec.push_back(iter->first);
			}

			if (1==temp_vec.size())
			{
				cout << c***p[temp_vec[0]] <<endl;
			}
			else
			{
				cout << "unknown command" <<endl;
			}

		}

	}
    
    return 0;

}

#include<iostream>
#include<string>
#include<vector>
#include<sstream>
using namespace std;
int main()
{
    string c;
    string list[6][3]={{"reset"},{"reset","board","board fault"},
                       {"board","add","where to add"},{"board","delete","no board at all"},
                       {"reboot","backplane","impossible"},{"backplane","abort","install first"}};
    while(getline(cin,c))
    {
        if(c.find(' ')==c.npos) 
        {
            if(list[0][0].find(c)!=list[0][0].npos)
            {cout<<"reset what"<<endl;continue;}
            else {cout<<"unknown command"<<endl;continue;}
        }
        else if(c.size())
        {
            int num=0;int k;stringstream ss;string com[2];
            ss<<c;ss>>com[0]>>com[1];
            for(int a=1;a<6;a++)
            {
                if(list[a][0].find(com[0])!=list[a][0].npos&&list[a][1].find(com[1])!=list[a][0].npos)
                {k=a;num+=1;}
            }
            if(num!=1) {cout<<"unknown command"<<endl;}
            else {cout<<list[k][2]<<endl;}
        }
    }
    return 0;
}

#include<stdio.h>
#include<string.h>
#define N 1024
int main()
{   char str[N];
    while(gets(str)){
        
    int n=strlen(str);
    int i;
    int flag;
    flag=0;
    for(i=0;i<n;i++)
    {if (str[i]==' ') flag=1;}
       if(flag==0)  
          {if(str[0]=='r') printf("reset what\n");}         
       if(flag==1) 
       {
           for(i=0;i<n;i++)
    { 
       if(str[i]==' ')
      {
         if(str[0]=='b'&& str[i+1]=='d') {printf("no board at all\n");break;} 
         else if(str[0]=='b'&&str[1]=='o'&&str[i+1]=='a') {printf("where to add\n");break;}
         else if(str[0]=='b'&&str[1]=='a'&&str[i+1]=='a') {printf("install first\n");break;}
         else if(str[0]=='r' && str[i+1]=='b'&&(str[i+2]=='a'||str[2]=='b') ) {printf("impossible\n");break;}
         else if(str[0]=='r' && str[i+1]=='b'&&(str[i+2]=='o'||str[2]=='s') ) {printf("board fault\n");break;}
         else printf("unknown command\n");
      }
      } 
  
       }
  }      
    return 0;
}

dic = {'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 True:
    try:
        com = input().strip()
        # 若输入的命令是完整命令，则直接输出执行结果
        if com in dic:
            print(dic[com])
        else:  # 输入的是命令的简化形式
            simcom_list = com.split(' ')
            if len(simcom_list) == 1:  # 输入的是一字串，只能匹配一个关键字的命令(本题的：reset命令)
                if 'reset'.startswith(simcom_list[0]):
                    print("reset what")
                else:
                    print("unknown command")
            elif len(simcom_list) == 2:  # 输入的是两字串，只能匹配两个关键字的命令
                match = []  # 用于存放可以匹配的完整命令
                for k in dic:  # 字典迭代取出的是键，即为完整命令
                    if ' ' in k:  # 排除掉一个关键字的命令
                        totalcom_list = k.split(' ')
                        # 若匹配成功第一个关键字，且匹配成功第二个关键字
                        if totalcom_list[0].startswith(simcom_list[0]) and totalcom_list[1].startswith(simcom_list[1]):
                            match.append(k)
                if len(match) == 1:
                    print(dic[match[0]])
                else:
                    print("unknown command")
            else:  # 输入的是三字串或者更多字串
                print("unknown command")
    except:
        break