某硕软件校园招聘笔试题

某硕软件校园招聘笔试题（开发）

第一部分：简答题

1.请问TCP/IP协议分为哪几层？

按照一般套路他可能想问的是ISO七层模型（理论），然而另外有一个模型叫做TCP/IP模型的四层模型（实际），它们分别如下：

ISO七层模型：

TCP/IP四层模型：

2. 写出判断ABCD四个表达式的是否正确，若正确，写出各个表达式中a的值。

int a=4;

(A) a+=(a++);

(B) a+=(++a);

(C) (a++)+=a;

(D) (++a)+=(a++);

首先明确一下基本法，左值必须是一个地址。

所以：

A：8

B：9

C、D错误。

我去这么基础的我开始竟然没做对....我以为自加的在使用完会改变自己值，现在看来是被丢弃了，自运算什么的一直有点晕晕的，无实用价值的东西不值得花费时间，价值观如此，嘲讽请随意

3. 给跪了，草榴算不  ：）

4. Error和Exception有什么区别？

Exception是正常的，属于程序员掌控范围内，并且可以借助Exception的名字传递信息（异常重要的就是名字，详见Thinking in java第十二章），但是一出现Error基本意味着玩砸了...

参考了一下网上的资料：

1. Exception是可控的，应该在程序级就处理掉，Error是不可控的，让系统去处理。

2. 一般是由程序员（或输入）导致的问题（人为因素），Error一般是系统错误或低级（没太理解？）的错误（不可控因素）。

3. (Exception) chekced exception鼓励catch，(RuntimeException & Error) unchecked exception不鼓励catch。

参考资料：错误和异常的区别(Error vs Exception)

5.  String、StringBuffer、StringBuilder的区别？

光看底层的话好像并没有太大的区别，都是使用char[]数组来实现的，但是String有一个字符串缓冲池，之前被使用过的会缓存啊，并且像这种"hello"+"world"的会被预编译为StringBuffer的拼接。

好了不扯淡，正经答题：

长度：String是不可变类型，再操作只能返回新的类型，而StringBuffer和StringBuilder的长度都是可变的。

线程安全：StringBuffer是线程安全的，StringBuilder是非线程安全的，当然套路中想听的一句话就是线程安全的效率都会低一些....

通常StringBuffer或StringBuilder会被用来做多次字符串拼接的缓冲。

第二部分：程序题

1. 请编写一个程序实现乘法口诀表，乘法口诀表如下：

送头题，如下：

public class Main {

    public static void main(String[] args) {
        
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.printf("%d*%d=%d ",i,j,i*j);
            }
            System.out.println();
        }
        
    }
    
}

2. 毕达哥拉斯三元组（此处省略看不懂的英文名词描述...），是一组三个正数，a<b<c，并且满足a^2+b^2=c^2。例如：3^2+4^2=5^2,。现在存在一组上面那个名词的数满足a+b+c=1000，请编写一个程序找到这组数a，b，c并将它们输出。

继续送头，这组数是： 200 375 425

代码如下：

public class Main {

    public static void main(String[] args) {
        
        final int n=1000;
        for(int c=n;c>=0;c--){
            for(int b=c-1;b>=0;b--){
                int a=n-b-c;
                if(a<0 || a>=b) continue;
                if(pow2(a)+pow2(b)==pow2(c)){
                    System.out.printf("%d %d %d
",a,b,c);
                }
            }
        }
    }
    
    public static int pow2(int n){
        return n*n;
    }
    
}

3. 平面上有6个点，每两个点之间都以红线或黑线连接，任意三点均不共线。现在，已知下列点之间的连线是红色的，剩下的连线都是黑色的，要求计算这些点组成的三角形有多少是同色的？

已知的红色连线：

6 5
1 2
1 3
2 3
2 5
3 6

这道题考的是算法。

我的思路：

每两个点之间都以红线或黑线连接   -->   有条边的全连通图

任意三点不共线      -->      任意三个顶点都可以组合

根据以上两条可以推出：取任意三个顶点都可以组合成一个三角形。

所有三角形的可能性是:

=20种

从这20种选出三条边a-b、b-c、c-a都相等的边。

可以构图了，使用邻接矩阵：

代入样例数据：

代码如下：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        
        final int size=6;
        final int inf=-1;
        
