网易游戏2018年笔试题

第一题：[编程题] 时钟

题目描述

小W有一个电子时钟用于显示时间，显示的格式为HH:MM:SS，HH，MM，SS分别表示时，分，秒。其中时的范围为[‘00’,‘01’…‘23’]，分的范围为[‘00’,‘01’…‘59’]，秒的范围为[‘00’,‘01’…‘59’]。

但是有一天小W发现钟表似乎坏了，显示了一个不可能存在的时间“98:23:00”，小W希望改变最少的数字，使得电子时钟显示的时间为一个真实存在的时间，譬如“98:23:00”通过修改第一个’9’为’1’，即可成为一个真实存在的时间“18:23:00”。修改的方法可能有很多，小W想知道，在满足改变最少的数字的前提下，符合条件的字典序最小的时间是多少。其中字典序比较为用“HHMMSS”的6位字符串进行比较。

输入描述:

每个输入数据包含多个测试点。每个测试点后有一个空行。 第一行为测试点的个数T(T<=100)。 每个测试点包含1行，为一个字符串”HH:MM:SS”，表示钟表显示的时间。

输出描述:

对于每个测试点，输出一行。如果钟表显示的时间为真实存在的时间，则不做改动输出该时间，否则输出一个新的”HH:MM:SS”，表示修改最少的数字情况下，字典序最小的真实存在的时间。

输入例子1:

2
19:90:23
23:59:59

输出例子1:

19:00:23
23:59:59

代码实现

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @author Created By Frank
 * @date 2018-08-07 15:12
 */
public class Main1 {

    public static void main(String[] args) throws FileNotFoundException {
        Scanner in = new Scanner(System.in);
        int n = Integer.valueOf(in.nextLine());

        for(int i = 0;iif (!isValid(strTime)) {
                System.out.println(changeTime(strTime));
            } else {
                System.out.println(strTime);
            }
        }

    }

    // 判断是否有效
    public static boolean isValid(String time) {
        int hours = Integer.valueOf(time.split(":")[0]);
        int mins = Integer.valueOf(time.split(":")[1]);
        int seconds = Integer.valueOf(time.split(":")[2]);

        if (hours >= 0 && hours <= 23 && mins >= 0 && mins <= 59 && seconds >= 0 && seconds <= 59)
            return true;
        return false;
    }


    public static String changeTime(String time) {
        StringBuffer res = new StringBuffer();

        String h = time.split(":")[0];
        String m = time.split(":")[1];
        String s = time.split(":")[2];


        int hours = Integer.valueOf(time.split(":")[0]);
        int mins = Integer.valueOf(time.split(":")[1]);
        int seconds = Integer.valueOf(time.split(":")[2]);

        List list = new ArrayList<>();

        if (hours >= 0 && hours <= 23) {
            res.append(h);
        } else {
            res.append("0");
            res.append(hours % 10);
        }
        res.append(":");

        if (mins >= 0 && mins <= 59) {
            res.append(m);
        } else {
            res.append("0");
            res.append(mins % 10);
        }

        res.append(":");

        if (seconds >= 0 && seconds <= 59) {
            res.append(s);
        } else {
            res.append("0");
            res.append(seconds % 10);
        }
        return res.toString();
    }
}

第二题：[编程题] 会话列表

题目描述

小云正在参与开发一个即时聊天工具，他负责其中的会话列表部分。

会话列表为显示为一个从上到下的多行控件，其中每一行表示一个会话，每一个会话都可以以一个唯一正整数id表示。

当用户在一个会话中发送或接收信息时，如果该会话已经在会话列表中，则会从原来的位置移到列表的最上方；如果没有在会话列表中，则在会话列表最上方插入该会话。

小云在现在要做的工作是测试，他会先把会话列表清空等待接收信息。当接收完大量来自不同会话的信息后，就输出当前的会话列表，以检查其中是否有bug。

输入描述:

输入的第一行为一个正整数T（T<=10），表示测试数据组数。
接下来有T组数据。每组数据的第一行为一个正整数N（1<=N<=200），表示接收到信息的次数。第二行为N个正整数，按时间从先到后的顺序表示接收到信息的会话id。会话id不大于1000000000。

输出描述:

对于每一组数据，输出一行，按会话列表从上到下的顺序，输出会话id。
相邻的会话id以一个空格分隔，行末没有空格。

输入例子1:

3
5
1 2 3 4 5
6
1 100 1000 1000 100 1
7
1 6 3 3 1 8 1

输出例子1:

5 4 3 2 1
1 100 1000
1 8 3 6

代码实现

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;

/**
 * @author Created By Frank
 * @date 2018-08-07 15:13
 */
public class Main2 {
    public static void main(String[] args) throws FileNotFoundException {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        for (int k = 0; k < n; k++) {
            int count = in.nextInt();
            Set set = new LinkedHashSet<>();

            for (int i = 0; i < count; i++) {
                int item = in.nextInt();
                if (set.contains(item)) {
                    set.remove(item);
                }
                set.add(item);
            }
            printReverseSet(set);
            if (k != n - 1) {
                System.out.println();
            }

        }
    }

