头条笔试 20190111

最新推荐文章于 2021-03-26 06:33:38 发布

程序员庄庄

最新推荐文章于 2021-03-26 06:33:38 发布

阅读量152

点赞数

分类专栏：实习准备

未经授权，不允许转载

本文链接：https://blog.csdn.net/weixin_37631780/article/details/86367817

版权

实习准备专栏收录该内容

0 篇文章 0 订阅

订阅专栏

头条笔试 20190111

笔试时长1小时，1道easy,2道middle 平台为newcoder 不允许自带的IDE

第一题 easy

输入k个单词，输出在字典里能找到的单词

字典的格式是二维数组，每个数组里有一个字母，单词的字母之间必须相邻,并且每个字符只能用一次

输入单词数 k 字典的行列为m,n

输入单词，字典

例：

3 5 4

help let zoo

h	e	a	b	L
a	l	p	t	e
b	f	g	d	d
c	e	d	b	m

输出

help

let

解题思路

该题很简单，递归即可

如果当前的字符相同，则比较下一个位置的左右下位置是否存在相同的字符，直到所有字符都能找到，或者所有相邻位置都找不到

import java.util.Scanner;

/**
 * @author hxh
 * @date 2019-01-12 13:56
 */
public class BD1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int k = scanner.nextInt();
        int m = scanner.nextInt();
        int n = scanner.nextInt();
        String[] words = new String[k];
        for (int i = 0; i < k; i++) {
            words[i] = scanner.next();
        }
        char[][] chars = new char[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                chars[i][j] = scanner.next().charAt(0);
            }
        }
        for (int i = 0; i < k; i++) {
            String str = words[i];
            boolean exist = false;
            for (int j = 0; j < m; j++) {
                if (exist) {
                    break;
                }
                for (int z = 0; z < n; z++) {
                    if (search(j, z, str, 0, chars)) {
                        exist = true;
                        System.out.println(str);
                        break;
                    }
                }
            }
        }
    }

    public static boolean search(int i, int j, String str, int index, char[][] chars) {
        if (index >= str.length()) {
            //字符串所有的字符都已经在字典里找到，返回true表示已经找到
            return true;
        }
        //检测边界
        boolean valid = i >= 0 && j >= 0 && i < chars.length && j < chars[0].length;
        if (!valid) {
            //越界
            return false;
        }
        if (chars[i][j] == str.charAt(index)) {
            //当前字符一样
            //依次检查左 右 上 下 的位置是否和字典的下一位相同
            //当前位置已经被占用
            char temp = chars[i][j];
            boolean exist = search(i, j - 1, str, index + 1, chars) ||
                    search(i, j + 1, str, index + 1, chars) ||
                    search(i + 1, j, str, index + 1, chars) ||
                    search(i - 1, j, str, index + 1, chars);
            chars[i][j] = temp;

            return exist;
        }
        return false;

    }
}

第二题 middle

一圆上的十等分点，依次标上0，1，2，3，4，5，6，7，8，9。每一步可以顺时针也可以逆时针走一个点，问经过n步回到原点的路径有多少种。输出结果对1000000007的余数

例如 n = 2时，有2种: 0-1-0 和 0-9-0

这题还是很有挑战性的，一开始是想会不会像斐波那契数列一样通过递推，毕竟需要取余。然而没有找到递推式子。就没有做出来放弃了，第二天和室友吃饭时他提到0，1数组，也没有太明白。回到寝室后躺在床上突然一惊，如果是-1，1的数组的话，则他们的和的绝对值应该是10的倍数或者是0（回到圆点）然后心里面大概明白其实是个有重复元素的全排列问题。

首先全排列的公式为n里面有x个元素是重复的

$A_{n}^{x} = \frac{n!}{x!} $

假设1的数量为x,2的数量为y则x和y的关系满足
x+y=n and |x-y| mod 10=0

这时候问题貌似就很简单了，只需要计算出所有满足条件的x,y相加然后取余就可以了。但是既然让取余说明数字会比较大，会出现溢出问题，乘法和加法都很好解决

有公式 (x+y)%n == (x%n+y%n)%n和x*y %n = ((x%n)*(y%n)%n);

但是计算公式里涉及到除法，就并没有相应的公式了。迅速百度根据相关数学知识的得到逆元公式

链接： ?链接

