春招校招总结

最新推荐文章于 2024-07-17 21:03:28 发布

wanhf11

最新推荐文章于 2024-07-17 21:03:28 发布

阅读量666

点赞数

分类专栏：笔试面试总结

本文链接：https://blog.csdn.net/qq_17612199/article/details/53366880

版权

笔试面试总结专栏收录该内容

12 篇文章 0 订阅

订阅专栏

滴滴

熟悉线程池么？线程池是怎么对线程的状态进行监控和控制的？
说一下类加载机制以及他们加载了什么类？
从文件读入数据的过程是什么样子的？缓冲区是在用户态还是内核态？

总结：
进程访问等级：
内核态：CPU可以访问内存所有数据, 包括外围设备, 例如硬盘, 网卡. CPU也可以将自己从一个程序切换到另一个程序
用户态：只能受限的访问内存, 且不允许访问外围设备. 占用CPU的能力被剥夺, CPU资源可以被其他程序获取

读取文件的工作流程如下（用户态程序切换到内核态, 但是不能控制在内核态中执行的指令）:
1.用户态程序将一些数据值放在寄存器中, 或者使用参数创建一个堆栈(stack frame), 以此表明需要操作系统提供的服务.
2.用户态程序执行陷阱指令（系统调用）
3.CPU切换到内核态, 并跳到位于内存指定位置的指令, 这些指令是操作系统的一部分, 他们具有内存保护, 不可被用户态程序访问
4.这些指令称之为陷阱(trap)或者系统调用处理器(system call handler). 他们会读取程序放入内存的数据参数, 并执行程序请求的服务
5.系统调用完成后, 操作系统会重置CPU为用户态并返回系统调用的结果

百度

