字节跳动2018.10.8笔试 地震逃生选择

最新推荐文章于 2021-03-26 20:35:20 发布
最新推荐文章于 2021-03-26 20:35:20 发布
阅读量411 收藏
点赞数
分类专栏： 笔试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anlian523/article/details/82981293
版权

文章目录

题目描述

在这里插入图片描述
输入-版本一：
3
0,-1,1,0
0,0,0,-1
0,-1,0,-1
1,-1,0,0
输入-版本二：
3
0,-1,0,0
0,1,1,-1
0,-1,0,-1
0,-1,0,0

深度遍历

原来的1和-1都会变成0，原来的0有两种情况，如果这个0与某个1即出口的距离<=k，那么这个0还是0，否则为1。
建立一个同样的大小的二维数组second（每个元素初值为0），然后对每个1进行最大深度为k的深度遍历，遇到1或者-1就忽略，遇到0就把second里面的对应位置second[row][column]赋值为1。
需要注意每次深度遍历都是独立的，不能说是A开始遍历走过的点，然后B开始遍历就不能A走过的这些点。
所有深度遍历结束后，second[row][column]为1说明这个元素与某个1之间的距离<=k，second[row][column]为0说明这个元素与每个1之间的距离都>k。

k  = eval(input())
li = []#原数组
exitLi = []#记录出口

def readexit(index,exitlist):
    #读取出口
    global exitLi
    if 1 in exitlist:
        for i in range(len(exitlist)):#一排里面可能有几个1
            if exitlist[i] == 1:
                exitLi.append([index, i])

#先读取第一行
temp = list(map(int,input().split(',')))
readexit(0,temp)
li.append(temp)
n = len(temp)
#新建一个矩阵
second = [[0 for i in range(n)] for j in range(n)]
for i in range(1, len(temp)):
    temp = list(map(int,input().split(',')))
    readexit(i,temp)
    li.append(temp)
#深度遍历每个起点
def recur(row,column,step):
    if step >= k:
        #大于三就返回
        return 
    if 0 <= column+1 <=n-1:
        if (li[row][column+1] != -1) and (li[row][column+1] != 1):
            #忽略墙和起点
            second[row][column+1] = 1
            recur(row,column+1,step+1)
    if 0 <= column-1 <=n-1:
        if (li[row][column-1] != -1) and (li[row][column-1] != 1):
            #忽略墙和起点
            second[row][column-1] = 1
            recur(row,column-1,step+1)
    if 0 <= row+1 <=n-1:
        if (li[row+1][column] != -1) and (li[row+1][column] != 1):
            #忽略墙和起点
            second[row+1][column] = 1
            recur(row+1,column,step+1)            
    if 0 <= row-1 <=n-1:
        if (li[row-1][column] != -1) and (li[row-1][column] != 1):
            #忽略墙和起点
            second[row-1][column] = 1
            recur(row-1,column,step+1)
for i in exitLi:
    row = i[0]
    column = i[1]
    recur(row,column,0)

#按照second里面的1进行赋值
for i in range(n):
    for j in range(n):
        if (li[i][j] == 1) or (li[i][j] == -1):
            li[i][j] = '0'
        elif li[i][j] == 0:
            #两种情况
            if second[i][j] == 1:
                li[i][j] = '0'
            else:
                li[i][j] = '1'

for i in range(n):
    print(','.join(li[i]))

通过率为75%。提示超时。这个因为当1与1之间相隔比较近，就会有许多点被重复的递归到，下一章讲一下优化方法，但没有平台让我验证优化后的代码通过率能否达到100%。
最大的问题是，在每次的深度递归中，不仅会重复遍历点，还会往回遍历点。
输入为如下，在递归函数里增加语句print(row,column)，会发现本章代码有大量重复遍历：
3
0,0,0,0,0
0,0,0,0,0
0,0,1,0,0
0,0,0,0,0
0,0,0,0,0
虽然大量重复遍历，但输出正确：
在这里插入图片描述
second数组元素其实就是代表该元素有没有被遍历过即相当于visited，但这里的代码也不能设置为visited为1即访问过就停止深度遍历，使用如上输入，递归函数修改为如下，即visited为1就不再递归。

