• ThoughtWorks19届秋招内推笔试测试题——总结


    ThoughtWorks19届秋招内推笔试测试题——总结

    随着12点的到来,终于完成了完成了这次内推笔试作业。 随之,是对于写作业的过程中的思维不完善的懊悔。

     

    题目:在线查看传送门:https://sendeyo.com/up/d/37d9daf6c4

    题目描述:

    [R] [R] [R] 
    [R] [R] [R] 
    [R] [R] [R]
     
    [W] [W] [W] [W] [W] [W] [W] 
    [W] [W] [W] [W] [W] [W] [W] 
    [W] [W] [W] [W] [W] [W] [W] 
    [W] [W] [W] [W] [W] [W] [W] 
    [W] [W] [W] [W] [W] [W] [W] 
    [W] [W] [W] [W] [W] [W] [W] 
    [W] [W] [W] [W] [W] [W] [W] 
    
    [W] [W] [W] [W] [W] [W] [W] 
    [W] [R] [W] [R] [W] [R] [W] 
    [W] [W] [W] [W] [W] [W] [W] 
    [W] [R] [W] [R] [W] [R] [W] 
    [W] [W] [W] [W] [W] [W] [W] 
    [W] [R] [W] [R] [W] [R] [W] 
    [W] [W] [W] [W] [W] [W] [W] 
    
    以上是关系图,我们需要输入两条指令来生成下面的图形(字符串):
      第一行是迷宫道路网格的尺寸。例如3x3的迷宫为3 3,而5x4的迷宫为54 (5行4列)。第二行是迷宫道路网格的连通性定义。如果cel1(0,1)  和cell(0,2) 是连通的,则表示为:0,1 0,2,多个连通以分号;隔开。
      例如,如果给定输入:
      3 3.
      0,1 0,2;0,0 1,0;0,1 1,1;0,2 1,2;1,0 1,1;1,1 1,2;1,1 2,1;1,2 2,2;2,0 2,1
    
    [W] [W] [W] [W] [W] [W] [W] 
    [W] [R] [W] [R] [R] [R] [W] 
    [W] [R] [W] [R] [W] [R] [W] 
    [W] [R] [R] [R] [R] [R] [W] 
    [W] [W] [W] [R] [W] [R] [W] 
    [W] [R] [R] [R] [W] [R] [W] 
    [W] [W] [W] [W] [W] [W] [W] 
    题目

    我在这次笔试犯下的最大的错误就是,对于**连通性检测功能**正则的书写,未能考虑到多位数的出现。

    我的错误写法:"[0-9],[0-9] [0-9],[0-9]"这个导致不能输入多位数,意味着,联通指令出现>10的时候,将报错。

    正确写法:"\d+,\d+ \d+,\d+"  当然,除此之外还有很多细节要处理,但是都没有这个正则重要。

    下面是代码: Grid.java

    package entity;
    /**
     * Grid实体,用于创建Grid对象
     * @author xanwidtf@foxmail.com
     *
     */
    public class Grid {
        private int m;
        private int n;
        String[][] arr;
        public Grid(){
            
        }
        public Grid(int m,int n,String s)
        {
            this.m=m;
            this.n=n;
            this.arr=new String[m][n];
            for(int i=0;i<arr.length;i++)
            {
                for(int j=0;j<arr.length;j++)
                {
                    arr[i][j]=s;
                    //System.out.print(arr[i][j]+" ");    //调试输出
                }
                //System.out.println();
            }
        }
        public int getM() {
            return m;
        }
        public void setM(int m) {
            this.m = m;
        }
        public int getN() {
            return n;
        }
        public void setN(int n) {
            this.n = n;
        }
        public String[][] getArr() {
            return arr;
        }
        public void setArr(String[][] arr) {
            this.arr = arr;
        }
        
    }
    Grid.java

    util.java

    package util;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    /**
     * 工具类
     * 1.3,完美
     * @author xanwidtf@foxmail.com
     *
     */
    public class util {
            
            //初始化渲染网格的方法
            public static String[][] constructGrid(String[][] s,String[][] b){
                String[][] small=s;        //道路网格
                String[][] big=b;        //渲染网格
                for(int i=0;i<small.length;i++)
                {
                    for(int j=0;j<small.length;j++)
                    {
                        if(small[i][j]=="[R]")
                            big[i*2+1][j*2+1]="[R]";
                    }
                }
                return big;
            }
            
            /**
             * 给输入的道路网格​的连通性定义进行格式检查,
             * 是否包含英文字母和汉字
             * @param s
             * @return true为包含,false为不包含
             */
            public static boolean containsABC(String s){
                Pattern p = Pattern.compile("^[A-Za-z0-9u4e00-u9fa5]+$");//定义规则 ,该规则为大小写字母
                Matcher m = p.matcher(s);
                return m.find();
            }
            /**
             * 判断是否含有特殊字符",;"和空格3个不包含在内
             *
             * @param s
             * @return true为包含,false为不包含
             */
            public static boolean isSpecialChar(String s) {
                String regEx = "[_`~!@#$%^&*()+=|{}':'\[\].<>/?~!@#¥%……&*()——+|{}【】‘;:”“’。,、?]|
    |
    |	";
                Pattern p = Pattern.compile(regEx);
                Matcher m = p.matcher(s);
                return m.find();
            }
            
            /**
             * 通过正则表达式的方式获取字符串中特定字符的个数
             * @param text 指定的字符串
             * @return 指定字符的个数
             */
            public static int pattern(String command,String str) {
                // 根据指定的字符构建正则
                Pattern pattern = Pattern.compile(str);
                // 构建字符串和正则的匹配
                Matcher matcher = pattern.matcher(command);
                int count = 0;
                // 循环依次往下匹配
                while (matcher.find()){ // 如果匹配,则数量+1
                    count++;
                }
                return  count;
            }
            
            /**
             * 匹配特定规则
             * @param command
             * @param str
             * @return 符合即返回true
             */
            public static boolean patternMain(String command,String str) {
                // 根据指定的字符构建正则
                Pattern pattern = Pattern.compile(str);
                // 构建字符串和正则的匹配
                Matcher matcher = pattern.matcher(command);
                return  matcher.matches();
            }
            /**
             * 网格联通指令格式检测
             * @param s
             * @return 正确返回true
             */
            public static boolean commandCheck(String s){
                boolean result=false;
                int num=pattern(s,";");
                String[] arr=new String[num+1];
                if(!util.containsABC(s)&&!util.isSpecialChar(s)){    //s只能为
                    if(num>0)
                    {
                        arr=s.split(";");
                        //System.out.println(arr.length);    //调试输出
                        if(arr.length>0&&arr.length>num){
                            for(int i=0;i<arr.length;i++)
                            {    
                                if(arr[i]==null||!arr[i].equals("")){    //判断不允许出现空值
                                    result=patternMain(arr[i],"\d+,\d+ \d+,\d+");
                                }else{
                                    //System.out.println("出现空值");    //调试输出
                                    return false;    //如果用result=false,有可能在for循环后变为true
                                }
                            }
                        }
                        else{
                            return false;
                        }
                    }else
                    {
                        result=patternMain(s,"\d+,\d+ \d+,\d+");
                    }
                }else{
                    return false;
                }
                return result;
            }
            
            /**
             * 联通性检测
             * @return
             */
            public static boolean Maze(String s,int m,int n){
                boolean result=true;
                String str=s.replaceAll("\D+","");
                //System.out.println("连通性测试:"+str);    //调试输出
                for(int i=0;i<str.length();i=i+4)    
                {
                    int x=Integer.parseInt(String.valueOf(str.charAt(i)));    //0
                    int y=Integer.parseInt(String.valueOf(str.charAt(i+2)));    //2
                    int xx=Integer.parseInt(String.valueOf(str.charAt(i+1)));    //1
                    int yy=Integer.parseInt(String.valueOf(str.charAt(i+3)));    //3
                    if(x==y||xx==yy){
                        //System.out.println(" "+x+y+" "+xx+yy);    //调试输出
                        if(x<m&&y<n&&xx<m&&yy<n&&Math.abs(x-y)<(m-1)&&Math.abs(xx-yy)<(n-1)){//坐标值不能超过行列的值,并且,两坐标距离不能超过行、列的下标的值,否则无法联通
                            result=true;
                        }else{
                            result=false;
                        }
                    }else{
                        return false;
                    }
                }
                return result;
            }
            
            /**
             * 通过提取连通性指令的有效数值,渲染网格
             * @param s
             * @param arr
             * @return 返回一个二维数组
             */
            public static String[][] drawGrid(String s,String[][] arr){
                String[] temp=s.split(";");
                String[] Temp=new String[temp.length];
                for(int j=0;j<Temp.length;j++)
                {
                    Temp[j]=temp[j].replaceAll("\D+","");
                }
                
                for(int i=0;i<Temp.length;i++)
                {    int k=0;
                    int x = 0,y = 0;
                    if(Temp[i].charAt(k)==Temp[i].charAt(k+2)){
                        x=Integer.parseInt(String.valueOf(Temp[i].charAt(k)))*2+1;
                        y=Integer.parseInt(String.valueOf(Temp[i].charAt(k+1)))*2+1+1;
                        //System.out.println("xy"+x+" "+y);        //调试输出
                        arr[x][y]="[R]";
                    }
                    else if(Temp[i].charAt(k+1)==Temp[i].charAt(k+3)){
                        x=Integer.parseInt(String.valueOf(Temp[i].charAt(k)))*2+1+1;
                        y=Integer.parseInt(String.valueOf(Temp[i].charAt(k+1)))*2+1;
                        //System.out.println("xy"+x+" "+y);        //调试输出
                        arr[x][y]="[R]";
                    }
                }
                return arr;
            }
            
            /**
             * 打印输出数组
             * @param arr
             */
            public static void printGrid(String[][] arr){
                for(int i=0;i<arr.length;i++)
                {
                    for(int j=0;j<arr.length;j++)
                    {
                        System.out.print(arr[i][j]+" ");
                    }
                    System.out.println();
                }
            }
    }
    util.java

    finalMain.java

    package Main;
    
    import java.util.Scanner;
    
    import entity.Grid;
    import util.util;
    
    public class finalMain {
    
        public static void main(String[] args) {
        
            while(true)
            {        
                int m,n=0;
                try{
                    //System.out.println("输入两位整数,初始化道路网格尺寸(如:3 3):");        //调试输出
                    Scanner sc=new Scanner(System.in);
                    m=sc.nextInt();    //m
                    n=sc.nextInt();    //n
                    //System.out.println("您的输入为:"+m+" "+n);    //调试输出
                    //判断道路网格尺寸大小
                    if(m<2||n<2)
                    {
                        System.out.println("Number out of range.");
                        System.out.println("请重新输入!");    //调试输出
                        continue;
                    }
                    
                    //输入连通性指令
                    //System.out.println("输入道路网格​的连通性指令:");    //调试输出
                    Scanner sc2=new Scanner(System.in);
                    String s=sc2.nextLine();    //道路网格​的连通性定义
                    
                    
                    //连通指令格式检测
                    if(!util.commandCheck(s))
                    {
                        System.out.println("Incorrect command format.");
                        System.out.println("请重新输入!");    //调试输出
                        continue;
                    }else
                    {
                        //System.out.println("您输入的联通指令为:"+s);
                    }
                    
                    //连通性检测,不通过则重来
                    if(!util.Maze(s,m,n)){
                        System.out.println("Mazeformat error.");
                        System.out.println("请重新输入!");    //调试输出
                        continue;
                    }
                    
                    //System.out.println("初始化数组为:");        //调试输出
                    Grid roadGrid=new Grid(m,n,"[R]");    //创建道路网格数组,用R字符
                    Grid renderGrid=new Grid(m*2+1,n*2+1,"[W]");    //创建渲染网格数组,用W字符
                    //System.out.println("初始化的渲染网格数组为:");
                    String[][] arr=util.constructGrid(roadGrid.getArr(), renderGrid.getArr());
                    
                    //执行联通指令 drawGrid
                    util.drawGrid(s,arr);
    
                    //输出渲染网格数组
                    util.printGrid(arr);
                    sc.close();
                    sc2.close();
                    break;
                }
                catch(Exception e)
                {
                    System.out.println("Invalid number format.");
                    break;
                }
            }
    
        }
    }
    finalMain.java

    欢迎各位大佬对代码指点、改进。^O^

  • 相关阅读:
    用Visual C#创建Windows服务程序
    C# WinForm窗口最小化到系统托盘
    C# ?? 运算符是什么?
    linux中守护进程启停工具start-stop-daemon
    linux shell脚本中 mode=${1:-sart} filename=${fileuser:-"filename"}
    Unix/Linux 脚本中 “set -e” 的作用
    利用Sonar定制自定义扫描规则
    docker 镜像详解
    Docker Compose使用
    docker搭建gitlab、Redmine
  • 原文地址:https://www.cnblogs.com/famine/p/9390165.html
Copyright © 2020-2023  润新知