项目介绍
介绍一下linux命令
线程进程的区别
线程和进程共享什么资源
线程共享的环境包括：进程代码段、进程的公有数据(利用这些共享的数据，线程很容易的实现相互之间的通讯)、进程打开的6. 文件描述符、信号的处理器、进程的当前目录和进程用户ID与进程组ID。
设计模式，单例双重检查其实并发有问题
大数加法（+-号）
怎么才能最小次数使一个字符串变成回文的字符串

    public class Main {

    /**
     * 两个大数相加
     *
     * @param a
     * @param b
     * @return
     * @throws Exception
     */
    private static String Add(String a, String b) throws Exception {
        // 处理空
        if (a == null || b == null || "".equals(a) || "".equals(b)) {
            throw new Exception("number is null.");
        }
        // 处理负号
        boolean aIsNegative = false, bIsNegative = false;
        if (a.startsWith("-")) {
            aIsNegative = true;
            a = a.substring(1);
        }
        if (b.startsWith("-")) {
            bIsNegative = true;
            b = b.substring(1);
        }
        // 处理正号
        if (a.startsWith("+")) a = a.substring(1);
        if (b.startsWith("+")) b = b.substring(1);
        if (!check(a) || !check(b)) {
            throw new Exception("number is error.");
        }
        if (aIsNegative == bIsNegative) {
            String ans = AddCore(a, b);
            if (aIsNegative) {
                return "0".equals(ans) ? "0" : "-" + ans;
            } else {
                return ans;
            }
        } else {
            if (!(a.length() > b.length() || a.length() == b.length() && a.compareTo(b) >= 0)) {
                // swap
                String stmp = a;
                a = b;
                b = stmp;
                boolean btmp = aIsNegative;
                aIsNegative = bIsNegative;
                bIsNegative = btmp;
            }
            String ans = SubtractCore(a, b);
            if (aIsNegative && !bIsNegative) {
                // -2+1
                return "0".equals(ans) ? "0" : "-" + ans;
            } else {
                // 2+-1
                return ans;
            }
        }
    }

    /**
     * 正数加法
     *
     * @param a
     * @param b
     * @return
     */
    private static String AddCore(String a, String b) throws Exception {
        if (a == null || b == null || "".equals(a) || "".equals(b)) {
            throw new Exception("number is null.");
        }
        int maxx = Math.max(a.length(), b.length());
        StringBuilder asb = new StringBuilder(a);
        for (int i = a.length(); i < maxx; i++) {
            asb.insert(0, '0');
        }
        a = asb.toString();
        StringBuilder bsb = new StringBuilder(b);
        for (int i = b.length(); i < maxx; i++) {
            bsb.insert(0, '0');
        }
        b = bsb.toString();
        StringBuilder ans = new StringBuilder();
        int e = 0;
        for (int i = maxx - 1; i >= 0; i--) {
            e = e + (a.charAt(i) - '0') + (b.charAt(i) - '0');
            ans.insert(0, e % 10);
            e /= 10;
        }
        while (e != 0) {
            ans.insert(0, e % 10);
            e /= 10;
        }
        String c = handlePrefixZero(ans.toString());
        return "".equals(c) || c.length() == 0 ? "0" : c;
    }

    /**
     * 参数为a>b
     * 正数减法，返回结果为大的数减小的数
     *
     * @param a
     * @param b
     * @return
     */
    private static String SubtractCore(String a, String b) throws Exception {
        if (a == null || b == null || "".equals(a) || "".equals(b)) {
            throw new Exception("number is null.");
        }
        int maxx = Math.max(a.length(), b.length());
        StringBuilder asb = new StringBuilder(a);
        for (int i = a.length(); i < maxx; i++) {
            asb.insert(0, '0');
        }
        a = asb.toString();
        StringBuilder bsb = new StringBuilder(b);
        for (int i = b.length(); i < maxx; i++) {
            bsb.insert(0, '0');
        }
        b = bsb.toString();
        StringBuilder ans = new StringBuilder();
        int e = 0;
        for (int i = maxx - 1; i >= 0; i--) {
            e = (e + (a.charAt(i) - '0')) - (b.charAt(i) - '0');
            if (e < 0) {
                ans.insert(0, e + 10);
                e = -1;
            } else {
                ans.insert(0, e);
                e = 0;
            }
        }
        String c = handlePrefixZero(ans.toString());
        return c;
    }

    /**
     * 正数乘法
     *
     * @param a
     * @param b
     * @return
     */
    private static String MultCore(String a, int b) throws Exception {
        if (a == null || "".equals(a)) {
            throw new Exception("number is null.");
        }
        if (b == 0) return "0";
        StringBuilder ans = new StringBuilder();
        int e = 0;
        for (int i = a.length() - 1; i >= 0; i--) {
            e = e + (a.charAt(i) - '0') * b;
            ans.insert(0, e % 10);
            e /= 10;
        }
        while (e != 0) {
            ans.insert(0, e % 10);
            e /= 10;
        }
        String c = handlePrefixZero(ans.toString());
        return "".equals(c) || c.length() == 0 ? "0" : c;
    }

    /**
     * 处理前缀0
     *
     * @param c
     * @return
     */
    private static String handlePrefixZero(String c) {
        if (c.startsWith("0")) {
            int pos = 0;
            while (pos < c.length() && c.charAt(pos) == '0') {
                pos++;
            }
            c = c.substring(Math.min(pos, c.length() - 1));
        }
        return c;
    }

    /**
     * 判断是否为数字
     *
     * @param s
     * @return
     */
    private static boolean check(String s) {
        if (s == null || "".equals(s)) return false;
        for (int i = 0, len = s.length(); i < len; i++) {
            char ch = s.charAt(i);
            if (ch >= '0' && ch <= '9') continue;
            else return false;
        }
        return true;
    }

    /**
     * 大整数乘法
     *
     * @param a
     * @param b
     * @return
     */
    private static String Mult(String a, String b) throws Exception {
        // 处理空
        if (a == null || b == null || "".equals(a) || "".equals(b)) {
            throw new Exception("number is null.");
        }
        // 处理负号
        boolean aIsNegative = false, bIsNegative = false;
        if (a.startsWith("-")) {
            aIsNegative = true;
            a = a.substring(1);
        }
        if (b.startsWith("-")) {
            bIsNegative = true;
            b = b.substring(1);
        }
        // 处理正号
        if (a.startsWith("+")) a = a.substring(1);
        if (b.startsWith("+")) b = b.substring(1);
        if (!check(a) || !check(b)) {
            throw new Exception("number is error.");
        }
        if (!(a.length() > b.length() || a.length() == b.length() && a.compareTo(b) >= 0)) {
            // swap
            String stmp = a;
            a = b;
            b = stmp;
            boolean btmp = aIsNegative;
            aIsNegative = bIsNegative;
            bIsNegative = btmp;
        }
        String ans = "0";
        for (int i = b.length() - 1, j = 0; i >= 0; i--, j++) {
            StringBuilder tmp = new StringBuilder(MultCore(a, b.charAt(i) - '0'));
            for (int k = 0; k < j; k++) {
                tmp.append("0");
            }
            ans = Add(ans, tmp.toString());
        }
        if (aIsNegative == bIsNegative) return ans;
        else return "-" + ans;
    }

    /**
     * 大整数减法
     *
     * @param a
     * @param b
     * @return
     */
    private static String Subtract(String a, String b) throws Exception {
        // 处理空
        if (a == null || b == null || "".equals(a) || "".equals(b)) {
            throw new Exception("number is null.");
        }
        // 处理负号
        boolean aIsNegative = false, bIsNegative = false;
        if (a.startsWith("-")) {
            aIsNegative = true;
            a = a.substring(1);
        }
        if (b.startsWith("-")) {
            bIsNegative = true;
            b = b.substring(1);
        }
        // 处理正号
        if (a.startsWith("+")) a = a.substring(1);
        if (b.startsWith("+")) b = b.substring(1);
        if (!check(a) || !check(b)) {
            throw new Exception("number is error.");
        }
        if (!(a.length() > b.length() || a.length() == b.length() && a.compareTo(b) >= 0)) {
            // swap
            String stmp = a;
            a = b;
            b = stmp;
            boolean btmp = aIsNegative;
            aIsNegative = bIsNegative;
            bIsNegative = btmp;
        }
        if (aIsNegative && bIsNegative) {
            // 2-1
            return SubtractCore(a, b);
        } else if (aIsNegative && !bIsNegative) {
            // 2-(-1)=2+1
            return AddCore(a, b);
        } else if (!aIsNegative && bIsNegative) {
            // -2-1 = -(2+1)
            String ans = AddCore(a, b);
            return "0".equals(ans) ? "0" : "-" + ans;
        } else {
            //-2-(-1)=-2+1=-(2-1)
            String ans = SubtractCore(a, b);
            return "0".equals(ans) ? "0" : "-" + ans;
        }
    }

    public static void main(String[] args) throws Exception {
        System.out.println(111*(-12));
        System.out.println(Mult("111", "-12"));
    }

}

