Java面向对象编程

IP地址205.140.36.68的哪一部分表示网络号（）

A. 205

B. 205.140

C. 68

D. 205.140.36

答案：D

IP数据报分片的重组通常发生在（）

A. 源主机和数据报经过的路由器上

B. 源主机上

C. 数据报经过的路由器上

D. 目的主机上

答案：D

以下不属于tcp连接断开的状态是（）

A. TIME_WAIT

B. FIN_WAIT_1

C. SYNC_SENT

D. FIN_WAIT_2

答案：C

ip地址10.1.8.0/24和10.1.9.0/24，下列哪个是正确的汇总网段（）

A. 10.0.0.0/8

B. 10.1.0.0/16

C. 10.1.8.0/23

D. 10.1.10.0/24

答案：C

属于网络112.10.200.0/21的地址是（）

A. 112.10.206.0

B. 112.10.217.0

C. 112.10.224.0

D. 112.10.198.0

答案：A

下列TCP连接建立过程描述正确的是（）

A. 服务端收到客户端的SYN包后等待2*ml时间后就会进入SYN_SENT状态

B. 服务端收到客户端的ACK包后会进入SYN_RCVD状态

C. 当客户端处于ESTABLISHED状态时，服务端可能仍然处于SYN_RCVD状态

D. 服务端未收到客户端确认包，等待2*ml时间后会直接关闭连接

答案：C

TCP建立连接的过程采用三次握手，已知第三次握手报文的发送序列号为1000，确认序列号为2000，请问第二次握手报文的发送序列号和确认序列号分别为（）

A. 1999，999

B. 1999，1000

C. 999，2000

D. 999，1999

答案：B

应用程序PING发出的是什么报文（）

A. TCP 请求报文

B. TCP 应答报文

C. ICMP 请求报文

D. ICMP 应答报文

答案：C

HTTP协议中，如果要告知所请求的网页已经永久跳转到了另一个地址，应该返回哪个状态码（）

A. 301

B. 302

C. 404

D. 503

答案：A

在因特网中，下列哪个不是IP层所需解决的问题（）

A. 流量控制

B. 路径选择

C. 寻址

D. 分段和重新组装

答案：A

乒乓球筐 

题目描述：nowcoder有两盒（A、B）乒乓球，有红双喜的、有亚力亚的……现在他需要判别A盒是否包含了B盒中所有的种类，并且每种球的数量不少于B盒中的数量，该 怎么办呢？ 

输入描述：输入有多组数据。 

每组数据包含两个字符串A、B，代表A盒与B盒中的乒乓球，每个乒乓球用一个大写字母表示，即相同类型的乒乓球为相同的大写字母。 

字符串长度不大于10000。 

输出描述：每一组输入对应一行输出：如果B盒中所有球的类型在A中都有，并且每种球的数量都不大于A，则输出“Yes”；否则输出“No”。

 

public class Main74 {

    //乒乓球筐

    public static void main(String[] args) {

        String strA;

        String strB;

        Scanner scanner=new Scanner(System.in);

        while (scanner.hasNextLine()){

            String[] strArr= scanner.nextLine().split(" ");

            strA=strArr[0];

            strB=strArr[1];

            char[] arrA=strA.toCharArray();

            char[] arrB=strB.toCharArray();

            HashMap<Character,Integer> mapA=new HashMap<>();

            HashMap<Character,Integer> mapB=new HashMap<>();

            //统计字符出现的次数

            for (char ch:arrA) {

                if (mapA.containsKey(ch)){

                    mapA.put(ch,mapA.get(ch)+1);

                }else {

                    mapA.put(ch,1);

                }

            }



            for (char ch:arrB) {

                if (mapB.containsKey(ch)){

                    mapB.put(ch,mapB.get(ch)+1);

                }else {

                    mapB.put(ch,1);

                }

            }

            boolean ret=true;

            //遍历字符串B

            for (char ch: arrB) {

                if ( !mapA.containsKey(ch) || mapA.get(ch) <mapB.get(ch)){

                    ret=false;

                    break;

                }

            }

            if (ret){

                System.out.println("Yes");

            }else {

                System.out.println("No");

            }



        }

    }

}

查找兄弟单词

题目描述：定义一个单词的“兄弟单词”为：交换该单词字母顺序（注：可以交换任意次），而不添加、删除、修改原有的字母就能生成的单词。 

兄弟单词要求和原来的单词不同。例如： ab 和 ba 是兄弟单词。 ab 和 ab 则不是兄弟单词。 

现在给定你 n 个单词，另外再给你一个单词 x ，让你寻找 x 的兄弟单词里，按字典序排列后的第 k 个单词是什么？ 

注意：字典中可能有重复单词。 

数据范围：1<=n<=1000，输入的字符串长度满足1<=len(str)<=10,1<k<n 

输入描述：输入只有一行。 先输入字典中单词的个数n，再输入n个单词作为字典单词。 然后输入一个单词x 最后后输入一个整数k 

输出描述：第一行输出查找到x的兄弟单词的个数m 第二行输出查找到的按照字典顺序排序后的第k个兄弟单词，没有符合第k个的话则不用输出。

public class Main75 {

    //查找兄弟单词

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);

        while (scanner.hasNextLine()){

            String[] str= scanner.nextLine().split(" ");

            int n=Integer.parseInt(str[0]);

            String[] arr=new String[n];

            for (int i = 0; i < n; ++i) {

                arr[i]=str[i+1];

            }

            //单词x

            String curStr=str[n+1];

            int k=Integer.parseInt(str[n+2]);

            //给数组进行排序

            Arrays.sort(arr);

            int count=0;

            String kStr="";

            for (String e:arr) {

                if (isBrother(e.toCharArray(),curStr.toCharArray())){

                    count++;

                    //判断是否为第K个兄弟单词

                    if(count==k){

                        kStr=e;

                    }

                }

            }

            System.out.println(count);

            if (count>=k){

                System.out.println(kStr);

            }

        }

    }



    public static boolean isBrother(char[] str1,char[] str2){

        //长度相同

        if (str1.length !=str2.length){

            return false;

        }

        //内容不同

        String strA=new String(str1);

        String strB=new String(str2);

        if (strA.equals(strB)){

            return false;

        }

        //排序之后，内容相同

        Arrays.sort(str1);

        Arrays.sort(str2);

        strA=new String(str1);

        strB=new String(str2);

        return strA.equals(strB);

    }

}