几道暑期实习笔试题

第一场(2020/03/20):

题目一:

有一叠扑克牌,每张牌介于1和10之间。有四种出牌方法:

  • 单出一张
  • 出两张相同的牌(对子)
  • 出五张顺子(如12345)
  • 出三连对子(如112233)

给10个数,表示1-10每种牌有几张,问最少要多少次能出完。每种牌最多有四张。

解题思路:

DFS 回溯法,先判断组成三连对和组成顺子需要的次数,递归深度 k 就是次数。对于对子和单张的可以直接通过枚举数需要打多少次。可以在组成三连对和顺子的时候增加剪枝操作加快运算:如果构不成三连对或者顺子,则不用进行回溯。

时间复杂度大概为 O(4^10)。

C++ 实现:
#include<bits/stdc++.h>
using namespace std;
int a[15],ans=123456789;

void dfs(int k)  // k表示次数 
{
    //检查是否有三连对子
    for(int i=1;i<=8;i++) {
        bool flag = true;
        for(int j=i;j<i+3;j++)
            if(a[j] < 2) {  // 不能构成三连对
                flag = false;  // 剪枝 
                break;
            }
        if(flag == true) {  // 可以构成三连对
            for(int j=i;j<i+3;j++)
                a[j] -= 2;
            dfs(k+1);
            for(int j=i;j<i+3;j++)  // 回溯一步
                a[j] += 2;
        }
    } 
    //检查是否有顺子
    for(int i=1;i<=6;i++) {
        bool flag = true;
        for(int j=i;j<i+5;j++) 
            if(a[j] < 1) {  // 不能构成顺子
                flag = false;  //  剪枝 
                break;
            }
        if(flag == true) {   // 可以构成顺子
            for(int j=i;j<i+5;j++)
                a[j] -= 1;
            dfs(k+1);
            for(int j=i;j<i+5;j++)   // 回溯一步
                a[j] += 1;
        } 
    }
    //没有三连对和顺子,直接统计答案
    int cnt = 0;
    for(int i=1;i<=10;i++) {
        if(a[i]==4) cnt += 2;   // 直接构成两个一对
        else if(a[i]==3) cnt+=2;  // 一对,一单张
        else if(a[i]==2) cnt+=1;  // 一对
        else if(a[i]==1) cnt+=1;  // 一单张
    }
    ans = min(ans, cnt+k);   // 更新答案
} 

int main()
{
    for(int i=1;i<=10;i++) cin >> a[i];
    dfs(0);
    cout << ans;
    return 0;
}
题目二:

小明在学旋律,每段旋律都可以用字符串来表示,并且旋律的每个字符的ASCALL码递增的。比如以下4段旋律 : aaa bcd bcdef zzz 现在就是要求,小明能够吧这些旋律拼接起来组成最长的旋律。 比如上述例子输出 11 最长的旋律为 aaabcdefzzz

解题思路:

实际上,这道题和之前做过的 Leetcode 【DP】139. Word Break 很类似。

排序 + 动态规划(DP):

  • 首先按照字符串最后一个字母,由小到大排序,如果最后一个相同,按第一个由小到大字母排序。
  • 然后定义 dp 数组,对于每个字符串 str,dp[i] 表示从字母 'a' 到字母 str[str.size()-1] 为结尾的最长上升字符串的长度。
  • 枚举输入的字符串 s,s 的最后一个字母 end = s[s.size()-1]。从字符串首字母 s[0] 到字母 'a' 倒着循环(假设循环遍历为 i),使用状态转移方程 dp[end] = max(dp[end], dp[i] + s.size()) 来更新 dp[end] 的最大值。
  • 最后,dp['a'] ~ dp['z'] 中的最大值就是答案。