        int x[][]=new int[size][size];
        for(int i=0;i<size;i++){
            x[i][i]=inf;
        }
        
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        while(n-->0){
            int u=sc.nextInt()-1;
            int v=sc.nextInt()-1;
            x[u][v]=1;
            x[v][u]=1;
        }
        
        int ans=0;
        for(int i=0;i<size;i++){
            for(int j=i+1;j<size;j++){
                for(int k=j+1;k<size;k++){
                    if(x[i][j]==x[j][k] && x[j][k]==x[k][i]) ans++;
                }
            }
        }
        System.out.println(ans);
        
    }
    
}

输入：

6
6 5
1 2
1 3
2 3
2 5
3 6

输出：

5 

4. 存在一个Words.txt，这是一个保存了5000多单词的文本文件，将里面的单词按其字母在26字母表里的位置获取一个位置数（A为1，Z为26），再将每个字母的位置相加，即得到这个单词的得分。

例如：COLIN，它的字母值是3+15+12+9+14=53，所以该单词得分53，请写程序计算出这个文件里得分最高的单词。

备注：名字间是用逗号分隔的，得分不区分字母大小写。

这道题考的是工程应用。

计算得分的类：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

/**
 * 单词工具类
 * @author CC11001100
 *
 */
public class WordUtils {

    /**
     * 传入文件路径和文件编码方式，返回得分最高的单词
     * @param filepath 文件路径
     * @param separator 单词分隔符
     * @param charset 文件编码方式
     * @return String 得分最高的单词
     */
    public static String getHighestScore(String filepath,String separator,String charset){
        
        BufferedReader reader=null;
        try {
            reader=new BufferedReader(new InputStreamReader(new FileInputStream(filepath),charset));
            
            //缓冲读入
            StringBuilder sb=new StringBuilder();
            while(reader.ready()) sb.append(reader.readLine());

            //分离单词
            String ss[]=sb.toString().split(separator);
            
            //计算每个单词得分拿到最大的
            int maxScore=0;
            String maxString=null;
            for(int i=0;i<ss.length;i++){
                int t=coutingScore(ss[i]);
                if(t>maxScore){
                    maxScore=t;
                    maxString=ss[i];
                }
            }
            
            return maxString;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //清理资源
            if(reader!=null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
    
    /**
     * 计算单词得分
     * @param word 英文单词，不区分大小写
     * @return 
     */
    public static int coutingScore(String word){
        
        //统一大写
        word=word.toUpperCase();
        
        //扫描计算得分
        int score=0;
        for(int i=0;i<word.length();i++) score+=word.charAt(i)-'A'+1;
        return score;
    }
    
}

生成测试数据的类：

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Random;

public class Main_020 {

    public static void main(String[] args) throws IOException {
        
        String savepath="D:/test_001/words.txt";
        
        BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(savepath),"UTF-8"));
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<5000;i++){
            sb.append(randWord());
            if(i!=4999) sb.append(",");
        }
        writer.write(sb.toString());
        writer.close();
        
        System.out.println(sb);
    }
    
    public static String randWord(){
        //长度[1,20]随机
        int length=new Random().nextInt(20)+1;
        StringBuilder sb=new StringBuilder(length);
        while(length-->0){
            char c=(char) (new Random().nextInt(26)+(new Random().nextBoolean()?'A':'a'));
            sb.append(c);
        }
        return sb.toString();
    }
    
}

测试类：

public class Main_021 {

    public static void main(String[] args) {
        
        String ans=WordUtils.getHighestScore("D:/test_001/words.txt",",","UTF-8");
        System.out.println(ans);
        
    }
    
}

 连自加都没搞明白的弱渣 or 三观不正 随便找一条就可以把我干掉啦   ：（

EOF