Java面向对象编程

下面关于IP地址的论述中哪个是不正确的（）

A.用户主机的IP地址可静态分配也可以动态分配

B.IP地址有单播地址，也有多播地址

C.一个用户主机只能有一个IP地址

D.在以太局域网中使用ARP协议查找与一IP地址对应的MAC地址

答案：C

tcp套接字中，不会阻塞的是哪一种操作（）

A.read

B.write

C.accept

D.bind

答案：D

以下几条路由，10.1.193.0/24,10.1.194.0/24,10.1.196.0/24,10.1.198.0/24，如果进行路由汇聚，则能覆盖这几条路由地址的是（）

A.10.1.192.0/22

B.10.1.200.0/22

C.10.1.192.0/21

D.10.1.224.0/20

答案：C

当一台 PC从一个网络移到另一个网络时，以下说法正确的是（）

A.它的 IP 地址和 MAC 地址都会改变

B.它的 IP 地址会改变，MAC 地址不会改变

C.它的 MAC 地址会改变，IP 地址不会改变

D.它的 MAC 地址、IP 地址都不会改变

答案：B

在TCP/IP建立连接过程中，客户端或服务器的状态转移说法错误的是（）

A.经历SYN_RECV状态

B.经历SYN_SEND状态

C.经历ESTABLISHED状态

D.经历TIME_WAIT状态

答案：D

ping命令是基于哪个协议（）

A.ICMP

B.TCP

C.IP

D.UDP

答案：A

下面关于TCP的描述，错误的是（）

A.TCP是一种面向连接的协议，给用户进程提供可靠的全双工的字节流

B.TCP客户端和服务器之间建立连接需要经过3次握手

C.只要有一方主动关闭连接后，这个TCP连接就结束了

D.TCP在传输数据过程中必须保持着连接，这个连接会给通信过程增加开销

答案：C

如果将网络IP段40.15.128.0/17划分成2个子网，则第一个子网IP段为40.15.128.0/18,则第二个子网为（）

A.40.15.129.0/18

B.40.15.128.128/18

C.40.15.192.0/17

D.40.15.192.0/18

答案：D

下面对Host文件描述正确的是（）

A.这个文件是批处理文件,用来指定域名的访问IP

B.一个DNS域名解析服务器文件,用于解析域名对应的IP地址

C.作用是网址域名与其对应的IP地址建立一个关联"数据库"

D.当用户输入网址后,系统首先到DNS服务器中寻找对应的IP地址,如果不存在会到Host文件中确定最终访问地址

答案：C

下列选项中,属于"10.174.20.176/28"该网段的有效IP地址是（）

A.10.174.20.174

B.10.174.20.186

C.10.174.20.191

D.10.174.20.192

答案：B

解读密码

题目描述: nowcder要和朋友交流一些敏感的信息，例如他的电话号码等。因此他要对这些敏感信息进行混淆，比如在数字中间掺入一些额外的符号，让它看起来像一堆乱码。

现在请你帮忙开发一款程序，解析从nowcoder那儿接收到的信息，读取出中间有用的信息。

输入描述:输入有多行。

每一行有一段经过加密的信息(其中可能包含空格)，并且原始信息长度不确定。

输出描述:输出每段信息中数字信息。

 

public class Main68 {

    //解读密码

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);

        while (scanner.hasNext()){

            String strCode=scanner.nextLine();

            StringBuilder str=new StringBuilder();



            for (int i = 0; i < strCode.length(); ++i) {

                char ch=strCode.charAt(i);

                if (ch>='0' && ch<='9'){

                    str.append(ch);

                }

            }

            System.out.println(str);

        }

    }

}

解读密码

题目描述：

nowcoder要和朋友交流一些敏感的信息，例如他的电话号码等。因此他要对这些敏感信息进行混淆，比如在数字中间掺入一些额外的符号，让它看起来像一堆乱码。
现在请你帮忙开发一款程序，解析从nowcoder那儿接收到的信息，读取出中间有用的信息。

输入描述：

输入有多行。

每一行有一段经过加密的信息（其中可能包含空格），并且原始信息长度不确定。

输出描述：

输出每段信息中数字信息。

输入：

$Ts!47&*s456  a23* +B9k

输出：

47456239

import java.util.Scanner;
import java.util.Stack;
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while (scanner.hasNextLine()){
            String str=scanner.nextLine();
            Stack stack=new Stack<>();
            for (int i = 0; i < str.length(); i++) {
                //入栈
                stack.push(str.charAt(i));
            }
            StringBuilder stringBuilder=new StringBuilder();
 
            for (int i = 0; i < str.length(); i++) {
                if (findIndex(str.charAt(i))){
                    stringBuilder.append(str.charAt(i));
                }
            }
 
            System.out.println(stringBuilder.toString());
 
        }
    }
 
    public static boolean findIndex(char ch){
        if (ch>='0' && ch<='9'){
            return true;
        }
        return false;
    }
}
 
//$Ts!47&*s456  a23* +B9k
//47456239

走迷宫

题目描述:NowCoder最喜欢游乐场的迷宫游戏，他和小伙伴们比赛谁先走出迷宫。

现在把迷宫的地图给你，你能帮他算出最快走出迷宫需要多少步吗?

输入描述:输入包含多组数据。

每组数据包含一个10*10，由“#"和"∵"组成的迷宫。其中“#"代表墙;“."代表通路。

入口在第一行第二列;出口在最后一行第九列。

从任意一个“."点都能一步走到上下左右四个方向的“."点。

输出描述:对应每组数据，输出从入口到出口最短需要几步。

class Position {

    int x;

    int y;

    int level; //表示从入口到(x,y)所走的步数



    public Position(int x, int y, int level) {

        this.x = x;

        this.y = y;

        this.level = level;

    }

}



public class Main69 {

    //走迷宫

    public static int bfs(String[] map, int m, int n) {

        //方向数组  下 右 右 上

        int[][] direct = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};



        //迷宫的入口和出口

        Position enter = new Position(0, 1, 0);

        Position out = new Position(9, 8, 0);



        //给出走过路径的标记数组

        boolean[][] flag = new boolean[m][n];



        //采用广度优先遍历方式来走迷宫

        Queue<Position> q = new LinkedList<>();

        q.offer(enter);



        while ( !q.isEmpty()) {

            Position cur = q.poll();



            //遍历该位置----实际就是将该位置进行标记

            flag[cur.x][cur.y] = true;



            //如果cur在出口的位置，说明最短路径找到了

            if (cur.x == out.x && cur.y == out.y) {

                return cur.level;

            }



            //向cur的四个方向进行遍历

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

                Position next = new Position(cur.x + direct[i][0],

cur.y + direct[i][1],cur.level + 1);



                //检测next放下是否可以移动

                //检测next坐标是否合法

                //如果next位置是通路

                //该位置是否走过

                if (next.x >= 0 && next.x < m && next.y >= 0 && 

next.y< n &&map[next.x].charAt(next.y) == '.'

&& !flag[next.x][next.y]) {

                    q.offer(next);

                }

            }

        }

        return 0;

    }



    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {

            //接收迷宫地图数据

            String[] map = new String[10];

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

                map[i] = scanner.nextLine();

            }



            //使用广度右下遍历走迷宫找到最短的路径

            System.out.println(bfs(map, 10, 10));

        }

    }

}