比如上述例子: (0)按照排序规则排完后为 aaa、bcd、bcdef、zzz,建立一个 dp[515],初始化全为 0。然后计算: (1)dp['a'] = max(dp['a'], dp['a'] (首字母) + 3) = 3; (2)dp['d'] = max(dp['d'], dp['b'] (首字母) + 3) = 3;dp['d'] = max(dp['d'], dp['a'] + 3) = 3 + 3 = 6; (3)dp['f'] = max(dp['f'], dp['b'] (首字母) + 5) = 5;dp['f'] = max(dp['f'], dp['a'] + 5) = 3 + 5 = 8; (4)dp['z'] = max(dp['z'], dp['z'] (首字母) + 3) = 3;dp['z'] = max(dp['z'], dp['y'] + 3) = 3;dp['z'] = max(dp['z'], dp['x'] + 3) = 3;...... ;dp['z'] = max(dp['z'], dp['f'] + 3) = 8 + 3 = 11;...... ;dp['z'] = max(dp['z'], dp['d'] + 3) = max(11, 6 + 3) = 11;...... ;dp['z'] = max(dp['z'], dp['a'] + 3) = max(11, 3 + 3) = 11. (5)最后,找出 dp['a'] ~ dp['z'] 中的最大值就是答案。

简单地说,比如一个字符串是 defg,我们就看一下字母 d 之前的能不能连接到以 g 为结尾的字符串后面,因此要循环 d、c、b、a,来更新 dp[g] = max(dp[g], dp[d(或者c\b\a)]+4)。

现在来解释两个问题:

  • 为什么排序规则是上面那样的? 首先,按照末尾字符串先从小到大排序这个毋庸置疑,因为比如 abc、fgh,要计算 dp[h],需要用到 dp[f] 到 dp[a] 这些之前的结果; 然后,如果末尾字符串相同,为什么还要按照首字母排序呢?因为比如 ab、bb,要计算字符串 bb 的 dp[b],需要用到 dp[b] 和 dp[a] 的结果,如果不按照首字母排序,那么可能 bb 会出现在 ab 前面。求解 bb 的时候 dp[a] 是 0,因此就会产生错误答案 2,而不是 4。
  • 为什么在更新 dp[i] 时要从 s[0] 到 'a' 倒着循环? 这是因为比如 s = "bb",如果倒着循环可以得到正确答案 2,但是正着循环,从 'a' 到 s[0] = 'b',更新 dp['b'] 的时候,按照上面的状态转移方程,"bb" 会重复计算一次,得到 dp['b'] = 4 的错误答案。

空间复杂度为 O(26),时间复杂度为 O(26*n)。

C++ 实现:
#include<bits/stdc++.h>
using namespace std;
struct node {
    string s;
    int len;
};
node xuan[1000005];
bool cmp(node a, node b) {  // 排序规则
    if(a.s[a.len-1] < b.s[b.len-1]) return true;
    else if(a.s[a.len-1] > b.s[b.len-1]) return false;
    else {
        return a.s[0] < b.s[0];
    }
}
int f[500];  // f[i]表示从字符'a'到字符串最后一个字符的最大长度 
int main()
{
    int n;
    cin >> n;
    for(int i=1;i<=n;i++) {
        cin >> xuan[i].s;
        xuan[i].len = xuan[i].s.size();
    }
    sort(xuan+1,xuan+n+1,cmp);
    for(int i=1;i<=n;i++) {
        int start = xuan[i].s[0];//第一位字符的ASCLL值 
        int end = xuan[i].s[xuan[i].len-1];//最后一位字符的ASCLL值 
        for(char c=start; c>='a';c--) //必须从start开始倒着循环到'a' 
            f[end] = max(f[end], f[c]+xuan[i].len);
    }
    int ans = 0;
    for(char c='a';c<='z';c++)
        if(f[c]>ans) ans = f[c];
    cout << ans;
    return 0;
}

第二场(2020/03/23):

题目一:

N个人,任意选k个,再从k个里任选1个当队长,求总组合数。

解题思路:

