2019/04/10 华为笔试 软件卷（java）

        第五次笔试，最后半个小时愣是没把第一题的剩下0.2和最后一题的剩下0.545推进一点点。最后一题致命打击，完全不知道怎么去优化。

0.8   1.0   0.455

1.（0.8）对输入字符串数组进行处理，字符串长度大于8就截成两个字符串，长度小于8就用0填补至长度等于8，对字符串数据进行从小到大排序，输出。

笔试想法：对输入的字符串进行判断长度，如果大于8就就进行截断，小于或者等于8的时候就直接加入数组，最后输出的时候再对字符串进行判断，如果等于8直接输出，小于8就填补0至长度为8。

现在想法（刚笔试完）：写思路的时候突然想起来为什么通过80%,因为忘了考虑字符串长度大于16的情况，zz。

                                     （只有在考完的时候才头脑清醒）

代码：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
   public static void main(String[] args) {
      Scanner in = new Scanner(System.in);
      int n = in.nextInt();
      String line = in.nextLine().trim();
      String[] ss = line.split(" ");;
      ArrayList result = new ArrayList<>();
      for (String s : ss) {
	   	   if((s = s.trim()).equals("")) continue;
	   	   if(s.length() == 8) {
	   		   result.add(s);
	   	   }else if(s.length()>8) {
	   		   while(s.length() > 8) {
	   			   result.add(s.substring(0, 8));
	   			   s = s.substring(8);
	   		   }
	   		   result.add(s);
	   	   }else {
	   		   result.add(s);
	   	   }
	  }
      result.sort(new Comparator() {
    	  @Override
			public int compare(String o1, String o2) {
    		    for(int i=0;io2.charAt(i)) {
    		    		return 1;
    		    	}
    		    	if(o1.charAt(i)

 

2.（1.0）对字符串进行展开即每个括号前有一个数字k，将括号里的字符串复制k遍，最后倒序输出。

              例如abc3(A),输出AAAcba

笔试想法：利用栈来完成，判断当前遍历字符是否为右括号 )、]、}其中的一个，不是则直接入栈，否则退栈，直至找到与之匹配的左括号，到左括号之前的字符串s都是要复制的，再退一个栈就是复制次数k，将s复制k次入栈，注意入栈顺序，因为最后需要倒序输出。

代码：

import java.util.Scanner;
import java.util.Stack;
public class Main {
    public static void main(String[] args) {
       Scanner in = new Scanner(System.in);
       String s = in.nextLine().trim();
       if(s == null || s.length() == 0) return;
       char[] chars = s.toCharArray();
       Stack stack = new Stack<>();
       for (int i=0;i 0) {
    			   for(int j=0;j=0;k--) {
        				   stack.push(cs[k]);
        			   }
        		   }
    		   }
    	   }else if(chars[i] == ']') {
    		   String temp = "";
    		   char c = stack.pop();
    		   while(c != '[') {
    			   temp = temp + c;
    			   c = stack.pop();
    		   }
    		   int times = Integer.valueOf(String.valueOf(stack.pop()));
    		   if(temp.length() > 0) {
    			   for(int j=0;j=0;k--) {
        				   stack.push(cs[k]);
        			   }
        		   }
    		   }
    	   }else if(chars[i] == '}') {
    		   String temp = "";
    		   char c = stack.pop();
    		   while(c != '{') {
    			   temp = temp + c;
    			   c = stack.pop();
    		   }
    		   int times = Integer.valueOf(String.valueOf(stack.pop()));
    		   if(temp.length() > 0) {
    			   for(int j=0;j=0;k--) {
        				   stack.push(cs[k]);
        			   }
        		   }
    		   }
    	   }else {
        	   stack.push(chars[i]);
    	   }
		
	   }
       while(!stack.isEmpty()) {
    	   char c = stack.pop();
    	   System.out.print(c);
       }
    }

}

3.（0.445）有一个n*m的地图，每个坐标有一个高度值，你可以往坐标上下左右走，但保证下一个坐标未走过且高度大于现在的坐标，求A到B有多少条路径，模1000000000。

笔试想法：就是递归+剪枝，从上下左右四个坐标且符合①未走过②高度大于当前坐标这两个条件的坐标走。

                 （复杂度太高，只通过45.5%，我完全不知道怎么改，我就是个菜鸡）

代码：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
       Scanner in = new Scanner(System.in);
       int n = in.nextInt();
       int m = in.nextInt();
       int[][] h = new int[n][m];
       for(int i=0;i=0 && h[crri-1][crrj] > h[crri][crrj] && r[crri-1][crrj] == false) {
    		sum = forward(r, crri-1, crrj, bi, bj, h, sum);
    	}
        //向下走
    	if(crri+1 h[crri][crrj] && r[crri+1][crrj] == false) {
    		sum = forward(r, crri+1, crrj, bi, bj, h, sum);
    	}
        //向左走
    	if(crrj-1>=0 && h[crri][crrj-1] > h[crri][crrj] && r[crri][crrj-1] == false) {
    		sum = forward(r, crri, crrj-1, bi, bj, h, sum);
    	}
         //向右走
    	if(crrj+1 h[crri][crrj] && r[crri][crrj+1] == false) {
    		sum = forward(r, crri, crrj+1, bi, bj, h, sum);
    	}
        //将当前坐标置为未走过
    	r[crri][crrj] = false;
    	return sum;
    }

}

 

2019/04/10   21:56  记录一下笔试的想法，后续将通过社区更新所有AC代码