def recur(row,column,step):
    print(row,column)
    if step >= k:
        #大于三就返回
        return 
    if 0 <= column+1 <=n-1:
        if (li[row][column+1] != -1) and (li[row][column+1] != 1):
            if second[row][column+1] == 0:
                #忽略墙和起点
                second[row][column+1] = 1
                recur(row,column+1,step+1)
    if 0 <= column-1 <=n-1:
        if (li[row][column-1] != -1) and (li[row][column-1] != 1):
            if second[row][column-1] == 0:
                #忽略墙和起点
                second[row][column-1] = 1
                recur(row,column-1,step+1)
    if 0 <= row+1 <=n-1:
        if (li[row+1][column] != -1) and (li[row+1][column] != 1):
            if second[row+1][column] == 0:
                #忽略墙和起点
                second[row+1][column] = 1
                recur(row+1,column,step+1)            
    if 0 <= row-1 <=n-1:
        if (li[row-1][column] != -1) and (li[row-1][column] != 1):
            if second[row-1][column] == 0:            
                #忽略墙和起点
                second[row-1][column] = 1
                recur(row-1,column,step+1)

运行结果如下，为错误输出：
在这里插入图片描述
错误输出的原因如下：
在这里插入图片描述
在某一时刻，递归往右走完，红色为已经遍历过的点，由于设置了visited，这些点不能再被遍历到了。
在这里插入图片描述
之后递归再向左遍历，蓝色代表能达到的范围，但绿色矩阵本来也应该可以到达，但由于有个红色挡住了，所以绿色区域就不能被遍历到了，所以就造成了错误输出。

优化深度递归次数

还是建立一个同样的大小的二维数组second，但另每个元素初值为-1，定义second每个元素的含义为传播能力，比如起点的传播能力为k，那么起点对应到second的那个元素的值就设为k；从起点递归到了下一个点A，那么A对应到second的那个元素的值就设为k-1,，以此类推，递归终点的点就会被设置为0。
在递归函数recur中，k-step-1即k-(step+1)为当前递归的传播能力，second对应元素的值为已经记录的传播能力：
如果当前递归的传播能力>已经记录的传播能力，那么继续递归，更新传播能力。
如果当前递归的传播能力<=已经记录的传播能力，那么停止递归。
在这里插入图片描述
如上图所示，假设有一个点1即出口的深度遍历是这样，红色数字表示了每个点的传播能力。
在这里插入图片描述
现在有另一个出口，它的传播能力是蓝色字体，当它传播到了虚线矩形区域时，当前传播能力就不大于已记录能力了，此时就应该停止深度遍历。这样就减小了递归次数。

优化的地方在于：最起码递归不会往回走了，传播能力小的也不会继续递归了，但还是会有一定的重复的遍历。

k  = eval(input())
li = []#原数组
exitLi = []#记录出口

def readexit(index,exitlist):
    #读取出口
    global exitLi
    if 1 in exitlist:
        for i in range(len(exitlist)):#一排里面可能有几个1
            if exitlist[i] == 1:
                exitLi.append([index, i])

#先读取第一行
temp = list(map(int,input().split(',')))
readexit(0,temp)
li.append(temp)
n = len(temp)
#新建第二个矩阵
second = [[-1 for i in range(n)] for j in range(n)]
for i in range(1, len(temp)):
    temp = list(map(int,input().split(',')))
    readexit(i,temp)
    li.append(temp)
#深度遍历每个起点
def recur(row,column,step):
    if step >= k:
        #大于三就返回
        return 
    if 0 <= column+1 <=n-1:
        if (li[row][column+1] != -1) and (li[row][column+1] != 1):
            #忽略墙和起点
            if (k-step-1) > second[row][column+1]:
                #如果当前传播能力大于已有传播能力，才进行递归
                second[row][column+1] = k-step-1
                recur(row,column+1,step+1)
    if 0 <= column-1 <=n-1:
        if (li[row][column-1] != -1) and (li[row][column-1] != 1):
            #忽略墙和起点
            if (k-step-1) > second[row][column-1]:
                second[row][column-1] = k-step-1
                recur(row,column-1,step+1)
    if 0 <= row+1 <=n-1:
        if (li[row+1][column] != -1) and (li[row+1][column] != 1):
            #忽略墙和起点
            if (k-step-1) > second[row+1][column]:
                second[row+1][column] = k-step-1
                recur(row+1,column,step+1)            
    if 0 <= row-1 <=n-1:
        if (li[row-1][column] != -1) and (li[row-1][column] != 1):
            #忽略墙和起点
            if (k-step-1) > second[row-1][column]:
                second[row-1][column] = k-step-1
                recur(row-1,column,step+1)
for i in exitLi:
    row = i[0]
    column = i[1]
    second[row][column] = 3
    #手动设置起点的传播能力
    recur(row,column,0)