    private static void printReverseSet(Set set) {
        for (int i = set.size() - 1; i >= 0; i--) {
            System.out.print(set.toArray()[i]);
            if (i != 0) {
                System.out.print(" ");
            }
        }
    }
}

第三题：[编程题] 字符迷阵

题目描述

字符迷阵是一种经典的智力游戏。玩家需要在给定的矩形的字符迷阵中寻找特定的单词。

在这题的规则中，单词是如下规定的：

1. 在字符迷阵中选取一个字符作为单词的开头；
2. 选取右方、下方、或右下45度方向作为单词的延伸方向；
3. 以开头的字符，以选定的延伸方向，把连续得到的若干字符拼接在一起，则称为一个单词。

以图1为例，如果要在其中寻找单词”WORD”，则绿色框所标示的都是合法的方案，而红色框所标示的都是不合法的方案。

现在的问题是，给出一个字符迷阵，及一个要寻找的单词，问能在字符迷阵中找到多少个该单词的合法方案。注意合法方案是可以重叠的，如图1所示的字符迷阵，其中单词”WORD”的合法方案有4种。

输入描述:

输入的第一行为一个正整数T，表示测试数据组数。 接下来有T组数据。每组数据的第一行包括两个整数m和n，表示字符迷阵的行数和列数。接下来有m行，每一行为一个长度为n的字符串，按顺序表示每一行之中的字符。再接下来还有一行包括一个字符串，表示要寻找的单词。 数据范围： 对于所有数据，都满足1<=T<=9，且输入的所有位于字符迷阵和单词中的字符都为大写字母。要寻找的单词最短为2个字符，最长为9个字符。字符迷阵和行列数，最小为1，最多为99。 对于其中50%的数据文件，字符迷阵的行列数更限制为最多为20。

输出描述

对于每一组数据，输出一行，包含一个整数，为在给定的字符迷阵中找到给定的单词的合法方案数。

输入例子1:

3
10 10
AAAAAADROW
WORDBBBBBB
OCCCWCCCCC
RFFFFOFFFF
DHHHHHRHHH
ZWZVVVVDID
ZOZVXXDKIR
ZRZVXRXKIO
ZDZVOXXKIW
ZZZWXXXKIK
WORD
3 3
AAA
AAA
AAA
AA
5 8
WORDSWOR
ORDSWORD
RDSWORDS
DSWORDSW
SWORDSWO
SWORD

输出例子1:

4
16
5

代码实现

import java.io.FileNotFoundException;
import java.util.Scanner;

/**
 * @author Created By Frank
 * @date 2018-08-08 8:34
 */
public class Main3 {
    public static void main(String[] args) throws FileNotFoundException {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        in.nextLine();

        for (int s = 0; s < t; s++) {

            int res = 0;
            int m = in.nextInt();
            int n = in.nextInt();
            char[][] board = new char[m][n];
            in.nextLine();

            for (int i = 0; i < m; i++) {
                String linestr = in.nextLine();
                char[] arr = linestr.toCharArray();
                for (int j = 0; j < n; j++) {
                    board[i][j] = arr[j];
                }
            }
            String word = in.nextLine();


            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    if (scanRight(board, i, j, word))
                        res++;
                    if (scanDown(board, i, j, word))
                        res++;
                    if (scanRD(board, i, j, word))
                        res++;
                }
            }
            System.out.println(res);
        }
    }

    private static boolean scanRD(char[][] board, int x, int y, String word) {
        int len = word.length();
        if (!inArea(x + len - 1, y + len - 1, board)) {
            return false;
        }
        StringBuffer sbf = new StringBuffer();
        for (int xs = x, ys = y; xs < x + len; xs++, ys++) {
            sbf.append(board[xs][ys]);
        }
        return word.equals(sbf.toString());
    }

    private static boolean scanDown(char[][] board, int x, int y, String word) {
        int len = word.length();
        if (!inArea(x + len - 1, y, board)) {
            return false;
        }
        StringBuffer sbf = new StringBuffer();
        for (int index = x; index < x + len; index++) {
            sbf.append(board[index][y]);
        }
        return word.equals(sbf.toString());
    }


    private static boolean scanRight(char[][] board, int x, int y, String word) {
        int len = word.length();
        if (!inArea(x, y + len - 1, board)) {
            return false;
        }

        StringBuffer sbf = new StringBuffer();
        for (int index = y; index < y + len; index++) {
            sbf.append(board[x][index]);
        }
        return word.equals(sbf.toString());
    }

    private static boolean inArea(int x, int y, char[][] board) {
        int m = board.length;
        int n = board[0].length;
        return x >= 0 && x < m && y >= 0 && y < n;
    }
}