某硕软件校园招聘笔试题

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

第一部分：简答题

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

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

ISO七层模型：

TCP/IP四层模型：

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

int a=4;

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

(B) 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. 请编写一个程序实现乘法口诀表，乘法口诀表如下：

送头题，如下：

 1 public class Main {
 2 
 3     public static void main(String[] args) {
 4         
 5         for(int i=1;i<=9;i++){
 6             for(int j=1;j<=i;j++){
 7                 System.out.printf("%d*%d=%d ",i,j,i*j);
 8             }
 9             System.out.println();
10         }
11         
12     }
13     
14 }

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

代码如下：

 1 public class Main {
 2 
 3     public static void main(String[] args) {
 4         
 5         final int n=1000;
 6         for(int c=n;c>=0;c--){
 7             for(int b=c-1;b>=0;b--){
 8                 int a=n-b-c;
 9                 if(a<0 || a>=b) continue;
10                 if(pow2(a)+pow2(b)==pow2(c)){
11                     System.out.printf("%d %d %d
",a,b,c);
12                 }
13             }
14         }
15     }
16     
17     public static int pow2(int n){
18         return n*n;
19     }
20     
21 }

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

已知的红色连线：

这道题考的是算法。

我的思路：

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

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

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

所有三角形的可能性是:

=20种

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

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

代入样例数据：

代码如下：

 1 import java.util.Scanner;
 2 
 3 public class Main {
 4 
 5     public static void main(String[] args) {
 6         
 7         final int size=6;
 8         final int inf=-1;
 9         
10         int x[][]=new int[size][size];
11         for(int i=0;i<size;i++){
12             x[i][i]=inf;
13         }
14         
15         Scanner sc=new Scanner(System.in);
16         int n=sc.nextInt();
17         while(n-->0){
18             int u=sc.nextInt()-1;
19             int v=sc.nextInt()-1;
20             x[u][v]=1;
21             x[v][u]=1;
22         }
23         
24         int ans=0;
25         for(int i=0;i<size;i++){
26             for(int j=i+1;j<size;j++){
27                 for(int k=j+1;k<size;k++){
28                     if(x[i][j]==x[j][k] && x[j][k]==x[k][i]) ans++;
29                 }
30             }
31         }
32         System.out.println(ans);
33         
34     }
35     
36 }

输入：

输出：

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

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

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

这道题考的是工程应用。

计算得分的类：

 1 import java.io.BufferedReader;
 2 import java.io.FileInputStream;
 3 import java.io.FileNotFoundException;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.io.UnsupportedEncodingException;
 7 
 8 /**
 9  * 单词工具类
10  * @author CC11001100
11  *
12  */
13 public class WordUtils {
14 
15     /**
16      * 传入文件路径和文件编码方式，返回得分最高的单词
17      * @param filepath 文件路径
18      * @param separator 单词分隔符
19      * @param charset 文件编码方式
20      * @return String 得分最高的单词
21      */
22     public static String getHighestScore(String filepath,String separator,String charset){
23         
24         BufferedReader reader=null;
25         try {
26             reader=new BufferedReader(new InputStreamReader(new FileInputStream(filepath),charset));
27             
28             //缓冲读入
29             StringBuilder sb=new StringBuilder();
30             while(reader.ready()) sb.append(reader.readLine());
31 
32             //分离单词
33             String ss[]=sb.toString().split(separator);
34             
35             //计算每个单词得分拿到最大的
36             int maxScore=0;
37             String maxString=null;
38             for(int i=0;i<ss.length;i++){
39                 int t=coutingScore(ss[i]);
40                 if(t>maxScore){
41                     maxScore=t;
42                     maxString=ss[i];
43                 }
44             }
45             
46             return maxString;
47         } catch (UnsupportedEncodingException e) {
48             e.printStackTrace();
49         } catch (FileNotFoundException e) {
50             e.printStackTrace();
51         } catch (IOException e) {
52             e.printStackTrace();
53         }finally{
54             //清理资源
55             if(reader!=null){
56                 try {
57                     reader.close();
58                 } catch (IOException e) {
59                     e.printStackTrace();
60                 }
61             }
62         }
63         return null;
64     }
65     
66     /**
67      * 计算单词得分
68      * @param word 英文单词，不区分大小写
69      * @return 
70      */
71     public static int coutingScore(String word){
72         
73         //统一大写
74         word=word.toUpperCase();
75         
76         //扫描计算得分
77         int score=0;
78         for(int i=0;i<word.length();i++) score+=word.charAt(i)-'A'+1;
79         return score;
80     }
81     
82 }

生成测试数据的类：

 1 import java.io.BufferedWriter;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 import java.io.OutputStreamWriter;
 5 import java.util.Random;
 6 
 7 public class Main_020 {
 8 
 9     public static void main(String[] args) throws IOException {
10         
11         String savepath="D:/test_001/words.txt";
12         
13         BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(savepath),"UTF-8"));
14         StringBuilder sb=new StringBuilder();
15         for(int i=0;i<5000;i++){
16             sb.append(randWord());
17             if(i!=4999) sb.append(",");
18         }
19         writer.write(sb.toString());
20         writer.close();
21         
22         System.out.println(sb);
23     }
24     
25     public static String randWord(){
26         //长度[1,20]随机
27         int length=new Random().nextInt(20)+1;
28         StringBuilder sb=new StringBuilder(length);
29         while(length-->0){
30             char c=(char) (new Random().nextInt(26)+(new Random().nextBoolean()?'A':'a'));
31             sb.append(c);
32         }
33         return sb.toString();
34     }
35     
36 }

测试类：

 1 public class Main_021 {
 2 
 3     public static void main(String[] args) {
 4         
 5         String ans=WordUtils.getHighestScore("D:/test_001/words.txt",",","UTF-8");
 6         System.out.println(ans);
 7         
 8     }
 9     
10 }

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

EOF