#按照second里面的1进行赋值
for i in range(n):
    for j in range(n):
        if (li[i][j] == 1) or (li[i][j] == -1):
            li[i][j] = '0'
        elif li[i][j] == 0:
            #两种情况
            if second[i][j] >= 0:
                li[i][j] = '0'
            else:
                li[i][j] = '1'

for i in range(n):
    print(','.join(li[i]))

宽度遍历

使用宽度遍历也是可以的，大概思想也是一样的，每个起点的宽度遍历也是独立的，即每次宽度遍历开始前都要把visited清零的。

#include <bits/stdc++.h>
#define LL long long
using namespace std;

const int maxn = 1e3 + 5;

int mat[maxn][maxn], dp[maxn][maxn];
int vis[maxn][maxn];

int main()
{
	int k;
	cin >> k;
	string str;
	int row = 0;
	while (cin >> str) {
		int num = 0, cnt = 0;//num当前记录的数字，cnt为列
		for (int j = 0; j < str.size(); j++) {
			if (str[j] == ',') {
				mat[row][cnt++] = num;//执行这句后再++
				num = 0;
			}
			else if (str[j] == '-') num = -2;//-2加1就为-1
			else num += str[j] - '0';
		}
		mat[row][cnt++] = num;//这句不用++了
		row++;//行++
	}

	int sumOut = 0, x[maxn], y[maxn];
	//记录出口在哪儿
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < row; j++) {
			//cout << mat[i][j] << ' ';
			if (mat[i][j] == 1) {
				x[sumOut] = i;
				y[sumOut++] = j;
			}
		}
		//cout << endl;
	}

	for (int i = 0; i < maxn; i++) {
		for (int j = 0; j < maxn; j++) {
			dp[i][j] = maxn;
			//dp二维数组每个元素都为1005
		}
	}
	int count = 0;//记录队列真正处理了元素的次数
	//四个方向
	int direct[4][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
	for (int i = 0; i < sumOut; i++) {
		//每次for循环是一次广度遍历
		dp[x[i]][y[i]] = 0;//把出口对应元素设置为0，元素代表与起点的距离
		memset(vis, 0, sizeof(vis));//重新分配visit数组，即每个广度遍历是独立的
		queue<int> Q;
		Q.push(x[i] * maxn + y[i]);//入队二维元素的一维序号
		while (!Q.empty()) {
			int pos = Q.front();
			Q.pop();
			int posX = pos / maxn, posY = pos % maxn;
			if (vis[posX][posY]) continue;
			vis[posX][posY] = 1;
			for (int j = 0; j < 4; j++) {
				int newX = posX + direct[j][0];
				int newY = posY + direct[j][1];
				cout << newX << " "<< newY<<endl;
				if (newX >= 0 && newX < row && newY >= 0 && newY < row && mat[newX][newY] != -1) {
					dp[newX][newY] = min(dp[newX][newY], dp[posX][posY] + 1);
					//更新与起点距离，一种是从1005更新，一种是从已记录更新
					if (!vis[newX][newY]) Q.push(newX * maxn + newY);
					//如果访问过，就不会继续宽度遍历
				}
			}
			
			for (int tempi = 0; tempi < row; tempi++) {
				for (int tempj = 0; tempj < row; tempj++) {
					if (tempj != row - 1)
						cout << dp[tempi][tempj] << " ";
					else
						cout << dp[tempi][tempj];
				}
				cout << endl;
			}
			for (int tempi = 0; tempi < row; tempi++) {
				for (int tempj = 0; tempj < row; tempj++) {
					if (tempj != row - 1)
						cout << vis[tempi][tempj] << " ";
					else
						cout << vis[tempi][tempj];
				}
				cout << endl;
			}
			count++;
			cout << endl;
		}
	}
	for (int i = 0; i < row; i++) {//你只需要留下这个for循环里面的输出，其他都是为了调试
		for (int j = 0; j < row; j++) {
			if (mat[i][j] == -1) cout << 0;
			else if (dp[i][j] <= k) cout << 0;
			else cout << 1;
			if (j != row - 1) cout << '\t';
		}
		cout << endl;
	}
	cout << "count" << count;
	return 0;
}
/*
3
0,0,0,0,0
0,0,0,0,0
0,0,1,0,0
0,0,0,0,0
0,0,0,0,0
*/

重点分析宽度遍历的那个while循环：
1.每执行一次while循环，就置vis[posX][posY]为1，并对[posX][posY]的四个方向上的点进行处理。