总数 S = 0*C(N,0) + ... + i*C(N,i) + N*C(N,N) 倒着加:S + S = N*(C(N,0) + ... + C(N,N) = N*2^(N) 所以 S = N*2^(N-1)

接下来只需要考虑计算 2^(N-1) 的快速计算方法就好了(快速幂算法)

时间复杂度O(logN),可以AC

C++ 实现:
#include<bits/stdc++.h>
using namespace std;
const int mod=1e9+7;
typedef long long ll;

ll ksm(ll a, ll b)  // 快速幂算法
{
    ll ans=1, base=a;
    while(b) {
        if(b&1) ans=ans*base%mod;
        base=base*base%mod;
        b>>=1;
    }
    return ans%mod;
}

int main() {
    ll n;
    cin>>n;
    ll ans=n*ksm(2,n-1)%mod;
    cout<<ans<<endl;
    return 0;
}
题目二:

一个地图 n*m,包含1个起点,1个终点,其他点包括可达点和不可达点。每一次可以:上下左右移动,或使用1点能量从(i,j) 移动到(n-1-i, m-1-j),最多可以使用5点能量。求从起点到达终点的最短路径长度。

解题思路:

类似于广度优先搜索的(使用队列),只不过还要考虑到达某个坐标有能量时,也可以进行跳跃,因此也可以入队列。

因为队列入队时,肯定越到后面步数需要越多,所以其实第一次访问到终点坐标就可以跳出了,即就是最短路径。

空间复杂度 O(m*n), 时间复杂度 O(m*n)。

C++ 实现:
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
typedef long long ll;
struct node {  // 某个节点信息
    int x,y;
    int stp;  // 到达这个节点时所走的步数
    int cnt;  // 到达这个节点时还有多少能量
};
int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
int sx,sy;   // 起点坐标
int n,m;
int ex,ey;  // 终点坐标
bool check(int x,int y){
    if(x>=1&&x<=n&&y>=1&&y<=m){
        return true;
    }
    else{
        return false;
    }
}
char Map[505][505];  // 地图
int vis[505][505];  // 标记某个点是否走过

int  BFS() {
    queue<node>q;
    node st;
    st.x=sx;
    st.y=sy;
    st.stp=0;
    st.cnt=5;
    vis[sx][sy]=1;
    q.push(st);  // 起点入队列
    while(!q.empty()){
        node now =q.front();
        if(now.x==ex&&now.y==ey)return now.stp;  // 最短路径即是第一次到达的步数
        q.pop();
        node nxt;
        for(int i=0;i<4;i++) {   // 上下左右搜索
            nxt.x=now.x+dir[i][0];
            nxt.y=now.y+dir[i][1];
            nxt.stp=now.stp+1;
            nxt.cnt=now.cnt;
            if(check(nxt.x,nxt.y)&&vis[nxt.x][nxt.y]==0&&(Map[nxt.x][nxt.y]=='.'||Map[nxt.x][nxt.y]=='E')){  // '.' 为可达
               vis[nxt.x][nxt.y]=1;
               q.push(nxt);
            }
        }
        if(now.cnt>=1){   // 如果到达 now 这个节点还有能量
            nxt.x=n+1-now.x;
            nxt.y=m+1-now.y;
            nxt.stp=now.stp+1;
            nxt.cnt=now.cnt-1;
            if(check(nxt.x,nxt.y)&&vis[nxt.x][nxt.y]==0&&(Map[nxt.x][nxt.y]=='.'||Map[nxt.x][nxt.y]=='E')){  // '.' 为可达
               vis[nxt.x][nxt.y]=1;
               q.push(nxt);
            }
        }
    }
    return -1;   // 队列为空,不可达
}

int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        scanf("%s",Map[i]+1);
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(Map[i][j]=='S'){  // 起点
                sx=i;sy=j;
            }
            if(Map[i][j]=='E'){  // 终点
                ex=i;ey=j;
            }
        }
    }
    cout<<BFS()<<endl;
    return 0;
}

第三场(2020/03/25):

题目一:

给定一个 3 行 n 列的矩阵 a (n<=10^5),从每一列选择一个数 bi 组成一个数组,然后要求使这个数组前一项减后一项的绝对值之和最小。即求 ∑ |b(i) - b(i+1)| (i=1,2,...,n-1)

