给出位向量的布尔运算

题目

给定一个包含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范围内没有出现在数组中的那个数。

示例 1：

输入：nums = [3,0,1]
输出：2
解释：n = 3，因为有 3 个数字，所以所有的数字都在范围 [0,3] 内。2 是丢失的数字，因为它没有出现在 nums 中。
示例 2：

输入：nums = [0,1]
输出：2
解释：n = 2，因为有 2 个数字，所以所有的数字都在范围 [0,2] 内。2 是丢失的数字，因为它没有出现在 nums 中。
示例 3：

输入：nums = [9,6,4,2,3,5,7,0,1]
输出：8
解释：n = 9，因为有 9 个数字，所以所有的数字都在范围 [0,9] 内。8 是丢失的数字，因为它没有出现在 nums 中。
示例 4：

输入：nums = [0]
输出：1
解释：n = 1，因为有 1 个数字，所以所有的数字都在范围 [0,1] 内。1 是丢失的数字，因为它没有出现在 nums 中。

提示：

n == nums.length
1 <= n <= 104
0 <= nums[i] <= n
nums 中的所有数字都 独一无二

进阶：你能否实现线性时间复杂度、仅使用额外常数空间的算法解决此问题?

思路

看到题目的时候靠直觉去写，就是循环 0-n，然后判断 n 在不在，不在就抛出，循环完后，还没找到，返回数组的长度

时间复杂度 n^2

发现可以用等差数列去做，计算等差数列的和，然后去掉数组内的数，最终的结果为缺失的数

还一个是用异或的方案

数组的数与0-n的数，全部进行异或，最终的数据为缺失的数

题解

自己实现的

1
2
3
4
5
6
7
8
9
10
11
12

impl Solution {
    pub fn missing_number(nums: Vec<i32>) -> i32 {
        for i in 0..nums.len() as i32 {
            if nums.contains(&i) {
                continue;
            } else {
                return i;
            }
        }
        nums.len() as i32
    }
}

看到别人题解后优化

1
2
3
4
5
6
7
8
9
10

impl Solution {
    pub fn missing_number(nums: Vec<i32>) -> i32 {
        let num_size: i32 = nums.len().try_into().unwrap();
        let mut total = (1 + num_size) * num_size / 2;
        for i in nums.iter() {
            total -= i;
        }
        total
    }
}

来源

• 作者：力扣 (LeetCode)
• 链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/xnj4mt/
• 来源：力扣（LeetCode）
• 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

有效的括号

题目

给定一个只包括 ‘(‘，’)’，’{‘，’}’，’[‘，’]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = “()”
输出：true
示例 2：

输入：s = “()[]{}”
输出：true
示例 3：

输入：s = “(]”
输出：false

提示：

1 <= s.length <= 104
s 仅由括号 ‘()[]{}’ 组成

题解

个人题解

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