2.处理首先是dp[newX][newY] = min(dp[newX][newY], dp[posX][posY] + 1)，dp数组元素代表与起点距离，这句是用于更新与起点距离，一种可能是从初始值1005更新为当前与起点距离，另一种可能是从已记录与起点距离更新为更小的与起点距离。

3.处理然后是if (!vis[newX][newY]) Q.push(newX * maxn + newY)，将四个方向的点中没有被访问的点加入队列，以待之后进行访问。

4.有可能会把一个未被访问过的点多次加入到队列当中，如果说C++提供的队列能够有功能检测元素是否在队列中，那就好办了，直接改成if (!vis[newX][newY] & 不在队列中) Q.push(newX * maxn + newY)，但并没有这个功能，所以一个点重复加入队列中是无法避免的事，但可以在while循环前部分加入if (vis[posX][posY]) continue，以免程序进行重复的操作。

下面的示意图将演示“一个点重复加入队列中”：
在这里插入图片描述
第一次出队后，周围四个方向的点就入队，之后的操作，就是再分别依次地对这四个点进行出队操作。
在这里插入图片描述
假设之后再对2,3这个点进行出队操作，又会将上图中红圈里的点入队，注意黄色数字0将会被重复入队。
在这里插入图片描述
假设之后再对3,2这个点进行出队操作，又会将上图中红圈里的点入队，这时黄色数字0被重复入队。
在这里插入图片描述
可以想象，在将最初入队的四个点都出队后，上图的四个黄色的点都会被重复入队。

宽度遍历优化

也是使用传播能力的思想，只是宽度遍历中变成了与起点距离，与起点距离就是反过来想。每次宽度遍历都不会所有点遍历一遍了。

	for (int i = 0; i < sumOut; i++) {
		//每次for循环是一次广度遍历
		dp[x[i]][y[i]] = 0;//把出口对应元素设置为0，元素代表与起点的距离
		memset(vis, 0, sizeof(vis));//重新分配visit数组，即每个广度遍历是独立的
		queue<int> Q;
		Q.push(x[i] * maxn + y[i]);//入队二维元素的一维序号
		while (!Q.empty()) {
			int pos = Q.front();
			Q.pop();
			int posX = pos / maxn, posY = pos % maxn;
			if (vis[posX][posY]) continue;
			if (!vis[posX][posY] & (dp[posX][posY] == k)) {
				//如果在当前遍历中还没有访问过，且距离为k即最远了，就只更新visited
				vis[posX][posY] = 1;
				continue;
			} 
			vis[posX][posY] = 1;
			for (int j = 0; j < 4; j++) {
				int newX = posX + direct[j][0];
				int newY = posY + direct[j][1];
				cout << newX << " "<< newY<<endl;
				if (newX >= 0 && newX < row && newY >= 0 && newY < row && mat[newX][newY] != -1 && mat[newX][newY] != 1) {
				//加了避开其他起点
					
					if (!vis[newX][newY] & ((dp[posX][posY] + 1)< dp[newX][newY])) Q.push(newX * maxn + newY);
					//只有传播能力更强才能入队
					//如果访问过，就不会继续宽度遍历
					dp[newX][newY] = min(dp[newX][newY], dp[posX][posY] + 1);
					
				}
			}
			
			for (int tempi = 0; tempi < row; tempi++) {
				for (int tempj = 0; tempj < row; tempj++) {
					if (tempj != row - 1)
						cout << dp[tempi][tempj] << " ";
					else
						cout << dp[tempi][tempj];
				}
				cout << endl;
			}
			for (int tempi = 0; tempi < row; tempi++) {
				for (int tempj = 0; tempj < row; tempj++) {
					if (tempj != row - 1)
						cout << vis[tempi][tempj] << " ";
					else
						cout << vis[tempi][tempj];
				}
				cout << endl;
			}
			count++;
			cout << endl;
		}
	}