输入示例:

5
5  9  5  4  4
4  7  4  10 3
2  10 9  2  3
这里可以选择 [5 7 5 4 4],所以输出等于 |7-5|+|5-7|+|4-5|+|4-4|=5。所以输出就是5。
解题思路:

动态规划。这道题和 Leetcode 【DP】64. Minimum Path Sum 很类似,使用 f[i][j] 存储到达点 (i, j) 的最小绝对值之和,最后 min({f[1][n],f[2][n], f[3][n]}) 就是最终的答案。状态转移方程如下: f[i][j] = min(f[k][j-1] + abs(a[k][j-1] - a[i][j])), k = 1, 2, 3 边界情况:f[1][1] = f[2][1] = f[3][1] = 0 (初始绝对值累加和为0)

时间复杂度为 O(9*n),空间复杂度为 O(3*n)。

C++ 实现:
#include<iostream>
#include<algorithm> 
#include<cstring>
#include<cmath>
using namespace std;
typedef long long ll;

ll a[4][100005], f[4][100005];

int main()
{
    int n;
    cin>>n;
    for(int i=1; i<=3; i++) {
        for(int j=1; j<=n; j++) {
            cin>>a[i][j];
        }
    }
    memset(f, 0x7f, sizeof(f));  // 相当于 0x7f7f7f7f (int下)
    f[1][1] = f[2][1] = f[3][1] = 0;
    for(int j=2; j<=n; j++) {  // 先要遍历列
        for(int i=1; i<=3; i++) {  // 再遍历行
            for(int k=1; k<=3; k++) {
                f[i][j] = min(f[i][j], f[k][j-1] + abs(a[i][j] - a[k][j-1]));
            }
        }
    }
    cout<<min(f[1][n], min(f[2][n], f[3][n]));
}
优化:

因为 f[i][j] = min(f[k][j-1] + abs(a[k][j-1] - a[i][j])), k = 1, 2, 3,则发现第 j 列只依赖于 j-1 列,因此没必要开辟一个 f[i][j] 大小的二维数组,只需要开辟两个一维数组:f[4] 和 pre[4],其中 f[i] 记录当前列每一行绝对值累加和,pre[i] 记录上一列每一行绝对值累加和。 因此状态转移方程为: f[i] = min(pre[k] + abs(a[k][j-1] - a[i][j])), k = 1, 2, 3 边界情况:pre[1] = pre[2][1] = pre[3][1] = 0 (初始绝对值累加和为0) 需要注意的是,每次求 f 数组的每一个 f[i] 时,都要先初始化为最大值,并且每次计算完 f 数组后,都要将 f 数组拷贝给 pre 数组。

时间复杂度为 O(12*n),空间复杂度为 O(1) (只有两个大小为 4 的数组)。

空间优化的 C++ 代码实现:
#include<iostream>
#include<algorithm> 
#include<cstring>
#include<cmath>
using namespace std;
typedef long long ll;

// f数组记录当前列每一行绝对值累加和,pre数组记录上一列每一行绝对值累加和 
ll a[4][100005], f[4], pre[4];

int main()
{
    int n;
    cin>>n;
    for(int i=1; i<=3; i++) {
        for(int j=1; j<=n; j++) {
            cin>>a[i][j];
        }
    }
    pre[1] = pre[2] = pre[3] = 0;
    for(int j=2; j<=n; j++) {
        memset(f, 0x7f, sizeof(f));  // 因为是一维,所以每次都必须先初始化 
        for(int i=1; i<=3; i++) {
            for(int k=1; k<=3; k++) {
                f[i] = min(f[i], pre[k] + abs(a[i][j] - a[k][j-1]));
            }
        }
        for(int t=1; t<=3; t++) {  // f数组更新完后,将其拷贝给pre数组 
            pre[t]=f[t];
        }
    }
    cout<<min(f[1], min(f[2], f[3]));
}
题目二:

给出一个 n*m 二维矩阵 (n<=500, m<=500),矩阵的每一行和每一列都是一个独立的等差数列,其中一些数据缺失了,现在需要推理隐藏但是可以被唯一确定的数字,然后对输入的查询进行回答。

输入描述: 第一行,n,m,q 分别表示矩阵的行数,列数和查询的条数。 接下来的 n 行,每行 m 个数表示这个矩阵,0表示缺失数据。 接下来 q 行,每行两个数字 x, y 表示对矩阵中第 i 行第 j 列的数字进行查询。

输出描述: 如果可以确定该位置的数字,则输出该数字,如果不能确定则输出 字符串 "Unknown"。

输入示例:

2 3 6
1 0 3
0 0 0
1 1
1 2
1 3
2 1
2 2
2 3

输出示例:

1
2
3
Unknown
Unknown
Unknown

样例解释: 矩阵是一个 2*3 的矩阵:[[1,0,3], [0,0,0]],总共询问 6 次。由第一行,可以确定公差为 1,因此前三次询问中,第一行的三个数都可以确定。但是,第二行是 3 个 0,不能推断出每一个数,因此后三次询问中,都输出 "Unknown"。

解题思路:

先将整个矩阵 a 推断出来,把能够确定的数字填入矩阵中,并用一个标记数组 vis 标记某个位置的数是否是确定的。然后再进行询问,对于确定的数直接输出结果,否则输出 "Unknown"。

关键点在于,如何推断出这个矩阵?如果我们知道每一行有两个确定的数字,我们就可以计算出该行的公差 d;同理,如果我们知道每一列有两个确定的数字,我们也可以计算出该列的公差 d。比如某一行:0 3 0 0 9 11 0 0,我们找到 3 和 9,就可以计算出公差 d = 2,并且可以推断出这行的其他数字,因此改行可以得到 1 3 5 7 9 11 13 15。

因此,算法步骤如下(假设是 work() 处理函数):

  • 对于每一行,去计算公差 d,如果可以计算出来,推断该行所有的数字,填充到矩阵 a 中,并用标记数组 vis 标记该行所有数字都可以推断。
  • 对于每一列,去计算公差 d,如果可以计算出来,推断该列所有的数字,填充到矩阵 a 中,并用标记数组 vis 标记该列所有数字都可以推断。

举例:

a 矩阵        ->          推断行                ->              推断列
0 2 0 4                  1 2 3 4                              1 2 3 4
1 0 5 0                  1 3 5 7                              1 3 5 7
0 4 0 0                  0 4 0 0                              1 4 7 10

但是,这种做法有一个问题,比如:

a 矩阵        ->          推断行                ->              推断列
0 2 0 4                  1 2 3 4                              1 2 3 4
0 3 0 0                  0 3 0 0                              0 3 0 5
0 0 0 6                  0 0 0 6                              0 4 0 6

会发现只推断一次行于列,推断不完全!实际上,需要推断多次,才能将所有的数字全部推理出来。再比如下面的这个例子:

7*5的矩阵,需要行列各推理三次才能全部推理结束

黄色表示确定的数字,空白表示不确定的数字。因此,需要调用 3 次 work() 函数才能全部推理出来。

因此,可以在代码中写一个 while(work()) ; 不断调用 work() 处理函数,在 work() 函数中加一个标记变量 flag = false,假设新一轮扫描中没有产生新的未知量,如果发现标记数组 vis 不再变化为止,说明推断结束,返回 flag (false),否则,将 flag 改为 true,继续进行下一轮的推断。

其实,还有一个更为隐蔽的 case,就是比如某一行为 -1 0 1,这个 0 是确定的数字,并不是未知量,因此需要在找两个非 0 数字过程中将条件 if(a[i][j] != 0) 改成 if(a[i][j] != 0 || vis[i][j] == true),就可以考虑到这种情况。如:

a 矩阵        ->          推断行              ->             推断列
-1 0 0                  -1 0 0                              -1 -2 -3 (-2根据0推出)
0 -1 1                  -3 -1 1                             -3 -1 1
-5 0 5                  -5 0 5 (这个0确定)                   -5 0 5 (这个0确定) 