import java.util.Scanner;

public class Main {

    private static int dp[][] = null;

    private static int dp(char chs[], int start, int end) {
        if (chs == null || chs.length == 0
                || start >= chs.length || end >= chs.length
                || start >= end) {
            return 0;
        }
        if (chs[start] == chs[end]) {
            return dp[start][end] = dp(chs, start + 1, end - 1);
        } else {
            int leftPop = -1, rightPop = -1;
            if (dp[start + 1][end] == -1) dp[start + 1][end] = dp(chs, start + 1, end);
            if (dp[start][end - 1] == -1) dp[start][end - 1] = dp(chs, start, end - 1);
            leftPop = dp[start + 1][end];
            rightPop = dp[start][end - 1];
            return dp[start][end] = Math.min(leftPop, rightPop) + 1;
        }
    }

    private static void init(int dp[][]) {
        for (int i = 0, len = dp.length; i < len; i++) {
            for (int j = i; j < dp[0].length; j++) {
                dp[i][j] = dp[j][i] = -1;
            }
        }
    }

    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        while (cin.hasNext()) {
            int n = cin.nextInt();
            for (int i = 0; i < n; i++) {
                String s = cin.next();
                dp = new int[s.length()][s.length()];
                init(dp);
                System.out.println(dp(s.toCharArray(), 0, s.length() - 1));
            }

        }
    }

}

搜狗笔试

