Posted on

题目描述

请实现一个函数，将一个字符串中的每个空格替换成 “%20”。例如，当字符串为 We Are Happy. 则经过替换之后的字符串为 We%20Are%20Happy。

替换空格

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public String replaceSpace(StringBuffer str) {
    if (str == null || str.length() == 0){
        return "";
    }
    // 1. 得到原来字符串的长度
    int originLength = str.length();
    // 2. 计算空白格的个数
    int blankNumber = 0;

    for (int i = 0; i < originLength; i++){
        if (str.charAt(i) == ' '){
            ++blankNumber;
        }
    }
    //3. 拿到新的字符串长度
    int newLength = originLength + blankNumber * 2;

    //4. 用两个指针分别指向 原来字符串的最后一个字符 和 新的字符串的最后一个字符
    int originIndex = originLength - 1;
    int newIndex = newLength - 1;
    // 5. 更新 StringBuffer 的长度
    str.setLength(newLength);

    while (originIndex >= 0 && newIndex > originIndex){
        if (str.charAt(originIndex) == ' '){ // 如果字符为空，那么替换为 %20，newIndex 逐步向前移动
            str.setCharAt(newIndex--, '0');
            str.setCharAt(newIndex--,'2');
            str.setCharAt(newIndex--,'%');
        } else { //如果字符不为空，那么将原有字符串的字符 复制 到 新的字符串的位置上
            str.setCharAt(newIndex--, str.charAt(originIndex));
        }
        --originIndex; //操作一次，原有指针都要往前移动
    }
    return str.toString();
}

Posted on

1. 进程概念

1.1 进程的定义

  • 进程是程序在某个数据集合上的一次运行活动
  • 数据集合：软 / 硬件环境，多个进程共存 / 共享的环境

1.2 进程的特征

  • 动态性：进程是程序的一次执行过程，动态产生 / 消亡
  • 并发性：进程同其他进程一起向前推进
  • 异步性：进程按各自速度向前推进
  • 独立性：进程是系统分配资源和调度 CPU 的单位

1.3 进程和程序的区别

  • 动态和静态

进程是动态的：程序的一次执行过程
程序是静态的：一组指令的有序集合

  • 暂存和长存

进程是暂存的：在内存驻留
程序是长存的：在介质上长期保存

  • 程序和进程的对应

一个程序可能有多个进程

1.4 进程的类型

2. 进程控制

3. 线程

4. 临界区和锁

5.同步和 P-V 操作

6. Windows 和 Linux 的同步机制

7. 进程通信

Posted on

腾讯

1. 职级

腾讯职级体系分 6 级，最低 1 级，最高 6 级。同时按照岗位又划分为 四大通道，内部也叫“族”，比如：

  • 产品 / 项目通道，简称 P 族
  • 技术通道，简称 T 族
  • 市场通道，简称 M 族
  • 职能通道，简称 S 族

以 T 族为例，分别为：

  • T1：助理工程师 （一般为校招新人）
  • T2：工程师
  • T3：高级工程师 3-1 相当于 阿里的 p6 到 p7（能力强可能到 p7）
  • T4：专家工程师
  • T5：科学家
  • T6：首席科学家

每一级之间又分为 3 个子级，3-1 是任命组长 / 副组长的必要条件，其他线也是这样。T4 基本为总监级，也不排除有T 3-3 的总监，因为 T4 非常难晋级。

不过在不久前宣布调整职级，取消了原有的 6 级 18 等（1.1 - 6.3 级）的职级体系设计，将专业职级体系优化为 14 级 (4 - 17 级).

2. 晋升

腾讯的晋级还是很困难的。尤其是T2 升T3，T3升T4。非常多的人卡在2-3,3-3没办法晋级。有的小伙伴做了3、4年的2-3 也升不上去啊.

3. 薪水

腾讯薪资架构：12 1 1=14薪

年终奖：看部门盈利情况，一般是3个月

级别越高 base 薪酬也越高，一年根据你的 performance 大概能发 15.3 个月 至 18 个月的工资，T3.1 的 base 2w ，T3 以上级别的员工都会有股票期权，腾讯 09 以前的员工赚钱主要靠股票，从 08 到现在股票 up 了 500% ，T5 的 base 薪酬在 600w ~ 800w / 年.

阿里巴巴

1. 职级

