2013年亚马逊在线笔试题

笔试题有两道，下面分别介绍。实现过程使用了Java语言。

The first one:

We have an array representing customer’s shopping records.
For example, it’s an array like this:
custA, item1,
custB, item1,
custA, item2,
custB, item3,
custC, item1,
custC, item3,
custD, item2,
This array indicates that customer A bought item 1, customer B bought item 1, customer A bought item 2, customer B bought item

3, etc..
For a given item X and shopping records array, write code to find out what else (item Y) was bought mostly by the customers who

bought item X.
For example, in above example, if X is item 1 then Y should be item 3.
Rules:
One customer can only buy one item once.
The mostly brought item should not be item X.
If no customer brought item X, then return “None”
If all the customers who brought item X only brought item X, then return “None”
The first line of input is the item X. The second line of input is the shopping record array, this shopping record array is split by

space.
If there are many other mostly brought items which have equally brought times, then return any one of those items.
Examples:
Input1:
item1
custA item1 custB item1 custA item2 custB item3 custC item1 custC item3 custD item2
Output1:
item3
Input2:
item2
custA item1 custB item1 custC item1 custA item2 custB item3 custA item3
Output2:
item1
(The output2 can be item3 too)

基本思路：顾客和商品之间的关系可以用二分图来表示，考虑数据结构中图的存储有邻接矩阵、邻接表等存储方式。该题需要涉及到每个点的入度和出度计算，应该使用邻接矩阵来存储。可以构建一个二维矩阵，存储顾客和商品之间的关系，顾客作为矩阵的行坐标，商品作为矩阵的纵坐标。顾客购买过商品，则矩阵中相应的元素置为1，其余元素置为0。

实现过程中有个工程性问题，就是输入中的顾客和商品名称都是字符串，如何将其映射为矩阵的行列数值索引，解决了这个问题，基本上就是简单的计数了。名称和索引的对应关系使用了HashTable来存放。具体实现如下：

         String line1 = null;
        String line2 = null;
        //用于存放名称和索引映射关系
        Hashtable<String, Integer> custmap = new Hashtable<String, Integer>();
        Hashtable<String, Integer> itemmap = new Hashtable<String, Integer>();
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try {
            line1 = br.readLine();
            line2 = br.readLine();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        if(!line2.contains(line1)){
            System.out.println("None");
            return;
        }
        
        String[] tmp = line2.split(" ");
        //构建名称和索引的映射关系，并统计顾客和商品数量
        int m = 0;
        int n = 0;
        for(int i = 0; i < tmp.length; i++){
            if(i % 2 == 0){
                if(!custmap.containsKey(tmp[i])){
                    custmap.put(tmp[i], m++);
                }
            }else {
                if(!itemmap.containsKey(tmp[i])){
                    itemmap.put(tmp[i], n++);
                }
            }
        }
        //创建矩阵，用于存放顾客和商品关系
        int[][] matrix = new int[m][n];
        //在矩阵中构建顾客和商品关系
        for(int i = 0; i < tmp.length; i = i+2){
            int x = custmap.get(tmp[i]);
            int y = itemmap.get(tmp[i + 1]);
            matrix[x][y] = 1;
        }
        //辅助数组，cust用于标记购买过某一商品的所有顾客，item用于存放cust中标记的所有顾客购买其他商品的数量
        int cust[] = new int[m];
        int item[] = new int[n];
        //获得特定商品在矩阵中的列索引
        int t = itemmap.get(line1);
        //标记购买过指定商品的所用顾客
        for(int i = 0; i < m; i++){
            if(matrix[i][t] == 1){
                cust[i] = 1;
            }
        }
        //统计购买过特定商品的所有顾客购买其他商品的数量，存放在item数组中
        for(int j = 0; j < n; j++){
            if(j != t){
                for(int i = 0; i < m; i++){
                    if(cust[i] != 0 && matrix[i][j] == 1){
                        item[j]++;
                    }                    
                }
            }
        }
        //找到购买数量最多的其他商品，并从映射关系中找到其对应的名称
        int maxIndex = 0;
        for(int i = 0; i < n; i++){
            if(item[i] > item[maxIndex]){
                maxIndex = i;
            }
        }
        if(item[maxIndex] == 0){
            System.out.println("None");
            return;
        } else {
            for(String key : itemmap.keySet()){
                if(itemmap.get(key) == maxIndex){
                    System.out.println(key);
                    break;
                }
            }
        }

 

 The second one:

As you know, two operations of Stack are push and pop. Now give you two integer arrays, one is the original array before push and pop operations, the other one is the result array after a series of push and pop operations to the first array. Please give the push and pop operation sequence.

For example:

If the original array is a[] = {1,2,3}, and the result array is b[] = {1,3,2}.

Then, the operation sequence is “push1|pop1|push2|push3|pop3|pop2”(operations are split by ‘|’ and no space).

Rules:

1.The push and pop operations deal with the original int array from left to right..
2.The input is two integer array. They are the original array and the result array. These interger array is split by space..
3.The output is the operation sequence..
4.If the original array cannot make to the result array with stack push and pop, The output should be 'None'..
5.The operation "push1" means push the first element of the original array to the stack..
6.The operation "pop1" means pop the first element of the original array from the stack, and add this element to the tail of the result array..
7.Please don't include any space in the output string..

Sample1:
Input:
1 2 3 4

1 2 3 4
Output:
push1|pop1|push2|pop2|push3|pop3|push4|pop4

Sample2:

Input:

1 2 3 4

4 3 2 1
Output:
push1|push2|push3|push4|pop4|pop3|pop2|pop1

基本思路：程序中使用一个栈，模拟整个操作过程。结果数组下标的移动肯定要慢于初始数组下标，并且当栈顶元素等于结果数组下标所指定的元素时进行出栈操作，并向前移动结果数组下标。具体实现如下所示：

 

        public String generateSequence(int[] o, int[] r){//o为初始数组，r为结果数组
        String s = "";
        int i = 0;
        int j = 0;
        int len = o.length;
        Stack<Integer> stack = new Stack<Integer>();
        
        while(i < len && j < len){
            if(stack.empty()){
                stack.push(o[i]);
                s += "push" + o[i] + "|";
                i++;
            } else {
                if(stack.peek() != r[j]){
                    stack.push(o[i]);
                    s += "push" + o[i] + "|";
                    i++;
                } else {
                    s += "pop" + stack.pop() + "|";
                    j++;
                }
            }
        }
        while( j < len ){
            if(stack.peek() == r[j]){
                s += "pop" + stack.pop() + "|";
                j++;
            } else {
                s = "None|";
                break;
            }
        }
        return s.substring(0, s.length() - 1);
    }