题目描述：
定义两个大于2的偶数之间的距离，为这两个数之间质数的个数。从小到大输入n个大于2的偶数，输出所有数两两之间距离的总和（应该有n*(n-1)/2个距离，输出总和就好)。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    private static final int maxn = 10000005;
    private static boolean prime[] = new boolean[maxn];
    private static int dp[] = new int[maxn];

    private static void init() {
        for (int i = 0; i < maxn; i++) {
            prime[i] = true;
        }
        for (int i = 2; i < maxn; i++) {
            if (prime[i]) {
                for (int j = i * 2; j < maxn; j += i)//是倍数的都不是素数
                    prime[j] = false;
            }
        }
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i < maxn; i++) {
            dp[i] = dp[i - 1] + (prime[i] ? 1 : 0);
        }
    }

    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        init();
        while (cin.hasNext()) {
            int n = cin.nextInt();
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = cin.nextInt();
            }
            Arrays.sort(a);
            long ans = 0;
            for (int i = 1; i < n; i++) {
            // 针对第i条线段，左边有i个点，右边有n-i个点
                ans += (dp[a[i]] - dp[a[i - 1]]) * (i * (n - i));
            }
            System.out.println(ans);
        }
    }
}

网易笔试

暗黑的字符串

一个只包含’A’、’B’和’C’的字符串，如果存在某一段长度为3的连续子串中恰好’A’、’B’和’C’各有一个，那么这个字符串就是纯净的，否则这个字符串就是暗黑的。例如：
BAACAACCBAAA 连续子串”CBA”中包含了’A’,’B’,’C’各一个，所以是纯净的字符串
AABBCCAABB 不存在一个长度为3的连续子串包含’A’,’B’,’C’,所以是暗黑的字符串
你的任务就是计算出长度为n的字符串(只包含’A’、’B’和’C’)，有多少个是暗黑的字符串。

import java.util.Scanner;