阿里的职称大部分都归纳在 P 序列, 你的 title 工种。比如 P7 产品经理 = 产品专家.

  • 一般到 P3 为 助理
  • P4 = 专员
  • P5 = 资深专员
  • P6 = 高级专员（也可能是高级资深）
  • P7 = 专家
  • P8 = 资深专家（架构师）
  • P9 = 高级专家（资深架构师）
  • P10 = 研究员
  • P11 = 高级研究员
  • P12 = 科学家
  • P13 = 首席科学
  • P14 = 马云

同时对应 P 级还有一套管理层的机制在：

  • M1 = P6 主管
  • M2 = P7 经理
  • M3 = P8 资深经理
  • M4 = P9 总监
  • M5 = P10 资深总监
  • M6 = P11 副总裁
  • M7 = P12 资深副总裁
  • M8 = P13 子公司CEO 或集团其他O
  • M9 = P14 陆兆禧（前马云）

在阿里早些时候 P 级普遍偏低，专员可能是 P2 这样，后来有了一次 P 级通货膨胀，出现了更多的 P 级。在阿里只有P6（M1）后才算是公司的中层。不同的子公司给出 P 级的标准不一样。

比如：B2B 的普遍 P 级较高，但是薪资水平低于天猫子公司的同级人员。同时到达该 P 级员工才有享受公司 RSU 的机会。（低于 P6 的除非项目出色有 RSU 奖励，否则 1 股都拿不到）

2.晋升

晋升很简单：

  1. 晋升资格：上年度KPI达3.75。

  2. 主管提名。一般KPI不达3.75主管不会提名。

  3. 晋升委员会面试。（晋升委员会组成一般是合作方业务部门大佬、HRG、该业务线大佬等。）

  4. 晋升委员会投票。

P5 升 P6 相对容易，再往上会越来越难，一般到P7都是团队技术leader了，P6到P7非常难，从员工到管理的那一步跨出去不容易，当然有同学说 P 一般都是专家，M 才是管理，actually，专家线/管理线有时并不是分的那么清楚的.

3. 薪水

  • 阿里薪资结构：一般是12 1 3 = 16薪
  • 年底的奖金为 0-6 个月薪资，90% 人可拿到 3 个月
  • 股票是工作满 2 年才能拿，第一次拿 50%，4 年能全部拿完

百度

1. 层级