impl Solution {
    pub fn is_valid(s: String) -> bool {
        let mut stack: Vec<char> = Vec::new();
        for c in s.chars() {
            if c == '{' {
                stack.push('}')
            } else if c == '[' {
                stack.push(']')
            } else if c == '(' {
                stack.push(')')
            } else {
                if let Some(i) = stack.pop() {
                    if i == c {
                        continue;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            }
        }
        stack.is_empty()
    }
}

官方题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#[allow(dead_code)]
impl Solution {
    pub fn is_valid(s: String) -> bool {
        let mut res: Vec<char> = Vec::with_capacity(s.len());
        let mut pre: Option<&char>;
        for c in s.chars() {
            pre = res.last();
            match (pre, c) {
                (Some('{'), '}') | (Some('['), ']') | (Some('('), ')') => {
                    res.pop();
                }
                _ => res.push(c),
            }
        }
        res.is_empty()
    }
}

思路

原本也没啥思路，就想着怎么处理字符串

然后发现解答里面有关于栈的问题，看了别人的解体思路后，比较明朗

匹配到左括号，向栈推入右括号

如果匹配到右括号，就把栈顶的括号推出，判断是不是为当前的右括号，如果是，代表括号闭合，如果不是，直接失败

匹配到右括号空栈也直接失败

最后判断栈的长度是不是为 0，如果为 0，代表完全匹配

emm

示例的代码写的比较精简，感觉可以复现一次

链接

• 作者：力扣 (LeetCode)
• 链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/xnbcaj/
• 来源：力扣（LeetCode）
• 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

卧槽，算错那么多

草，还是得用计算器？？？？

• 0x503c + 0x8 = 0x5044
• 0x503c - 0x40 = 0x50FC(0x4FFC)
• 0x503c + 64 = 0x507c
• 0x50ea - 0x503c = 0x50Ae(0xAE)

别做卷子了，废物，这都能错俩，还特么检查，你有脸检查？？？

完了，还是那么粗心。。

p-26-1

将 0x39A7F8 转换为二进制

001110011010011111111000

将二进制 1100100101111011 转化为十六进制

0xC97b

将 0xD5E4C 转换为二进制

11010101111001001011

将 1001101110011110110101 转化为十六进制

0x26e7B5

积分表结构设计

需求

• 记录积分行为来源
• 允许撤销用户积分
• 个人中心有展示总积分
• 未来积分可以兑换商品
• 未来积分逐条过期机制

分析

记录积分行为来源

• 需要增加行为枚举类，并且记录该行为对应的表主键，比如发帖需要对应发帖的内容 id
• 行为增加的分数，考虑到变动很少，可以放在代码中。如果后期确认该需求经常变动，需要建立对应的表结构，映射该枚举数据

1
2
3
4
5
6
7
8
9
10
11
12

// 积分枚举
enum ScoreSourceTypeEnum {
  LIKE = 1,
  COMMENT = 2,
  // ...
}
// 积分对应分数
const ScoreSourceTypeMap = new Map({
  [ScoreSourceTypeEnum.LIKE]: { score: 5, title: "点赞" },
  [ScoreSourceTypeEnum.COMMENT]: { score: 10, title: "评论" },
  // ...
});

允许撤销用户积分

• 撤销用户积分不能修改原始数据，应增加一条新纪录记录该行为，积分记录表允许负值或新建一个表记录数据(先采用允许负值方案)
• 撤销用户积分需要增加操作人，撤销的原因两个字段
• 增加一个撤销用户积分的行为，行为对应的主键为对应的积分记录 ID

积分逐条过期机制

• 积分记录表增加剩余积分字段，默认等于当前积分
• 用户消费积分时，判断剩余积分字段相加是否满足需求，如果满足，按时间倒序挨个去扣除剩余积分字段，直到扣除完毕
• 统计用户积分时，SUM（剩余积分）
• 每天跑一次定时任务，每次用户积分过期，剩余积分字段设置为 0

个人中心展示总积分

• 每次查询用户的积分数据，都需要 sum 方法，如果数据量多，性能会比较差
• 是否需要直接统计用户的积分，每次插入或删除去修改该数据
• 如果需要用户总积分，应独立于用户模块，新建一张表，统计用户总积分，以及用户积分相关数据

未来积分可以兑换商品

• 积分记录表增加商品兑换的行为，并记录订单 id

其他

• 并发问题（如果用户同时访问数据，一边增加一边消费，是否需要在数据库加锁，或使用单个消息队列来实现）
• 积分异常（如果突然出现大批量积分发放，每天应有积分监控功能，每日发放积分、扣减积分，总积分数据）

表结构

用户积分记录表

用户积分表(暂时不使用，数据库无法支撑再考虑)

不知道应该写点什么。

想到哪 写到哪吧。

都会有一段令人铭记在心的记忆，随着时间的流逝，逐渐变淡

已经感觉到了

最开始

后来

现在

嗯，这种情况也许不会持续很久。

也许到了说再见的时候

不知道是不是最坏的结果

但应该不是最好的

但

总是有些东西，在夜深人静的时候会想起来

想起来 就一阵难过

为什么当时热恋的两个人

到现在

em，可能分离两地的结果就是这样子吧

自己也没想着尝试改变什么

按班就不

一步步走到那个阶段

是你自己选择的

不应该埋怨什么

你当时做这件事情的时候 已经预见到了结果

这不是如你所愿

感性吗

不应该

应该是活该

晚上总是瞎J8想

就这吧

还有吗

木有了，就这。

希望她有更好的生活

路由器梅林clash下载地址

https://github.com/zusterben/plan_c

路由器关闭关键字检测

sed -i ‘s/\tdetect_package/\t# detect_package/g’ /jffs/softcenter/scripts/ks_tar_install.sh

问题

原来服务是稳定运行的，加了一个子进程功能后，服务器经常无法访问。

具体情况

• 除代码直接返回数据的接口，其他涉及到数据库 IO 的接口都无法访问
• 内存占用正常
• CPU 占用正常(待定)
• 抽风时间不固定
• 同一套数据库，其他接口服务正常

可能性猜测

• 数据库连接池有问题
• 子进程调用方式有问题
• 定时任务有问题

排查问题

排查日志记录，确定抽风是不是有固定的模式，业务。

• 最近一次 2022-09-19 07:00:00.0

  1 2 3 4 5 6

  85 [info] 2022-09-19 02:14:02.6 [ApiInterceptor] 126ms 61.165.44.200: 1184582: GET: /api/video: {"current":"1","pageSize":"20","orderBy":"id","order":"DESC","isProfessional":"true","isFake":"false"}: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (K HTML, like Gecko) Chrome/104.0.0.0 Safari/537.36 86 [info] 2022-09-19 07:00:00.0 [DayReportCron] 数据日报开始发送，是否是生产环境：true 87 [info] 2022-09-19 07:47:13.10 [ApiInterceptor] 30ms 180.162.130.187: -: GET: /api/sms: {}: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36 88 [info] 2022-09-19 07:47:19.3 [ApiInterceptor] 24ms 180.162.130.187: -: GET: /api/sms: {}: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36 89 [info] 2022-09-19 07:47:25.6 [ApiInterceptor] 22ms 180.162.130.187: -: GET: /api/sms: {}: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36 90 [info] 2022-09-19 09:47:21.8 [NestFactory] Starting Nest application...

• 倒第二次 2022-09-18 04:00:00.0

  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

  328 [info] 2022-09-18 03:30:02.0 [KeywordMonitorCommunityCron] 收到close事件，子进程收到信号 256120 329 [info] 2022-09-18 04:00:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 330 [info] 2022-09-18 04:30:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 331 [info] 2022-09-18 05:00:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 332 [info] 2022-09-18 05:30:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 333 [info] 2022-09-18 06:00:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 334 [info] 2022-09-18 06:30:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 335 [info] 2022-09-18 07:00:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 336 [info] 2022-09-18 07:00:00.0 [DayReportCron] 数据日报开始发送，是否是生产环境：true 337 [info] 2022-09-18 07:30:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 338 [info] 2022-09-18 08:00:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 339 [info] 2022-09-18 08:30:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 340 [info] 2022-09-18 09:00:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 341 [info] 2022-09-18 09:30:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 342 [info] 2022-09-18 10:00:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 343 [warn] 2022-09-18 10:04:53.5 [exceptionLogger] ::ffff:127.0.0.1: -: GET: /: {} A0002: 用户未登录 344 [warn] 2022-09-18 10:05:36.3 [exceptionLogger] ::ffff:127.0.0.1: -: GET: /: {} A0002: 用户未登录 345 [info] 2022-09-18 10:05:43.10 [ApiInterceptor] 27ms 117.143.104.164: -: GET: /api/sms: {}: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36 346 [info] 2022-09-18 10:07:57.10 [ApiInterceptor] 30ms 117.143.104.164: -: GET: /api/sms: {}: Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Mobile Safari/537.36 347 [info] 2022-09-18 10:10:14.10 [ApiInterceptor] 31ms 117.143.104.164: -: GET: /api/sms: {}: Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Mobile Safari/537.36 348 [info] 2022-09-18 10:11:53.2 [ApiInterceptor] 0ms 117.143.104.164: -: GET: /api: {}: apifox/1.0.0 (https://www.apifox.cn) 349 [warn] 2022-09-18 10:12:28.2 [exceptionLogger] ::1: 1288925: PATCH: /api/configuration/fake-user: {} A0001: 请求参数错误：fakeUsers must be an array 350 [info] 2022-09-18 10:14:21.3 [ApiInterceptor] 0ms 117.143.104.164: -: GET: /api: {}: apifox/1.0.0 (https://www.apifox.cn) 351 [info] 2022-09-18 10:14:22.7 [ApiInterceptor] 0ms 117.143.104.164: -: GET: /api: {}: apifox/1.0.0 (https://www.apifox.cn) 352 [info] 2022-09-18 10:14:23.6 [ApiInterceptor] 0ms 117.143.104.164: -: GET: /api: {}: apifox/1.0.0 (https://www.apifox.cn) 353 [info] 2022-09-18 10:14:24.4 [ApiInterceptor] 1ms 117.143.104.164: -: GET: /api: {}: apifox/1.0.0 (https://www.apifox.cn) 354 [info] 2022-09-18 10:16:33.2 [ApiInterceptor] 26ms 117.143.104.164: -: GET: /api/sms: {}: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36 355 [info] 2022-09-18 10:30:00.0 [KeywordMonitorCommunityCron] 社群关键字开始运行 356 [info] 2022-09-18 10:37:32.3 [NestFactory] Starting Nest application...

• 倒第三次 2022-09-17 03:30:02.1

  1 2 3

  94 [info] 2022-09-17 03:30:02.1 [KeywordMonitorCommunityCron] 收到close事件，子进程收到信号 145279 95 [info] 2022-09-17 03:35:45.7 [ApiInterceptor] 160ms 61.173.30.240: 1221394: GET: /api/oss/sts: {}: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36 96 [info] 2022-09-17 03:45:34.8 [ApiInterceptor] 141ms 61.173.30.240: 1221394: GET: /api/oss/sts: {}: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36

日志没有特征，确认是否是定时任务 bug

没有发现问题

暂时定为是数据库连接池问题

确认连接池问题

确认是否是连接池问题

有一段代码循环使用 sql，导致连接池被用尽。

尝试复现 BUG

1
2
3
4
5
6
7

const value = await PromiseTools.queue(list, async (item) => {
  const count = await this.labelCategoryDao.findV2LabelCount(item?.id);
  return {
    ...item,
    count,
  };
});

如果 list 过多，会导致连接池全部使用完，无法释放。
PromiseTools.queue 代码逻辑有问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14

static async queue<T, K>(dataList: T[], callBack: (item: T, index: number) => Promise<K> | K, spliceLength = 5): Promise<K[]> {
  if (!dataList?.length) {
    return [];
  }
  const promiseList: Array<Promise<K> | K> = [];
  const list: K[] = [];
  for (let i = 0; i < dataList.length; i++) {
    promiseList.push(callBack(dataList[i], i));
  }
  while (promiseList.length) {
    list.push(...(await Promise.all(promiseList.splice(0, spliceLength))));
  }
  return list;
}

尝试优化代码

1
2
3
4
5
6
7
8
9
10
11
12
13

static async queue<T, K>(dataList: T[], callBack: (item: T, index: number) => Promise<K> | K, spliceLength = 5): Promise<K[]> {
  if (!dataList?.length) {
    return [];
  }
  const list: K[] = [];
  for (let i = 0; i < dataList.length; i += spliceLength) {
    const step = i + spliceLength < dataList.length ? spliceLength : dataList.length - i;
    const promiseList = new Array(step).fill(0).map((_, index) => callBack(dataList[i + index], i + index));
    const result = await Promise.all(promiseList);
    list.push(...result);
  }
  return list;
}

JS 中的设计模式

解决一些特定问题的方法，并总结起来，给一个名字。

定义

在面向对象软件设计过程中针对特定的问题简洁而优雅的解决方案。

原则

找出程序中变化的地方，并将变化封装起来

鸭子类型

如果它走起路来像鸭子，叫起来也是鸭子，那么它就是鸭子。

多态

同一操作作用于不同的对象上面，可以产生不同的解释和不同的执行结果。换句话说，给不同的对象发送同一个消息的时候，这些对象会根据这个消息分别给出不同的反馈。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Duck {}
class Chicken {}
class Dog {}
const makeSound = function (animal) {
  if (animal instanceof Duck) {
    console.log("嘎嘎嘎");
  } else if (animal instanceof Chicken) {
    console.log("咯咯咯");
  }else if (animal instansof Dog){
    console.log("汪汪汪");
  }
};
makeSound(new Duck()); // 嘎嘎嘎
makeSound(new Chicken()); // 咯咯咯

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

const makeSound = function (animal: Animal) {
  animal.sound();
};
class Animal {
  sound() {
    throw new Error("不存在sound");
  }
}
class Duck extends Animal {
  sound() {
    console.log("嘎嘎嘎");
  }
}
class Chicken extends Animal {
  sound() {
    console.log("嘎嘎嘎");
  }
}

class Dog extends Animal {
  sound(){
    console.log("汪汪汪")
  }
}

makeSound(new Duck()); // 嘎嘎嘎
makeSound(new Chicken()); // 咯咯咯
makeSound(new Dog()); // 咯咯咯
// 更多...
// class Chicken extends Animal {
//   sound() {
// console.log("嘎嘎嘎");
//   }
// }

多态最根本的作用就是通过把过程化的条件分支语句转化为对象的多态性，从而消除这些条件分支语句

封装

考虑你的设计中哪些地方可能变化，这种方式与关注会导致重新设计的原因相反。它不是考虑什么时候会迫使你的设计改变，而是考虑你怎样才能够在不重新设计的情况下进行改变。这里的关键在于封装发生变化的概念，这是许多设计模式的主题

原型模式

基于原型链

单例模式

定义

保证一个类仅有一个实例，并提供一个访问它的全局访问点

场景

• 需要频繁实例化然后销毁的对象
• 创建对象时耗时过多或者耗资源过多，但又经常用到的对象
• 有状态的工具类对象
• 繁访问数据库或文件的对象

应用

• window 对象
• 日志文件
• 应用配置
• 线程池

代理模式

定义

代理模式是为一个对象提供一个代替品或占位符，以便控制对他的访问

场景

• 明星的经纪人
• 生产数据库访问
• 翻墙

迭代器模式

定义

顺序访问一个聚合对象的元素，而不需要暴露对象的内部表示。

基本不需要自己实现，大部分语言内置了迭代器

场景

• Array.prototype.forEach

发布订阅模式

定义

对象间的一对多的依赖关系，当一个对象的状态发生改变时，所以依赖于他的对象都能接受到通知

场景

• JS 事件模型

命令模式

定义

命令是对命令的封装，每一个命令都是一个操作，请求方发出请求，接收方接收请求，并执行操作。命令模式解耦了请求方和接收方，命令模式属于行为型模式

场景

• 处理一些功能，但是不知道请求的接收者是谁，操作是什么，希望以一种松耦合的方式来设计程序。
• JS 高阶函数

组合模式

定义

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结

场景

• 树形菜单
• 文件
• 文件夹的管理

模板模式

定义

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

场景

• 造房子
• 泡茶还是泡咖啡

策略模式

定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。

计算绩效

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

const calculateBonus = function (
  performanceLevel: "S" | "A" | "B",
  salary: number
) {
  if (performanceLevel === "S") {
    return salary * 4;
  }
  if (performanceLevel === "A") {
    return salary * 3;
  }
  if (performanceLevel === "B") {
    return salary * 2;
  }
};
calculateBonus("B", 20000); // 输出：40000

// ts实现
const bounsMap = new Map([
  ["S", (salary: number) => salary * 4],
  ["A", (salary: number) => salary * 3],
  ["B", (salary: number) => salary * 2],
]);
bounsMap.get("S")?.(1000);

// 完整实现
enum strategyEnum {
  S = "S",
  A = "A",
  B = "B",
}
const bounsMap = new Map<strategyEnum, { times: number }>([
  [strategyEnum.S, { times: 4 }],
  [strategyEnum.B, { times: 3 }],
  [strategyEnum.B, { times: 2 }],
]);

const getBouns = (strategy: strategyEnum, salary: number) => {
  const bouns = bounsMap.get(strategy);
  if (!bouns) {
    return 0;
  }
  return bouns.times * salary;
};
getBouns(strategyEnum.S, 1000);