amazon笔试题

下面是来自于亚马逊的编程笔试题，感兴趣的同学可以先自己想想解题思路：

Please implement a simple logic rule, the input is a set of logic formula, the format is like a1,a2,a3,…,an->b, which means a1,a2,a3,…an can deduce b. It meets the following rules:

1. If A->B B->C then A->C

2. If A,B->C D->A then D,B->C

3. If A,B->C then B,A->C

 

The input contains two lines:

1. The first line contains n (100>n>0) base formulas, separated by spaces

2. The second line contains m (100>m>0) formulas that need to check true or false according to above n formulas, separated by spaces

 

The output should be m lines, if the i-th formula in the second line can be deduced by the n base formulas, the i-th line should be "true", otherwise, "false".

 

Each element is a case sensitive alphabet, to simplify the parsing work, “->” is replaced by ">", there might be more than 1 character on the left side and only one on the right side, the following is an example: A,B,C>D

 

Sample Input and Output

Input

A>B B>C

A>C

Output

true

 

Input

A,B>C D,E>A E>B

E,D>C F,E>C

Output

true

false

 

Input

A>B A,B>C

A>C

Output

true

 

Please complement the matchRule method in Solution class:

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

 

public class Solution {

public static void main(String[] args) throws IOException {

InputStreamReader isr = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(isr);

 

String baseRules = br.readLine();

String checkingRules = br.readLine();

 

matchRule(baseRules, checkingRules);

 

br.close();

isr.close();

}

 

private static void matchRule(String baseRules, String checkingRules) {

 

}

}

 

 

 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Vector;


public class Solution {
    
    
    private static HashMap<String, node> nodeAlreadyHave = new HashMap<String, node>();
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);

//        String baseRules = "A>B A,B>C";
//        String checkingRules = "A>C";
        String baseRules = br.readLine();
        String checkingRules = br.readLine();
         
        matchRule(baseRules, checkingRules);
         
        br.close();
        isr.close();
    }
    static class node{
        String identified;
        Vector<node> nextnodes = null;
        int count;
        
        node(String name)
        {
            identified = name;
            count = 0;
            nextnodes = new Vector<node>();
        }
        
        boolean after(node t)
        {
            if(identified.equals(t.identified))
                return true;
            for(int i = 0;i < nextnodes.size(); i++)
            {
                if(nextnodes.get(i).after(t))
                    return true;
            }
            return false;
        }
    }
    private static void matchRule(String baseRules, String checkingRules) {
        System.out.println("test");
        String[] baseRulesArray = baseRules.split(" ");
        for(int i=0 ;i < baseRulesArray.length; i++)
        {
            System.out.println(baseRulesArray[i]);
            
        }
        
        parseRule(baseRulesArray);
        String[] checkingRulesArray = checkingRules.split(" ");
        for(int i=0 ;i < checkingRulesArray.length; i++)
        {
            System.out.println(checkingRulesArray[i]);
            checkRules(checkingRulesArray[i]);
        }
        
        
        
    }
    
    private static void parseRule(String[] rules)
    {
        for(int i = 0 ; i < rules.length;i++)
        {
            String[] token = rules[i].split("[, >]");
            node t;
            if(!nodeAlreadyHave.containsKey(token[token.length-1]))
            {
                t = new node(token[token.length-1]);
                nodeAlreadyHave.put(token[token.length-1], t);
            }else {
                t = nodeAlreadyHave.get(token[token.length-1]);
            }
            for(int j=0 ;j< token.length-1; j++)
            {
                node s;
                if(!nodeAlreadyHave.containsKey(token[j]))
                {
                    s = new node(token[j]);
                    nodeAlreadyHave.put(token[j], s);
                }else{
                    s = nodeAlreadyHave.get(token[j]);
                }
                s.nextnodes.add(t);
                
                //System.out.println("token "+token[j]);
            }
        }
        
    }
    
    private static void checkRules(String checkRule)
    {
        String[] token = checkRule.split("[, >]");
        node t;
        if(!nodeAlreadyHave.containsKey(token[token.length-1]))
        {
            System.out.println("false");
            return ;
        }else {
            t = nodeAlreadyHave.get(token[token.length-1]);
        }
        for(int j=0 ;j< token.length-1; j++)
        {
            node s;
            if(!nodeAlreadyHave.containsKey(token[j]))
            {
                System.out.println("false");
                return ;
            }else{
                s = nodeAlreadyHave.get(token[j]);
            }
            if(s.after(t))
            {
                System.out.println("true");
                return;
            }
            
            
        }
        System.out.println("false");
    }
    

    

}