字节跳动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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
朋友字节跳动面试，第三面挂了，这原因我服了！这心也太大了
a3961401的博客
12-01 1万+
前言 大家应该看过不少人分享的面试成功的面经，是不是觉得自己“说不定也可以”呢？ 这里重提一个理论：幸存者偏差。当取得资讯的渠道，仅来自于幸存者时（因为死人不会说话），此资讯可能会存在与实际情况不同的偏差。 所以，今天要分享的是凉经。文末总结了此次的面试答案与面试思考 这位是二面字节挂掉的朋友 下面是他的面经 投的是抖音，感觉抖音的需求量大些，面上的可能性更高一些吧，但是我忘了一点供应量也是一样的大。。。 一面二面的时候感觉自己表现还不错，所以后面就有点飘，结果第三面准备不足，多人面试直接懵逼…（啊啊啊啊
字节跳动校招笔试题汇总
热门推荐
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_...
字节跳动笔试后的感悟
qq_34473178的博客
07-04 3259
前些天投了字节跳动提前批，投完过了一天提示简历筛选完毕，然后短信和邮件发来了笔试邀请，本来我以为提前批内推过来的没有笔试，没想到还是有笔试，后来才知道，原来内推是简历非常厉害的才能免笔试（小菜鸡不配免笔试），然后没有办法哇，人家要笔试考我，别无他法，只有刷题咯，然后我找了leetcode的中的字节跳动专项来训练，说是训练，实际上由于时间来不及了（那个题库中差不多40道题），因为距离笔试只剩下1天时间不到了，所以直接看答案，答案看得倒是蛮快的，可是有点消化不良。终于在今天上午10点笔试开始了，字节跳动还是那个
【机试】今日头条（字节跳动）2018 笔试（算法）
Jasmine_dream
05-26 1万+
面试的反思 缘起 意外的一个机会，朋友告诉我头条的这个笔试。想着还没有面试过，就来试水一下。为明年模拟准备。 面试题目 150min(100`) 选择题 3*5` 填空题 7*5` 编程题 2*25` 由于我不是CS专业出身，本来三个比较简单的选择题对于我来说确实无法拿分的。未来还是要加强C++的学习。 填空题不存在什么难度，基本上以脑经急转弯？或者说是简单的概率题的形式存在。...
【笔试真题】字节跳动产品岗笔试主观题解析！！
Sing599的博客
09-07 1万+
题目一：如果选一家互联网公司和今日头条深度合作，选择哪一家？为什么？TOC 考点：战略分析 【主要解题思路】 本题考查的是战略分析，对于这种题，我们可以有两种思路去思考。 1.思路1：SWOT分析–企业战略分析方法 具体分析方式如下； 在SWOT法中，我们可以主要对今日头条的优势进行分析，再思考能否将头条的优势与当前市场的机会有效结合。 SO（优势+机会）最重要，这是公司未来的核心发展 WT（弱...
字节跳动秋招笔试编程题（一）
u010886794的博客
10-26 4810
1、Bytedance Efficiency Engineering团队在8月20日搬入了学清嘉创大厦。为庆祝团队的乔迁之喜，字节君决定邀请整个EE团队，举办一个大型团建游戏-字节跳动大闯关。可是遇到了一个问题：EE团队共有n个人，大家都比较害羞，不善于与陌生人交流。这n个人每个人都向字节君提供了自己认识的人的名字，不包括自己。如果A的名单里有B，或B的名单里有A，则代表A与B互相认识。同时如果A...
双生词-字节跳动的笔试
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) {        ...
编程训练2
alfredlew1026的博客
08-12 797
1.世界杯开幕式会在球场C举行，球场C的球迷看台可以容纳M*N个球迷。在球场售票完成后，现官方想统计此次开幕式一共有多少个球队球迷群体，最大的球队球迷群体有多少人。 经调研发现，球迷群体在选座时有以下特性： 同球队的球迷群体会选择相邻座位，不同球队的球迷群体会选择不相邻的座位（注解：相邻包括前后相邻，左右相邻，斜对角相邻） 给定一个M*N的二维球场，0代表该位置没有坐人，1代表该位...
字节跳动面试总结-3.18
紫芝的博客
03-18 1万+
字节跳动面试总结 字节跳动是全球第一家将人工智能应用到主产品的科技公司。全系产品矩阵包括今日头条、抖音、西瓜视频、火山小视频、TopBuzz、Faceu激萌、图虫、懂车帝等多款产品。截止2019年1月，字节跳动旗下全线产品日活超过6亿，月活超过10亿。字节跳动也在积极进行国际化部署，产品覆盖150多个国家和地区，75个语种，在40多个国家和地区排在应用商店总榜前列。 面试信息 面试岗位：J...
字节跳动一面通过率_字节跳动面试（一面）总结
weixin_39604557的博客
11-22 6168
其实这篇总结很早以前就开始写了——去年11月底就面的头条，只是由于总总原因没有完成，趁现在假期补上。 面试用的是ZOOM视频会议，这里提醒大家视频面试前现检查网络情况如何！一定要保证非常流畅，不然等等面试官听到你的讲话断断续续的，或者是你听不清问题一直让面试官重复一次，都是一个减分项。一、面试前这次面试可以说是比较匆忙，当时我手里还有一个比赛，再加上那时候正好是我们伟大的岳麓第一高中期...
【面试】字节跳动提前批笔试题：实现三种线程安全的单例模式
七年蝉
07-01 859
文章目录饿汉模式懒汉模式双重检测锁模式附另外两种 饿汉模式 线程安全，调用效率高，但是不能延时加载： public class hungery { //类初始化时立即加载对象(没有延迟加载的优势)，天然的线程安全 private static hungery instance=new hungery(); private hungery(){}; //方法没有同步，调用效率高 pu...
字节跳动春招攻略：学长学姐笔经面经，还有出题人「锦囊」
字节跳动技术范儿
03-26 3995
正在参加春季校招的同学们，此刻可能是最紧张的了： 简历投出去了，什么时候才能收到笔试通知啊？ 收到了笔试通知，最后两天还来得及做什么准备？ 面试会问什么问题？怎么才能提升通过率、拿到更好的offer？ 不妨先来听一听过来人的故事。 我们找到了通过校招入职字节跳动的算法、后端、客户端、前端、大数据、测试方向的6位技术同学，分享他们校招中遇到的难题和拿到offer的独家秘笈。 来一起看看他们是如何过关斩将，拿到字节跳动offer的吧。 图形算法o...
字节跳动2019第三次笔试（JavaScript版本）
叮当了个河蟹
09-09 3148
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...
2020届字节跳动后端开发笔试题目
qq_40993425的博客
08-26 5619
2020届字节跳动后端开发笔试题目 总共四道编程题目。笔试结束，狼友群分享了两道完整的题目，这里分享给大家，仅供参考 版权声明：未经本人许可，请勿转载。题目如涉及公司相关隐私规范，请联系博主删除，谢谢！ ...
《字节跳动》笔试第一题
请叫我小皇帝 的博客
08-12 4240
题目描述：在[m,n]的矩阵中，用1表示有人，0表示没人。假如两个人的位置相邻（包括斜着相邻，水平相邻，垂直相邻），则他们是属于一个团体。 输入： 第一行输入两个数m,n，用，隔开 接下来输入m行，每一行输入n个数，用逗号隔开 输出： 矩阵中有多少个团体，以及最大团体的人数。 例如： 输出6,11（程序没有管输出的格式，自己可以修改） import sys global r ...
我所经历的字节跳动面试
微电子学与固体电子学-俞驰
08-24 1054
面谈时间2020-8-23，面试时间下午5:30~6:20，牛客网视频面谈 投了Python数据挖掘，然后上来让面Java后端。 字节跳动的招聘体系已经和华为一样混乱了。 猎头的回答是猜测可能是觉得你数据挖掘审核不通过,所以给你转Java后端了。 我满脸懵逼，kaggle银牌和各种python前后端全栈项目还不够么。 猎头说不用考leetcode题，但是其实是需要考的。 最后猎头和字节的HR全部联系不上了。 既然你们都联系不上了那我就写出来吧。 字节跳动面试分为四个部分: ...
字节跳动-数据分析笔试回忆20181008
lcg29的博客
11-05 2万+
这是一篇博主含泪写下的笔经   120min时长，五部分。 第一部分80min内完成。四道简答题 十分钟10个推理题计算类型 十分钟10个数字规律题 十分钟三个段落信息或图表，十个小问题 十分钟，推理计算题，理论应该是10个但我最后只有6min时间 进去只显示了7个 说明：时间从19到21点，因为有各部分点进去和提交要时间所以你各个题做题时间+提取题目+提交每部分时间&gt;120m...
字节跳动面试经验总结，已顺利拿到offer！
程序员小乐
05-15 1万+
刚去字节跳动面试成功回来，为了能让大家有更好的面试资料，小编花费了2个多月的时间，把市面上的所有的Java面试题，做了一个归纳总结，整理了快300多页，够大家刷题好久了！好了，废话不多说...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值