整体思想就是化除为乘，a / b mod n = a * b1 mod n b1就是b的逆元

然后就可以找到所有的x,y的排列对1000000007的余数了

代码如下

import java.util.Scanner;

/**
 * @author hxh
 * @date 2019-01-12 13:56
 */
public class BD2 {
    private static final long MOD = 1000000007L;
    public static long[] inv = new long[10000];

    public static void init() {
        inv[1] = 1L;
        for (int i = 2; i < inv.length; i++) {
            //费马小定理 除法运算的取模 逆元
            inv[i] = inv[(int) (MOD % i)] * (MOD - MOD / i) % MOD;
        }
    }

    public static void main(String[] args) {
        init();
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        long answer = function(n);

        System.out.println(answer);
    }

    public static long function(int n) {
        if (n % 2 != 0) {
            return 0;
        }
        long answer = 0;
        long fn = 1;
        for (int i = 0; i < n; i++) {
            //乘法的取模运算
            fn = (fn % MOD) * ((i + 1) % MOD) % MOD;
        }
        // 当成 -1 和 1看待 x + y的和的绝对值是10的倍数 故是有重复元素的全排列 结果为 n! / (a! * b!);
        for (int i = 0; i < n / 10 + 1; i++) {
            long f = fn;
            long x = (n - i * 10) / 2;
            long y = (n + i * 10) / 2;
            for (int j = 1; j <= x; j++) {
                f = (f * inv[j]) % MOD;
            }
            for (int j = 1; j <= y; j++) {
                f = (f * inv[j]) % MOD;
            }
            if (i != 0) {
                f = (f * 2) % MOD;
            }
            answer = (answer % MOD + f % MOD) % MOD;
        }
        return answer;
    }
}
/**
 * 题目详情
 * 一个圆上一次有0到9共十个点，9和0联通，问经过n步回到0点的路径有多少种
 * 示例 n=4 则有6种
 * n = 2 有1种
 */

第三题 middle

手中有一副牌，根据以下规则放到桌子上面

把手中的第一张牌放到桌子上
把手中剩余的第一张牌放到最后
重复1、2直到所有牌已经放完

现已经知道桌子上牌的顺序，求手中牌的顺序

输入几轮牌

牌的顺序

例题

输入：

1

4 2 3 1

输出

1 2 3 4

解题思路：

刚开始想的是模拟一下手中牌的放置过程，然后根据放置的结果得到桌子上的每张牌的初始位置。即刚开始用一个链表记录索引，值依次为1，2，3…n然后根据用另一个链表当作桌子，记录牌的放置。最终后一个链表的节点的值表示了该节点之前的位置。然而没有实现。同样是今天在床上，突然有了思路。

假设牌为

1，2，3，4，5，6，7，8，9，10，11，12

注意到

第一次拿到牌为 1，3，5，7，9，11然后牌的顺序为2，4，6，8，10

再一次的顺序为2，6，10剩下的顺序为4，8

然后就4，8

即牌的依次顺序为1 3 5 7 9 11 2 6 10 4 8

拿牌的间隔由2到4再到8

故有了如下代码

import java.util.Scanner;

/**
 * @author hxh
 * @date 2019-01-12 13:56
 */
public class BD3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n =Integer.parseInt(scanner.nextLine());
        for (int i = 0; i < n; i++) {
            String[] strs = scanner.nextLine().split(" ");
            String[] origin = new String[strs.length];
            int count = 0;
            int index = 0;
            int step = 2;
            while (count != origin.length) {
                origin[index] = strs[strs.length - count - 1];
                index += step;
                count++;
                if (index >= origin.length) {
                    index = step - 1;
                    step *= 2;
                }
            }
            System.out.println();
            for (int j = 0; j < origin.length; j++) {
                System.out.print(origin[j] + " ");
            }
            System.out.println();
        }
    }
}
/**
 * 手中一副牌 做如下操作
 * 1. 将手中的第一张牌放到桌面上
 * 2. 将剩余手中的第一张牌放在最后
 * 3. 重复上述过程
 * 4. 现在已经知道在桌面上的牌的顺序 求手中牌的初始顺序
 */
// 分析 其实就是间隔取元素，取完后再从剩下的空当中间隔取元素
// 0 1 2 3 4 5 6 7 8 9 10
// 0   2   4   6   8   10
//   1   3   5   7   9
//   1       5       9
//       3       7
//               7