京东各职级薪资一览表

大家好，我是苍何。

准备搬家，在京东上看了打包带，相较于淘宝和拼多多，价格上可以说丝毫没有优势可言。

有时，我又在想，那为什么还要来京东买？

我翻遍了购物车，发现每次的京东购物不是为了贪图次日达，就是图他质量有保证，特别是电子产品，基本就只选京东了。

这样也好，有自己的竞争优势总能让人想起他，就像单纯的贪图便宜我会去拼多多一样，想搞某些 pojie 软件，就去万能的宝。

说到京东，比较好奇的有以下三点：

1、京东内部职级是怎么划分的？

2、不同职级薪资能到多少？

3、校招薪资白菜价能到多少？

我们先来看看京东内部的职级。

通常情况下，校招本科为 T2，硕士为 T3，T3-T6 为京东主力军，通常是社招 3-5 年经验，T7 算是一道坎，差不多算是一线小 leader 了。

可以看到但凡是大公司，对职级都会有严格的划分，每一级什么能力，能拿到多少钱，怎么晋升，都规划的明明白白的。

这样让人容易产生一种错觉，仿佛去了那里就能平步青云，不断晋升，干他一辈子，但往往多数情况还没等来晋升，人就被开了，当初的誓言也成了不臭不响的臭屁。

当然这种好处就是可以有期盼，没有人不喜欢希望。

那这么多职级对应能拿到多少薪资呢？由于 M 系列离普通人太遥远，这里就以技术岗 T 系列来看看。

这里的年包只是 base 薪资+年终奖+股票，还没算上餐补、工龄补贴等这些，年终奖根据最新的是 base 的 8 个月.

等级到了 T7 开始有股权激励，年包能到 100 w 了，T8，T9，T10属于技术专家了，年薪都突破100万。

而 T10 是首席科学家的头衔，是传说中的人中龙凤，薪资待遇 500 万以上（高的离谱😂）。

下面再来看看校招入狗东，能拿到多少钱？

白菜价是普通档，SP 是“特殊offer”的缩写，这类offer比普通offer要高一些，SSP是“超级特殊offer”的缩写通常给予面试中的佼佼者或极为出色的候选人，钱也会更多。

京东狗不狗我不知道，但这薪资真的很不错了，有些甚至是多少人穷尽一生的天花板。

想要冲刺京东秋招，可以直接在京东招聘官网：https://campus.jd.com/，投递简历，京东提供了新星计划和实习生计划，给给为天选之子们不少机会。

京东今年校招直接就放出了 1.8 万个，直接就超越了拼多多员工总数🐶，有 1.2 万个应届岗，6000 个实习岗。

光贡献就业这一点，无 fuck 说。

还没投递的人才们，可以冲一波京东。

好啦，关于京东职级薪资，你有什么补充的呢？欢迎评论区讨论。

…

回归主题。

今天来一道京东开发考过的面试算法题，给枯燥的牛马生活加加油😂。

• 《RocketMQ 从入门到精通》 原创电子书免费下载（面试必背）
• 面试官看了就喜欢的简历模板免费下载！
• PmHub-开源项目-助你拿个好 offer。

题目描述

平台：LeetCode

题号：290

题目名称：单词规律

给定一种规律 pattern 和一个字符串 s，判断 s 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如，pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

示例 1：

输入: pattern = "abba", s = "dog cat cat dog"
输出: true

示例 2：

输入: pattern = "abba", s = "dog cat cat fish"
输出: false

示例 3：

输入: pattern = "aaaa", s = "dog cat cat dog"
输出: false

提示：

• 1 <= pattern.length <= 300
• pattern 只包含小写英文字母
• 1 <= s.length <= 3000
• s 只包含小写英文字母和 ' '
• s 不包含任何前导或尾随空格
• s 中每个单词都被 单个空格 分隔

解题思路

这道题的关键是判断 pattern 中的每个字符是否和字符串 s 中的每个单词保持双向的映射关系，即字符和单词一一对应。我们可以采用两个哈希表（字典）分别记录：

