为什么领导都讨厌准点下班的人

今天刷到个帖子，一位室内设计的小哥哥发帖说："为什么领导都讨厌准点下班的人？"

这问题问得好，确实值得琢磨。为什么准点下班这么正常的事情，在职场里却成了问题？

各方观点

先看看大家都是怎么说的：

❝某设计师：因为肤浅，很多领导都是以上班时间长短衡量员工是否优秀，他们懒得去考量员工的工作成果，只看这些表面的东西。

这话说得直白。

❝某后端开发：不讨厌，是讨厌没结果还准点下班的。

这话说到点子上了。

❝某门店管理：讨厌准点下班且没产出的吧，你产出多谁管你什么时候下班啊。

这话说得实在。

从不同角度看

看完评论区，换个思路想想。

领导为什么讨厌准点下班：

第一，很多领导以上班时间长短衡量员工是否优秀。他们懒得去考量员工的工作成果，只看表面的东西。你准点下班，他们就觉得你不努力。

第二，因为领导把自己个人的无能归咎于团队的不努力。团队没做好，不是领导的问题，是员工不够努力，所以员工必须加班。

第三，权力带来的控制欲。买了你的时间，就要让你多提供一点增值服务，这是权力的体现。

第四，有些领导从来就没有准点下班过，看到别人准点下班，心里不平衡。这是嫉妒。

但话说回来，准点下班本身不是问题：

第一，准点下班基本上就是分内的事。工作时间内完成分内的工作，准时下班没毛病。

第二，如果你产出多，谁管你什么时候下班。讨厌的是准点下班且没产出的人，不是准点下班本身。

第三，很多公司不讲效率，领导只是认为他买了你的时间，所以多工作一点理所当然。但问题是，效率高的人应该被鼓励，而不是被打压。

准点下班的边界

这么说吧，这事儿得分情况：

1. 工作单一，没有上下游

如果你的工作很单一，没有上下游，也没有人加班，准点下班没什么问题。这个世界并不是非黑即白。

2. 有上下游协作

如果你的下游或者上游在加班，对接的你的东西出了问题，找不到人，领导擦屁股，那就不合适了。没责任心。

3. 团队都在攻坚

团队都在加班，你准点走确实不合群。这时候就多留一会，和大家一起。偶尔准点走没事，天天准点走确实说不过去。

4. 工作没完成

工作没完成就准点下班，这确实是问题。准点下班的前提是工作已经完成。

怎么看准点下班

从实际角度看，准点下班本身不是问题，关键看你有没有产出。

如果你产出多，准点下班说明你效率高，这是好事。领导应该欣赏你，而不是讨厌你。

如果你没产出还准点下班，那确实有问题。工作时间内没完成分内的工作，准点下班就说不过去了。

还有就是，有些领导就是喜欢看加班，不管你有没有产出。这种领导，要么是你产出不够让他满意，要么就是他思维有问题。遇到这种领导，要么提升产出，要么换公司。

给打工人几条建议

1. 确保产出：准点下班的前提是工作已经完成，产出到位。没有产出还准点下班，确实说不过去。
2. 看准时机：平时正常工作准点走没问题，但团队攻坚、上下游在加班的时候要适当配合。
3. 理解边界：如果你的工作有上下游，要注意别人加班的时候你能不能联系上。不要因为准点下班影响团队。
4. 灵活应对：根据公司文化、团队情况、领导风格调整自己的节奏。有的公司看重结果，有的公司看重过程，灵活应对最重要。
5. 必要时沟通：如果领导就是喜欢看加班，不管产出，该沟通就沟通，该换公司就换公司。

算法题：第49题-字母异位词分组

今天咱们来刷道中等难度的题：字母异位词分组。

题目描述

给你一个字符串数组，请你将字母异位词组合在一起。可以按任意顺序返回结果列表。

字母异位词是由重新排列源单词的所有字母得到的一个新单词。

示例：

输入: strs = ["eat","tea","tan","ate","nat","bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

输入: strs = [""]
输出: [[""]]

输入: strs = ["a"]
输出: [["a"]]

思路

字母异位词的特点是：如果将字符串的字符排序，那么所有字母异位词排序后得到的字符串都是相同的。

所以我们可以：

1. 遍历每个字符串
2. 对字符串的字符进行排序
3. 以排序后的字符串作为key，将原字符串存入对应的列表
4. 最终返回所有列表

代码实现

package main

import (
"fmt"
"sort"
)

func groupAnagrams(strs []string) [][]string {
// 用map存储，key是排序后的字符串，value是字母异位词列表
 anagrams := make(map[string][]string)

for _, str := range strs {
// 将字符串转为字符数组并排序
  chars := []byte(str)
  sort.Slice(chars, func(i, j int) bool {
   return chars[i] < chars[j]
  })

// 用排序后的字符串作为key
  key := string(chars)

// 将原字符串存入对应列表
  anagrams[key] = append(anagrams[key], str)
 }

// 将map转为结果切片
 result := make([][]string, 0, len(anagrams))
for _, group := range anagrams {
  result = append(result, group)
 }

return result
}

func main() {
// 测试用例
 strs1 := []string{"eat", "tea", "tan", "ate", "nat", "bat"}
 fmt.Println(groupAnagrams(strs1))

 strs2 := []string{""}
 fmt.Println(groupAnagrams(strs2))

 strs3 := []string{"a"}
 fmt.Println(groupAnagrams(strs3))
}

复杂度分析

• 时间复杂度：O(n * k * log k)，其中 n 是字符串数量，k 是字符串的平均长度
• 空间复杂度：O(n * k)，需要存储所有字符串

进阶思路

如果不想排序，可以用字符计数作为key。比如 "abb" 可以表示为 "a1b2"，这样所有字母异位词的计数字符串都是一样的。

package main

import (
"fmt"
"strings"
)

func groupAnagrams(strs []string) [][]string {
 anagrams := make(map[string][]string)

for _, str := range strs {
// 统计每个字符的出现次数
  count := make([]int, 26)
for _, c := range str {
   count[c-'a']++
  }

// 生成key字符串
var builder strings.Builder
for i := 0; i < 26; i++ {
   if count[i] > 0 {
    builder.WriteByte(byte('a' + i))
    builder.WriteString(fmt.Sprintf("%d", count[i]))
   }
  }
  key := builder.String()

  anagrams[key] = append(anagrams[key], str)
 }

 result := make([][]string, 0, len(anagrams))
for _, group := range anagrams {
  result = append(result, group)
 }

return result
}

这种方法时间复杂度是 O(n * k)，空间复杂度还是 O(n * k)，但实际运行更快，因为不需要排序。