这两天爆火的字节小作文,不知道大家看了没有。
标题是《给字节卖命两年,被恶意劝退并要求退还全部工资》。
知道你们爱省流。
原因:违反竞业协议;金额:60W。
首先,我要对爆料当事人表示同情,这个结果足以摧毁任何一个在城打工的异乡人。
但回归理性,容易发现这篇幅巨大的小作文,缺乏一些核心要素,还可以做得更好。
容易被攻击"避重就轻"。
对于爆料当事人,从文章上来看,ta 至少具备如下优秀品质:
还得是字节,连写个爆料文都这么有"字节范"。
从职业素养上,作者已经秒杀了脉脉上 95% 以上爆料人。
欲抑先扬,然后再说说,我个人觉得做得不好的几个地方:
+1
、+2
以及相关的 HRBP 都采取了实名,但自身没有实名。这个首先从道德上,不太站得住脚,而且极可能会额外引发不必要的麻烦。
如果只是想简单叙述,可以采取给对方化名的方式;
如果是对对方过往行为有所怀恨,怀着朴素但又直接的报复心态,想让对方社死。
emmmm,不认同这种做法但可表示对情绪上的理解。但即使从"坏人"的角度出发,直接在全文实名称呼对方也不是一种高效的、具有传播力的做法。
实名对于广大网友来说,没有意义,知道这个人是谁,网友也不能替你怎么样;这层实名的更大意义是对字节内部,那么隐约指出相比于直接指出,更有优势。
对字节高层而言,不带实名,不会有公关团队以外的部门对此发力,消息在往上传递的阻力会更小;
对字节内部普通吃瓜群众而言,不带实名,更能引起广泛讨论,神秘化的处理能够在转发之间,增加吃瓜群众的参与感,也更容易产生长尾流量效应;
如果实在有其他需要点名对方的理由,那么至少也应该在交代人物关系的时候,将包含自己的关系也进行抛出;
综上,只让对方实名,自身不实名,无论是从理性人还是坏人角度来分析,都不是好的处理,除了能够给到当事人心理上的优势和安慰,起不到任何正面作用。+1
、+2
和 HR 在在职期间对自己存在针对行为,导致自己从抖音跳到快手,但自认为没有违反竞业协议,现如今的被起诉也觉得是由这几位前同事发起主导。
这部分的猜测其实不太符合常规理解,通常不发起竞业起诉才是常态,真的发起,也是由法务部做决策,法务部通常是比财务部更加独立的部门,不太可能是当事人的猜测的情况。
退一万步,真的由几位相关人员向法务部申请,法务部也会结合材料,至少符合竞业协议中的两条以上的规则,才会真的进行发起竞业起诉,不会是无的放矢。...
因此,如果你问我对这篇小作文怎么看。
我会顺便跟你分享,我对于一般性的"第一人称爆料"会怎么去看
通常这些小作文,绝大概率是真假掺半。
这里说的假不一定是捏造事实,更多的是指同一事情,刻意的叙事角度和情绪化表达,会对读者的立场,产生几乎是决定性的作用。
身陷囹圄,是几乎不可能写出理性的爆料文。
而且通常绝对理性的人,一般也走不到曝光这一步。
因此,对于这篇小作文,我个人觉得:
...
回归主线,也不知道谁是对的,随便做道题目吧。
平台:LeetCode
题号:18
给定一个包含
个整数的数组 nums
和一个目标值 t
。
判断 nums
中是否存在四个元素 a
,b
,c
和 d
,使得 a + b + c + d
的值与 t
相等?
找出所有满足条件且不重复的四元组。
注意:答案中不可以包含重复的四元组。
示例 1:
输入:nums = [1,0,-1,0,-2,2], t = 0
输出:[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2:
输入:nums = [], t = 0
输出:[]
提示:
对数组进行排序,使用四个指针 i
、j
、k
和 p
分别代表要找的四个数。
i
确定第一个数,枚举 j
确定第二个数,另外两个指针 k
和 p
分别从左边 j + 1
和右边 n - 1
往中间移动,找到满足 nums[i] + nums[j] + nums[k] + nums[p] == t
的所有组合。k
和 p
指针的移动逻辑,分情况讨论 sum = nums[i] + nums[j] + nums[k] + nums[p]
:sum
> t
:p
左移,使 sum
变小sum
< t
:k
右移,使 sum
变大sum
= t
:将组合加入结果集,k
右移继续进行检查题目要求不能包含重复元素,所以我们要对 i
、j
和 k
进行去重,去重逻辑是对于相同的数,只使用第一个。
Java 代码:
class Solution {
public List<List<Integer>> fourSum(int[] nums, int t) {
Arrays.sort(nums);
int n = nums.length;
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < n; i++) { // 确定第一个数
if (i > 0 && nums[i] == nums[i - 1]) continue; // 对第一个数进行去重(相同的数只取第一个)
for (int j = i + 1; j < n; j++) { // 确定第二个数
if (j > i + 1 && nums[j] == nums[j - 1]) continue; // 对第二个数进行去重(相同的数只取第一个)
// 确定第三个数和第四个数
int k = j + 1, p = n - 1;
while (k < p) {
// 对第三个数进行去重(相同的数只取第一个)
while (k > j + 1 && k < n && nums[k] == nums[k - 1]) k++;
// 如果 k 跳过相同元素之后的位置超过了 p,本次循环结束
if (k >= p) break;
long sum = 0L + nums[i] + nums[j] + nums[k] + nums[p];
if (sum == t) {
ans.add(Arrays.asList(nums[i], nums[j], nums[k], nums[p]));
k++;
} else if (sum > t) {
p--;
} else if (sum < t) {
k++;
}
}
}
}
return ans;
}
}
C++ 代码:
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int t) {
sort(nums.begin(), nums.end());
int n = nums.size();
vector<vector<int>> ans;
for (int i = 0; i < n; i++) {
if (i > 0 && nums[i] == nums[i - 1]) continue;
for (int j = i + 1; j < n; j++) {
if (j > i + 1 && nums[j] == nums[j - 1]) continue;
int k = j + 1, p = n - 1;
while (k < p) {
while (k > j + 1 && k < n && nums[k] == nums[k - 1]) k++;
if (k >= p) break;
long sum = 0L + nums[i] + nums[j] + nums[k] + nums[p];
if (sum == t) {
ans.push_back({nums[i], nums[j], nums[k], nums[p]});
k++;
} else if (sum > t) {
p--;
} else if (sum < t) {
k++;
}
}
}
}
return ans;
}
};
Python 代码:
class Solution:
def fourSum(self, nums: List[int], t: int) -> List[List[int]]:
nums.sort()
n = len(nums)
ans = []
for i in range(n):
if i > 0 and nums[i] == nums[i - 1]: continue
for j in range(i + 1, n):
if j > i + 1 and nums[j] == nums[j - 1]: continue
k, p = j + 1, n - 1
while k < p:
while k > j + 1 and k < n and nums[k] == nums[k - 1]:
k += 1
if k >= p: break
_sum = nums[i] + nums[j] + nums[k] + nums[p]
if _sum == t:
ans.append([nums[i], nums[j], nums[k], nums[p]])
k += 1
elif _sum > t:
p -= 1
elif _sum < t:
k += 1
return ans
TypeScript 代码:
function fourSum(nums: number[], t: number): number[][] {
nums.sort((a, b) => a - b);
const n = nums.length;
const ans = [];
for (let i = 0; i < n; i++) {
if (i > 0 && nums[i] === nums[i - 1]) continue;
for (let j = i + 1; j < n; j++) {
if (j > i + 1 && nums[j] === nums[j - 1]) continue;
let k = j + 1, p = n - 1;
while (k < p) {
while (k > j + 1 && k < n && nums[k] === nums[k - 1]) k++;
if (k >= p) break;
const sum = nums[i] + nums[j] + nums[k] + nums[p];
if (sum === t) {
ans.push([nums[i], nums[j], nums[k], nums[p]]);
k++;
} else if (sum > t) {
p--;
} else if (sum < t) {
k++;
}
}
}
}
return ans;
};
i
和 j
是直接枚举确定,复杂度为 ,当确定下来 i
和 j
之后,通过双指针确定 k
和 p
,也就是对于每一组 i
和 j
而言复杂度为
。总的复杂度为
我是宫水三叶,每天都会分享算法题解,并和大家聊聊近期的所见所闻。
欢迎关注,明天见。