在推断第 3 行的时候,中间的 0 是确定的数字,不是未知量,因此 vis[3][2] = true,当推断第 2 列时,根据 if(a[3][2] != 0 || vis[3][2] == true) 这个条件,条件也成立,说明可以利用 a[3][2] 上的 0,来推断出 a[1][2] = -2。

时间复杂度为 O(k*n*m)(k 是 work() 函数调用的次数),空间复杂度也为 O(n*m)。

C++ 实现:
#include<iostream>
using namespace std;

int n,m,q,x,y;
int a[505][505], vis[505][505];

void work() // 填充矩阵a,并标记某个位置的数是否是确定的 
{
    int flag = false; // 新一轮扫描中,没有产生新的未知量 
    for(int i=1; i<=n; i++) {  // 枚举每一行,检验该行上是否有两个确定的数字 
        int p = 0;  // 对于第i行,找到第一个确定的数字出现的位置p和公差d  
        int d = 0x7fffffff;
        for(int j=1; j<=m; j++) {  
            if(a[i][j]!=0 || vis[i][j]==true) {  // 后一个条件是为了处理 -1 0 1 的情况,这个0是确定的数字0 
                if(p==0) {
                    p = j;
                } else {  // 第二次出现确定的数字,可以计算出公差d 
                    d = (a[i][j]-a[i][p]) / (j-p);
                    break; 
                }
            }
        }
        if(d!=0x7fffffff) {  // d计算出来了,填充第i行中的每个数 
            for(int j=1; j<=m; j++) {
                a[i][j] = a[i][p] + d * (j-p);
                if(vis[i][j] == false) flag = true;  //  新一轮扫描中,产生了新的未知量 
                vis[i][j] = true;  // 标记第i行的每个数字都是确定的 
            }
        }
    }
    for(int j=1; j<=m; j++) {  // 枚举每一列,检验该列上是否有两个确定的数字 
        int p = 0;
        int d = 0x7fffffff;
        for(int i=1; i<=n; i++) {
            if(a[i][j]!=0 || vis[i][j] == true) {
                if(p==0) {
                    p = i;
                } else {
                    d = (a[i][j]-a[p][j]) / (i-p);
                    break; 
                }
            }
        }
        if(d!=0x7fffffff) {
            for(int i=1; i<=n; i++) {
                a[i][j] = a[p][j] + d * (i-p);
                if(vis[i][j] == false) flag = true;
                vis[i][j] = true;
            }
        }
    }   
    return flag; // 如果返回true,说明还需要继续扫描一轮 
} 