1. pattern 中的字符到 s 中单词的映射关系；
2. s 中单词到 pattern 中字符的映射关系。

如果 pattern 中某个字符已经映射到某个单词，则该字符再次出现时，必须映射到同一个单词；同理，s 中的单词也必须映射到同一个字符。如果任一方向的映射关系出现冲突，则返回 false。

具体步骤：

1. 先将字符串 s 按照空格分割成单词数组。
2. 如果 pattern 和单词数组的长度不一致，直接返回 false。
3. 遍历 pattern 和单词数组，使用两个字典分别记录字符和单词的对应关系，若出现不匹配则返回 false。
4. 遍历完成后，若所有匹配都成立，返回 true。

代码实现

Java 实现

import java.util.HashMap;

public class WordPattern {
    public boolean wordPattern(String pattern, String s) {
        String[] words = s.split(" ");
        if (pattern.length() != words.length) {
            return false;
        }

        HashMap<Character, String> charToWord = new HashMap<>();
        HashMap<String, Character> wordToChar = new HashMap<>();

        for (int i = 0; i < pattern.length(); i++) {
            char c = pattern.charAt(i);
            String word = words[i];

            if (charToWord.containsKey(c)) {
                // 如果字符c已经有映射但映射的单词不匹配
                if (!charToWord.get(c).equals(word)) {
                    return false;
                }
            } else {
                charToWord.put(c, word);
            }

            if (wordToChar.containsKey(word)) {
                // 如果单词已经有映射但映射的字符不匹配
                if (wordToChar.get(word) != c) {
                    return false;
                }
            } else {
                wordToChar.put(word, c);
            }
        }

        return true;
    }
}

C++ 实现

#include <iostream>
#include <unordered_map>
#include <sstream>
#include <vector>

using namespace std;

class Solution {
public:
    bool wordPattern(string pattern, string s) {
        vector<string> words;
        stringstream ss(s);
        string word;

        // 分割字符串s
        while (ss >> word) {
            words.push_back(word);
        }

        if (pattern.size() != words.size()) {
            return false;
        }

        unordered_map<char, string> charToWord;
        unordered_map<string, char> wordToChar;

        for (int i = 0; i < pattern.size(); i++) {
            char c = pattern[i];
            string word = words[i];

            if (charToWord.count(c)) {
                // 如果字符c已经有映射但映射的单词不匹配
                if (charToWord[c] != word) {
                    return false;
                }
            } else {
                charToWord[c] = word;
            }

            if (wordToChar.count(word)) {
                // 如果单词已经有映射但映射的字符不匹配
                if (wordToChar[word] != c) {
                    return false;
                }
            } else {
                wordToChar[word] = c;
            }
        }

        return true;
    }
};

Python 实现

def word_pattern(pattern: str, s: str) -> bool:
    words = s.split()
    if len(pattern) != len(words):
        return False

    char_to_word = {}
    word_to_char = {}

    for c, word in zip(pattern, words):
        if c in char_to_word:
            # 如果字符c已经有映射但映射的单词不匹配
            if char_to_word[c] != word:
                return False
        else:
            char_to_word[c] = word

        if word in word_to_char:
            # 如果单词已经有映射但映射的字符不匹配
            if word_to_char[word] != c:
                return False
        else:
            word_to_char[word] = c

    return True

复杂度分析

• 时间复杂度：O (n)，其中 n 是 pattern 的长度。我们遍历了 pattern 和 s 中的单词。
• 空间复杂度：O (n)，我们使用了两个哈希表来存储 pattern 中字符和 s 中单词的映射关系。

ending

你好呀，我是苍何。是一个每天都在给自家仙人掌讲哲学的执着青年，我活在世上，无非想要明白些道理，遇见些有趣的事。倘能如我所愿，我的一生就算成功。共勉 💪

点击关注下方账号，你将感受到一个朋克的灵魂，且每篇文章都有惊喜。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