23年12月字节一面面试回顾

一、12月15日一面

1.自我介绍

（1）介绍自己过往的工作经历， balabla...

（2）面试官询问了我目前的工作状态以及在上家公司的级别，离职的原因等等

2.项目介绍以及项目相关问题

面试官让我随机从简历上写的项目挑一个来介绍，介绍完成后基于项目的情况挑选了一些问题。

（1）问题1： 你们项目用的存储DB是什么？为什么用选择这种DB？

（2）问题2: 既然你们项目采用了读写分离的微服务架构，请问你们的数据接入服务是如何保证数据写入接口调用的幂等性，

你们的request_id生成规则是怎样的？

（3）问题3: 你们项目的整个技术框架是怎样的？包含了哪几层，每一层是怎样交互的？

（4）问题4: 听你提到你们项目使用了spring-cloud gateway这个开源框架作为项目对外网关的基础框架，为什么选择了这个组件来搭建网关，而不是zuul？

（5）问题5: 请你说一说spring-cloud gateway的大概实现流程是怎样的，调用网关的请求会经过哪些处理流程？

（6）问题6: 如果让你对你们这个项目优化，你觉得这个项目的查询适合用图数据库存储还是关系型数据库存储？

（7）问题7: 看你简历上写了使用过ClickHouse, ClickHouse为啥可以查询那么快，底层的实现是怎样的？ClickHouse跟Mysql有什么不同？

3. 算法题

（1）简单逻辑题

问题描述：有36辆赛车和6条跑道，没有计时器的前提下，最少用几次比赛可以筛选出最快的3辆赛车？

(2) 算法编码题

问题描述：

给你一个大小为 m x n 的二进制矩阵 grid。

岛屿 是由一些相邻的 0 (代表土地) 构成的组合，这里的「相邻」要求0 必须在 水平或者竖直、对角线的八个方向上 相邻。你可以假设 grid 的四个边缘都被 1或2（代表水）包围着。

岛屿的面积是岛上值为 0的单元格的数目。

计算并返回 grid 中各个岛屿面积的列表。要求各岛屿的面积按照升序排序

public class Main {
    boolean[][] visited = new boolean[4][4];
    int[][] directions = new int[][] {
            {1, 0}, {-1, 0}, {0, 1}, {0, -1}, {1, 1}, {-1, -1}, {1, -1}, {-1, 1}
    };

    public static void main(String[] args) {
        int[][] grid = new int[][]{{0, 2, 1, 0}, {0, 1, 0, 1}, {1, 1, 0, 1}, {0, 1, 0, 1}};
        Main main = new Main();
        final List<Integer> res = main.findPoolSizes(grid);
        for (int item : res) {
            System.out.println(item);
        }
    }

    public List<Integer> findPoolSizes(int[][] grid) {
        if (grid == null || grid.length == 0) {
            return Collections.EMPTY_LIST;
        }

        int m = grid.length;
        int n = grid[0].length;

        List<Integer> res = new ArrayList<>();

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0 && !visited[i][j]) {
                    res.add(dfs(grid, m, n, i, j));
                }
            }
        }
        Collections.sort(res);
        return res;
    }

    private boolean judge(int m, int n, int row, int col) {
        if (row < 0 || row >= m || col < 0 || col >= n) {
            return false;
        }

        if (visited[row][col]) {
            return false;
        }

        return true;
    }

    private int dfs(int[][] grid, int m, int n, int row, int col) {
        if (!judge(m, n, row, col)) {
            return 0;
        }


        if (grid[row][col] != 0) {
            return 0;
        }

        visited[row][col] = true;

        int poolSize = 1;
        for (int i = 0; i < directions.length; i++) {
                final int nextRow = row + directions[i][0];
                final int nextCol = col + directions[i][1];
                poolSize += dfs(grid, m, n, nextRow, nextCol);
        }

        return poolSize;
    }
}