百度的级别架构分成四条线。

  • 技术序列 T：T3 - T11 （一般对应阿里高一级序列，如：百度T3 = 阿里P4，T5 / T6属于部门骨干，非常抢手，人人猎中相当一部分 offer 人选都来自这个序列）

  • 产品运营序列 P：p3 - P11 （产品和运营岗，对应阿里高1-1.5级序列 百度p3=阿里P4-P5之间)

  • 后勤支持部门 S：S3 - S11 (主要是公共、行政、渠道等等，晋升比较困难)

  • 管理序列 M：M1 - M5 (每一级又分为 2 个子级 M1A、M1B , 最低的是 M1A，至少是部门二把手了，李明远是 M3.2，以前的汤和松都是这个级别，李彦宏是唯一的 M5，其实从 M3 开始就有机会加入 E——star，类似于阿里的合伙人会议，属于最高战略决策层.

2. 薪资

月薪 14.6（12 0.6 2）, 其他岗位：月薪 14

T5 以上为关键岗位，另外有股票、期权。T5、T6占比最大的级别，T8、T9占比最小，级别越高，每档之间的宽幅越大。

3. 晋升

基本上应届毕业生应该是 T3，但是内部晋升非常激烈。公司那么大，部门和部门之间有业务竞争，肯定也有人才竞争。

通常应届毕业生入职1年多能升到 T4，但如果你的部门业务足够核心，或许 1 年就可以了。3 年升 T5。从目前百度的情况来看，核心工程师集中在 T5 / 6，但是从 5/6 到 7是非常艰难的过程。

百度是很唯 KPI 至上的，其次部门很核心，再次老大话语权比较高，相对晋升容易些。

一般情况分2种：

  1. 自己提名，当你自己觉得已经具备下一 level 的素质，可以自己提名，提名后进入考察期，主管设定考察期目标，考察通过顺利晋升，考察不通过维持原层级不变；

  2. 主管提名，如果是主管提名，一般都是直接通过的，但是如果你现层级已经比较高了，那就不是直接提名这么简单了。

P.S. 如果你能升到 T7，基本上是 TL 的级别，写代码 / 直接做业务的时间就很少了.

虽然 BAT 们的技术岗位定着高大上的职级、拿着令人艳羡的薪资，但其实很多人在很多年里都会困在某一职级上停步不前，工作经验的积累并不能带来工作上的平滑晋升。

BAT 内部技术晋升有多难？

以阿里巴巴技术岗为例，很多人入职时可以拿到 P5、P6 的定级，但从 P6 到 P7 升级是一个坎，很多人会卡在 P6 级别上一两年甚至更久。而从 P7 到 P8 就更不容易了。再往上，从 P8 到 P9 的升级会更难，要的不仅是业界影响力，还需要有足够的运气。而从 P9 到 P10，难度更上一层楼，猎头直言：“这个级别需要做出像钉钉、咸鱼式的产品才有机会”。当成功晋升 P10 时，已经是管理线的 M5 级别，有机会进入阿里组织部，这个级别的技术人跳槽就很少了，一般都是出去创业。

腾讯的技术晋升也不容易。在腾讯旧的职级体系下，T3-3 升 T4-1 是一个大坎，停留在 T3-3 超过 5 年的不在少数，停留 7 年的也有。一旦进入 T4 级别，就是腾讯的专家工程师了，腾讯研发人数将近 2 万人，T4 级别的人数大概也不超过 500 人，这还是在近两年 T3 到 T4 级别人数增多的情况下。

工程师的晋升方式，不同公司之间的规则不尽相同。以阿里为例，每年 4 月份会组织一次工程师答辩。评委会由阿里技术线的高级程序员组成，对绩效考核达到 3.75 的员工进行考核答辩，通过者方能成功晋级。当然，如果你能做出惊天地泣鬼神的产品，跳级晋升也不是什么难事。

基本功扎实、技术能力过硬，这是技术线较低级别晋升的共性。但当发展到中、高级技术路线时，技术能力就不再是唯一重要的考核标准，具不具备良好的产品感觉、做没做过完整的技术架构、懂不懂业务痛点、商业思维，都是晋升必不可少的要素。

Posted on

题目描述： 给定两个有序的，不含有重复值的链表，请将这两个有序链表进行原地合并，并且保证合并后的链表中，不包含重复数据.

输入输出示例：

  • Example 1 : 1 -> 3 -> 5 和 1 -> 2 -> 4，合并结果：1 -> 2 -> 3 -> 4 -> 5
  • Example 2 : 2 -> 5 -> 7 和 1 -> 3，合并结果：1 -> 2 -> 3 -> 5 -> 7

题目分析

1
2
3
4
5
6
7
8
9
// 结点结构
static class Node {
        int val;
        Node next;

        public Node(int val) {
            this.val = val;
        }
    }
  1. 给定两个有序的，不包含重复数据的链表，我们在进行合并的时候，就有可能存在重复数据，所以需要进行去重操作；
  2. 这两个有序链表需要进行原地合并，所以，我们不能像一般的方法一样，去新建一个头结点. 然后，分别去比较和扫描两个有序链表，将结点中的较小数值的数据 new 出 新的Node ，放在头结点之后.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public Node mergeSortedListWithoutDuplicates(Node node1, Node node2) {
        //1.首先，根据两个结点情况判空，高效返回
        if (node1 == null) {
            return node2;
        }
        if (node2 == null) {
            return node1;
        }
        //2. 新建一个结点，指向结点值较小的那个
        Node head = (node1.val <= node2.val) ? node1 : node2;
        //3. 创建两个指针，动态的指向 node1 和 node2
        Node prev = head;
        Node point = null;

        while (node1 != null && node2 != null) {
            if (node1.val <= node2.val) {
                point = node1;
                node1 = node1.next;
            } else {
                point = node2;
                node2 = node2.next;
            }
            if (prev.val != point.val) {
                prev.next = point;
                prev = point;
            }
        }

        //处理多余结点
        while (node2 != null) {
            if (prev.val != node2.val) {
                prev.next = node2;
                prev = node2;
            }
            node2 = node2.next;
        }

        while (node1 != null) {
            if (prev.val != node1.val) {
                prev.next = node1;
                prev = node1;
            }
            node1 = node1.next;
        }
//        将最后一个结点的下一个结点置位 null
        prev.next = null;
        return head;
    }

Posted on

题目描述

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

利用最关键的一句话：每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public boolean Find(int target, int[][] array) {
        int rows = array.length;
        int cols = array[0].length;
        int i = rows - 1;
        int j = 0;
        while(i >= 0 && j < cols){
            if (target < array[i][j]) {
                i--;
            } else if(target > array[i][j]) {
                j++;
            } else {
                return true;
            }
        }
        return false;
    }