public class Main {

private static final int MAXN = 35;
private static long dp[] = new long[MAXN];

private static void init() {
    dp[1] = 3;
    dp[2] = 9;
    for (int i = 3; i < MAXN; i++) {
        dp[i] = dp[i - 1] * 2 + dp[i - 2];
    }
}

public static void main(String[] args) {
    Scanner cin = new Scanner(System.in);
    init();
    while (cin.hasNext()) {
        int n = cin.nextInt();
        System.out.println(dp[n]);
    }
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
回文序列

如果一个数字序列逆置之后跟原序列是一样的就称这样的数字序列为回文序列。例如：
{1, 2, 1}, {15, 78, 78, 15} , {112} 是回文序列,
{1, 2, 2}, {15, 78, 87, 51} ,{112, 2, 11} 不是回文序列。
现在给出一个数字序列，允许使用一种转换操作：
选择任意两个相邻的数，然后从序列移除这两个数，并用这两个数字的和插入到这两个数之前的位置(只插入一个和)。
现在对于所给序列要求出最少需要多少次操作可以将其变成回文import java.util.Scanner;

public class Main {

public static void main(String[] args) {
    Scanner cin = new Scanner(System.in);
    while (cin.hasNext()) {
        int n = cin.nextInt();
        int array[] = new int[n];
        for (int i = 0; i < n; i++) {
            array[i] = cin.nextInt();
        }
        int left = 0, right = n - 1;
        int ans = 0;
        while (left < right) {
            if (array[left] < array[right]) {
                array[left + 1] = array[left] + array[left + 1];
                left++;
                ans++;
            } else if (array[left] > array[right]) {
                array[right - 1] = array[right] + array[right - 1];
                right--;
                ans++;
            } else {
                left++;
                right--;
            }
        }
        System.out.println(ans);
    }
}

}

优雅的点

小易有一个圆心在坐标原点的圆，小易知道圆的半径的平方。小易认为在圆上的点而且横纵坐标都是整数的点是优雅的，小易现在想寻找一个算法计算出优雅的点的个数，请你来帮帮他。
例如：半径的平方如果为25
优雅的点就有：(+/-3, +/-4), (+/-4, +/-3), (0, +/-5) (+/-5, 0)，一共12个点。

import java.util.Scanner;

public class main {

public static void main(String[] args) {
    Scanner cin = new Scanner(System.in);
    while (cin.hasNext()) {
        int r2 = cin.nextInt();
        double r = Math.sqrt(r2 * 1.0);
        int maxx = (int) r;
        int ans = 0;
        for (int x = 1; x <= maxx; x++) {
            double y2 = r2 - x * x;
            double y = Math.sqrt(y2);
            ans += (y == (int) y ? 1 : 0);
        }
        // 四个象限+xy正负轴4个点
        System.out.println(ans * 4);
    }
}

}

百度笔试

HTTP会话的四个过程
1. 建立tcp连接
2. 发出请求文档
3. 发出响应文档
4. 释放tcp连接

subnet 166.173.197.131 netmask 255.255.255.192{
range 166.173.197.10 166.173.197.107;
default-lease-time 600;
max-lease-time 7200;
}

subnet 设置一个子网 166.173.197.131/24
range 可分配的IP地址范围上 166.173.197.10 ~ 166.173.197.107
default-lease-time 默认租约时间
max-lease-time 最大租约时间

如需在表中添加列，请使用下列语法:
ALTER TABLE table_name
ADD column_name datatype
要删除表中的列，请使用下列语法：
ALTER TABLE table_name
DROP COLUMN（可省略） column_name

在一棵度为3的树中，度为3的节点个数为2，度为2的节点个数为1，则度为0的节点个数为（）
n(节点数)=n0+n1+n2(1)+n3(2)
n=n0*0+n1*1+n2*2+n3*3
n0=6

京东笔试

集中式总线：
集中式串行链接,查询所有部件都用一条”总线请求”线
集中式定时查询,所有部件共用一条”总线忙”线
集中式定时查询,所有部件都用一条”总线请求”线

一个GFS集群由一个master和大量chunkserver构成

浮点数尾数基值rm=8,尾数长度为6,则可表示规格化正尾数的个数为多少个()
浮点数尾数基值rm=8,尾数长度为6，规格化正尾数时，前三位（2^3）不能全为零。故2^6-2^3=56

批处理系统主要指多道批处理系统，由于多道程序能交替使用CPU，提高了CPU及其他系统资源的利用率，同时也提高了系统的效率。多道批处理系统的缺点是延长了作业的周转时间，用户不能进行直接干预，缺少交互性，不利于程序的开发与调试。

关于主对角线（从左上角到右下角）对称的矩阵为对称矩阵；如果一个矩阵中的各个元素取值为0或1，那么该矩阵为01矩阵，求大小为N*N的01对称矩阵的个数？（）
这里写图片描述

设一课完全二叉树共有999个结点，则在该二叉树中的叶节点个数是？
因为对于m层的满二叉树，其节点为2^m-1
所以第10层的节点数为(2^10-1)-(2^9-1)=512，第9层的节点数为(2^9-1)-(2^8-1)=256
因为这个是完全的二叉树，所以第十层真正的节点数为999-2^9+1=488，也就是说第9层有孩子节点的节点数为244，那么没有孩子节点的个数为256-244=12
所以叶子结点的个数=第10层的节点+第9层没有孩子的叶子结点=488+12=500

蘑菇街笔试

Mysql触发程序不能使用以显式或隐式方式开始或结束事务的语句，如START TRANSACTION、COMMIT或ROLLBACK

（ 1 ）软连接可以跨文件系统，硬连接不可以
（ 2 ）硬连接不管有多少个，都指向的是同一个 I 节点，会把结点连接数增加，只要结点的连接数不是 0 ，文件就一直存在不管你删除的是源文件还是连接的文件。只要有一个存在文件就存在。当你修改源文件或者连接文件任何一个的时候，其他的文件都会做同步的修改。软链接不直接使用 i 节点号作为文件指针 , 而是使用文件路径名作为指针。所以删除连接文件对源文件无影响，但是删除源文件，连接文件就会找不到要指向的文件。软链接有自己的 i 节点 , 并在磁盘上有一小片空间存放路径名。
（ 3 ）软连接可以对一个不存在的文件名进行连接。
（ 4 ）软连接可以对目录进行连接。

设顺序循环队列Q[0: M-1]的头指针和尾指针分别为F和R.头指针F总是指向队头元素的前一位置.尾指针R总是指向队尾元素的当前位置.则该循环队列中的元素个数为（（R-F+M)%M）