anlian523
关注
专栏目录
朋友字节跳动面试，第三面挂了，这原因我服了！这心也太大了
a3961401的博客
12-01 1万+
前言 大家应该看过不少人分享的面试成功的面经，是不是觉得自己“说不定也可以”呢？ 这里重提一个理论：幸存者偏差。当取得资讯的渠道，仅来自于幸存者时（因为死人不会说话），此资讯可能会存在与实际情况不同的偏差。 所以，今天要分享的是凉经。文末总结了此次的面试答案与面试思考 这位是二面字节挂掉的朋友 下面是他的面经 投的是抖音，感觉抖音的需求量大些，面上的可能性更高一些吧，但是我忘了一点供应量也是一样的大。。。 一面二面的时候感觉自己表现还不错，所以后面就有点飘，结果第三面准备不足，多人面试直接懵逼…（啊啊啊啊
字节奋战8年，离去的时候只有一份1857页的算法笔记陪我
文章中资料均可获取，有需要请添加yunduoa2019即可
05-14 326
计算机专业的应届生想进大厂做开发有多难呢？ 我们来看一组网上的数据： 据统计，互联网公司笔试是最难的关卡之一，平均通过率只有 10%~20%。滴滴出行笔试通过率为 18.2%；腾讯秋招笔试通过率不足 15%；字节跳动通过率不足 25%... 你要知道的是，即便好不容易过淘汰率 50% 笔试，还有淘汰率 60% 的面试在等你，而且面试也有好几轮：一面群面→二面组长面→三面部门经理面→四面总监面→五面 HR 面→ Offer。 看完这个，不知道有多少同学的心已经凉得跟现在东北的气温一..
【机试】今日头条（字节跳动）2018 笔试（算法）
Jasmine_dream
05-26 1万+
面试的反思 缘起 意外的一个机会，朋友告诉我头条的这个笔试。想着还没有面试过，就来试水一下。为明年模拟准备。 面试题目 150min(100`) 选择题 3*5` 填空题 7*5` 编程题 2*25` 由于我不是CS专业出身，本来三个比较简单的选择题对于我来说确实无法拿分的。未来还是要加强C++的学习。 填空题不存在什么难度，基本上以脑经急转弯？或者说是简单的概率题的形式存在。...
字节跳动笔试后的感悟
qq_34473178的博客
07-04 3296
前些天投了字节跳动提前批，投完过了一天提示简历筛选完毕，然后短信和邮件发来了笔试邀请，本来我以为提前批内推过来的没有笔试，没想到还是有笔试，后来才知道，原来内推是简历非常厉害的才能免笔试（小菜鸡不配免笔试），然后没有办法哇，人家要笔试考我，别无他法，只有刷题咯，然后我找了leetcode的中的字节跳动专项来训练，说是训练，实际上由于时间来不及了（那个题库中差不多40道题），因为距离笔试只剩下1天时间不到了，所以直接看答案，答案看得倒是蛮快的，可是有点消化不良。终于在今天上午10点笔试开始了，字节跳动还是那个
最新、最全的 IntelliJ IDEA(2018.3.3) 的介绍、安装、破解、配置与使用
qq_35487165的博客
01-19 1万+
文章目录 一、IntelliJ IDEA 介绍 -&gt; Eclipse IBM 1. JetBrains 公司介绍 2. IntelliJ IDEA 介绍 3. IDEA 的主要功能介绍 4. IDEA 的主要优势：(相较于 Eclipse 而言) 5. IDEA 的下载地址：(官网) 6. 官网提供的详细使用文档 二、windows 下安装过程 1. 安装前的准备 2. ...
jdk-8u131-linux-x64.tar.gz
05-09
jdk-8u131-linux-x64.tar.gz 截至2017.05.08 最新版JDK For Linux x64 gar.gz sha256: 62b215bdfb48bace523723cdbb2157c665e6a25429c73828a32f00e587301236 md5: 75b2cb2249710d822a60f83e28860053 大小：176.95 MB
jdk-8u91-windows-x64.exe
04-20
jdk-8u91-windows-x64.exe java jdk-8u91 windows x64 .exe 截至2016.04.20 最新版JDK For windows x64 .exe sha256: 3f34e5f2f142e4ad560539384d62fe0171bf05f62256976c4f9da60113f59849 md5: 61aecb9c7720f4db8c...
浏览器兼容 谷歌IE8.js，IE9.js下载
01-29
... ``` 这里的条件注释`<!--[if lt IE 9]>`和`<!--[if lt IE 8]>`用于确保只有在IE8及以下版本的浏览器中才会加载对应的脚本，避免在现代浏览器中造成额外的性能开销。 需要注意的是，虽然`IE8.js`和`IE9.js`...
木瓜的MyFll.fll(1.182.10.526)及说明
07-01
《木瓜的MyFll.fll(1.182.10.526)及说明》 本文将深入探讨“木瓜”的MyFll.fll文件，这是一个专为编程爱好者和IT专业人士设计的软件组件，其版本号为1.182.10.526。这个组件以其独特的功能和强大的性能在编程领域内...
【笔试真题】字节跳动产品岗笔试主观题解析！！
Sing599的博客
09-07 1万+
题目一：如果选一家互联网公司和今日头条深度合作，选择哪一家？为什么？TOC 考点：战略分析 【主要解题思路】 本题考查的是战略分析，对于这种题，我们可以有两种思路去思考。 1.思路1：SWOT分析–企业战略分析方法 具体分析方式如下； 在SWOT法中，我们可以主要对今日头条的优势进行分析，再思考能否将头条的优势与当前市场的机会有效结合。 SO（优势+机会）最重要，这是公司未来的核心发展 WT（弱...
编程训练2
alfredlew1026的博客
08-12 802
1.世界杯开幕式会在球场C举行，球场C的球迷看台可以容纳M*N个球迷。在球场售票完成后，现官方想统计此次开幕式一共有多少个球队球迷群体，最大的球队球迷群体有多少人。 经调研发现，球迷群体在选座时有以下特性： 同球队的球迷群体会选择相邻座位，不同球队的球迷群体会选择不相邻的座位（注解：相邻包括前后相邻，左右相邻，斜对角相邻） 给定一个M*N的二维球场，0代表该位置没有坐人，1代表该位...
双生词-字节跳动的笔试
boguesfei的博客
08-25 747
import java.util.Scanner; import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main {     /**      * @param args      */     public static void main(String[] args) {        ...
字节跳动一面通过率_字节跳动面试（一面）总结
weixin_39604557的博客
11-22 6189
其实这篇总结很早以前就开始写了——去年11月底就面的头条，只是由于总总原因没有完成，趁现在假期补上。 面试用的是ZOOM视频会议，这里提醒大家视频面试前现检查网络情况如何！一定要保证非常流畅，不然等等面试官听到你的讲话断断续续的，或者是你听不清问题一直让面试官重复一次，都是一个减分项。一、面试前这次面试可以说是比较匆忙，当时我手里还有一个比赛，再加上那时候正好是我们伟大的岳麓第一高中期...
字节跳动春招攻略：学长学姐笔经面经，还有出题人「锦囊」
字节跳动技术范儿
03-26 4012
正在参加春季校招的同学们，此刻可能是最紧张的了： 简历投出去了，什么时候才能收到笔试通知啊？ 收到了笔试通知，最后两天还来得及做什么准备？ 面试会问什么问题？怎么才能提升通过率、拿到更好的offer？ 不妨先来听一听过来人的故事。 我们找到了通过校招入职字节跳动的算法、后端、客户端、前端、大数据、测试方向的6位技术同学，分享他们校招中遇到的难题和拿到offer的独家秘笈。 来一起看看他们是如何过关斩将，拿到字节跳动offer的吧。 图形算法o...
字节跳动2019第三次笔试（JavaScript版本）
叮当了个河蟹
09-09 3150
UTF-8校验 //js版本代码 /** * Created by dcp on 2018/9/9. */ // UTF-8校验 const readline = require('readline'); const rl = readline.createInterface({ input: process.stdin, output: process.st...
字节跳动一二面面经(二面挂)
qq_35985044的博客
03-27 4730
字节一面(戴口罩的面试官有点帅，看上去像易烊千玺，但是一直摆pose) 自我介绍 实验室做啥方向 介绍下http服务器项目 代码题，给一个正整数s，给出所有加起来和为s的正整数集合(一开始理解错题意，写了快10分钟，被吐槽了一下) 面试官边找题边让我介绍下https 代码题，螺旋打印矩阵，leetcode原题 项目中遇到了哪些困难，怎么解决 拥塞避免和快重传是什么 进程间通信有哪些方式 cpu调度...
字节跳动校招笔试题汇总
热门推荐
qq_41805514的博客
10-06 3万+
1. 世界杯开幕式 思路：跟leetcode上求岛屿数量问题很像，使用DFS，这里要注意的是搜索方向从4个变成了8个，并且要输出最大区域里的人数。 # coding:utf-8 M, N = list(map(int, raw_input().split(','))) book = [] for i in range(M): line = list(map(int, raw_...
vivado 2018.2与modelsim联合仿真的详细步骤
"vivado 2018.2与modelsim的联合仿真流程" 在Xilinx Vivado 2018.2版本中，为了实现与 Mentor Graphics 的ModelSim仿真器的联合仿真，需要进行一系列设置。Vivado虽然自带了仿真工具，但在处理复杂的仿真任务时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值