int main()
{
    // 输入 
    cin>>n>>m>>q;
    for(int i=1; i<=n; i++) {
        for(int j=1; j<=m; j++) {
            cin>>a[i][j];
        }
    }
    // 处理
    while(work());  // 扫描多次行域列,直到vis数组不变化为止,才说明推断结束 
    // 询问q次 
    for(int i=1; i<=q; i++) {
        cin>>x>>y;
        if(vis[x][y]) {
            cout<<a[x][y]<<endl;
        } else {
            cout<<"Unknown"<<endl;
        }
    }
} 

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 腾讯暑期实习在线笔试题--魔法序列

    前段时间投实习,腾讯的暑期实习进了在线笔试。结果只做出了一道题(1/5),非常丢人。

    伪君子
  • 腾讯暑期实习产品策划&运营岗笔经面经

    牛客网
  • 象牙塔之旅

    又是一年暑假季,八月的炎热比起七月要温和点,只是每每到了夜晚,隔三两天就会暴雨如注,清晨起来,一夜好梦。 不知不觉毕业快两个月了,偶尔恍惚还以为自己才大四,前...

    仇诺伊
  • 北大“女学霸”,3 个月内拿取硅谷10 家顶级科技公司offer!

    经过 3 个月精心准备,我拿到了 Google,Facebook,Netflix,linkedin,Snapchat,Roku TV,Amazon,Signal...

    秃顶的Java程序员
  • 我的2017春招实习+秋招总结【前端开发】

    双非本科,通信工程,算是转到IT行业这边的了。从大二暑期正式开始学习前端,想想已经一年的时间了。期间经历了很多,从迷惘到清晰,从艰难自学到找到实习,从备战秋招到...

    牛客网
  • 从机械自动化专业到Java工程师转行之路

    秋招已经过半,突然想写篇文章总结下自己的 Java 转行之路和秋招提前批、暑期实习的面试经历及个人感悟。因为要写的东西比较多,拆分成三篇:

    乔戈里
  • 读者上岸阿里的硬核经验分享

    大家好,我是石头哥,最近正值校招季,这里分享一篇硬核校招面经,希望对大家有帮助。

    程序猿石头
  • 大学四年Java学习路线规划,所有私藏资料我都贡献出来了,我要是早知道就好了

    首先我不是来打广告的,此篇内容会涉及到很多产品,我只是贡献出来学习工具途径,读者自己衡量。

    阿甘的码路
  • 机器学习实习生面试总结(阿里 腾讯等)

    今年来一直在找暑期实习,现在基本已经确定了,前后历经差不多2个月吧,发现了很多自己的缺点,同时也希望写出来供需要的人参考了解 先说下我自己的情况吧,决定去腾讯T...

    GavinZhou
  • 2015腾讯暑期实习生 Web前端开发 面试经历

    试题上一般都会涉及:操作系统、数据库、计算机网络、C/C++、编译原理、概率论、算法、更甚的还出现js、ios ...

    书童小二
  • 春招/秋招面试前必看一文

    春节过完,不管是大三/研二、还是大四/研三,就要投入到最激烈的春招当中去了,各大公司将会正式招聘,由元旦期间拉开序幕(1 - 2 月),到彻底的进入白热化阶段(...

    乔戈里
  • 回馈牛客,校招总结(从一心想进银行到最后选择了互联网)

    简介:女生,小硕,非科班,暑假前投过一些实习,毫无疑问,全挂。因为什么都不懂,研究生期间主要做的理论研究,跟计算机毫不相关,并不涉及编程,也没有学过数据结构和数...

    牛客网
  • 找实习中的一些困惑,如何解决?

    对于大三/研二的来说,已经到了春招找暑期实习备战阶段了(最迟学校期末考完试),这个时间点是最合适的,实习怎么找?可以先看一下我之前写的一篇:

    乔戈里
  • 肝了一天,帅地今天一定把春秋招讲清楚+贡献自己整理的资料

    对于日后需要找工作的同学来说,春招/秋招可以说是学生生涯中非常重要的一战,但是我发现很多人却对春秋招的了解甚少,有些人甚至以为是毕业之后再开始找工作,进而导致了...

    帅地
  • 大学四年

    2017年6月26日21时,此时此刻,漫步在学校的马路上,努力走遍学校的每一个角落,努力的回忆在这四年中发生的点点滴滴,在这最后的时刻,沉淀下大学四年的所有。 ...

    haifeiWu
  • 顺丰科技AI产品经理面经

    牛客网
  • 说几件小事

    熟悉我的朋友应该知道,从大概3个月前,我开源了一个后端(偏Java方向)的学习/指南文档。Github地址为:https://github.com/Snailc...

    用户2164320
  • 漫漫大学江湖录 - 爱与恨唯与工作更交织

    其实在18年11月有了华为,就已经宣告结束了大学校招历程,是时候写下总结了,再不写估计很多东西都忘了。

    JavaEdge
  • 在字节跳动的实习经历分享 | 万字求职指南

    原来是字节跳动公司发来的周年庆祝福,看到这个短信,我真是太激动了!瞬间回想起了当年在字节跳动实习的往事,眼泪止不住地往下流啊,好想大喊一句,爷的青春回来啦!

    程序员鱼皮

扫码关注云+社区

领取腾讯云代金券