给出位向量的布尔运算
运算 | 二进制 |
---|---|
a | [01101001] |
b | [01010101] |
~a | [10010110] |
~b | [10101010] |
a&b | [01000001] |
a|b | [01111101] |
a^b | [00111110] |
给定一个包含 [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 | impl Solution { |
1 | impl Solution { |
给定一个只包括 ‘(‘,’)’,’{‘,’}’,’[‘,’]’ 的字符串 s ,判断字符串是否有效。
有效字符串需满足:
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。
示例 1:
输入:s = “()”
输出:true
示例 2:
输入:s = “()[]{}”
输出:true
示例 3:
输入:s = “(]”
输出:false
提示:
1 <= s.length <= 104
s 仅由括号 ‘()[]{}’ 组成
1 | impl Solution { |
1 | #[allow(dead_code)] |
原本也没啥思路,就想着怎么处理字符串
然后发现解答里面有关于栈的问题,看了别人的解体思路后,比较明朗
匹配到左括号,向栈推入右括号
如果匹配到右括号,就把栈顶的括号推出,判断是不是为当前的右括号,如果是,代表括号闭合,如果不是,直接失败
匹配到右括号空栈也直接失败
最后判断栈的长度是不是为 0,如果为 0,代表完全匹配
emm
示例的代码写的比较精简,感觉可以复现一次
n | 2^n 十进制 | 2^n 十六进制 |
---|---|---|
9 | 512 | 0x200 |
19 | 524288 | 0x80000 |
14 | 16384 | 0x4000 |
16 | 65535 | 0x10000 |
17 | 131070 | 0x20000 |
5 | 32 | 0x20 |
7 | 128 | 0x80 |
卧槽,算错那么多
十进制 | 二进制 | 十六进制 |
---|---|---|
0 | 0000 0000 | 0x00 |
167 | 1010 0111 | 0xA7 |
62 | 0011 1110 | 0x3E |
188 | 10111100 | 0xBC |
55 | 00110111 | 0x37 |
136 | 10001000 | 0x88 |
243 | 11110011 | 0xF3 |
82 | 01010010 | 0x52 |
172 | 10101100 | 0xAC |
231 | 11100111 | 0xE7 |
草,还是得用计算器????
别做卷子了,废物,这都能错俩,还特么检查,你有脸检查???
完了,还是那么粗心。。
16 | 2 |
---|---|
3 | 0011 |
9 | 1001 |
A | 1010 |
7 | 0111 |
F | 1111 |
8 | 1000 |
001110011010011111111000
16 | 2 |
---|---|
C | 1100 |
9 | 1001 |
7 | 0111 |
B | 1011 |
0xC97b
16 | 2 |
---|---|
D | 1101 |
5 | 0101 |
E | 1110 |
4 | 0100 |
C | 1100 |
11010101111001001011
16 | 2 |
---|---|
2 | 0010 |
6 | 0110 |
E | 1110 |
7 | 0111 |
B | 1011 |
5 | 0101 |
0x26e7B5
1 | // 积分枚举 |
字段 | 类型 | 含义 |
---|---|---|
id | primary key | 主键 |
uid | bigint | 用户 id |
source_type | tinyint | 积分来源类型 |
source_id | int | 积分来源 id |
socre | int | 分值 |
rest_score | datetime | 剩余积分 |
action_uid | bigint | 操作人 |
reason | varchar | 原因 |
exprie_time | datetime | 过期时间 |
create_time | datetime | 创建时间 |
update_time | datetime | 更新时间 |
delete_time | datetime | 删除时间 |
字段 | 类型 | 含义 |
---|---|---|
id | primary key | 主键 |
uid | bigint | 用户 id |
socre | int | 分值 |
create_time | datetime | 创建时间 |
update_time | datetime | 更新时间 |
delete_time | datetime | 删除时间 |
不知道应该写点什么。
想到哪 写到哪吧。
都会有一段令人铭记在心的记忆,随着时间的流逝,逐渐变淡
已经感觉到了
最开始
后来
现在
嗯,这种情况也许不会持续很久。
也许到了说再见的时候
不知道是不是最坏的结果
但应该不是最好的
但
总是有些东西,在夜深人静的时候会想起来
想起来 就一阵难过
为什么当时热恋的两个人
到现在
em,可能分离两地的结果就是这样子吧
自己也没想着尝试改变什么
按班就不
一步步走到那个阶段
是你自己选择的
不应该埋怨什么
你当时做这件事情的时候 已经预见到了结果
这不是如你所愿
感性吗
不应该
应该是活该
晚上总是瞎J8想
就这吧
还有吗
木有了,就这。
希望她有更好的生活
https://github.com/zusterben/plan_c
sed -i ‘s/\tdetect_package/\t# detect_package/g’ /jffs/softcenter/scripts/ks_tar_install.sh
原来服务是稳定运行的,加了一个子进程功能后,服务器经常无法访问。
1 | 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 |
1 | 328 [info] 2022-09-18 03:30:02.0 [KeywordMonitorCommunityCron] 收到close事件,子进程收到信号 256120 |
1 | 94 [info] 2022-09-17 03:30:02.1 [KeywordMonitorCommunityCron] 收到close事件,子进程收到信号 145279 |
没有发现问题
确认连接池问题
有一段代码循环使用 sql,导致连接池被用尽。
1 | const value = await PromiseTools.queue(list, async (item) => { |
如果 list 过多,会导致连接池全部使用完,无法释放。
PromiseTools.queue 代码逻辑有问题
1 | static async queue<T, K>(dataList: T[], callBack: (item: T, index: number) => Promise<K> | K, spliceLength = 5): Promise<K[]> { |
尝试优化代码
1 | static async queue<T, K>(dataList: T[], callBack: (item: T, index: number) => Promise<K> | K, spliceLength = 5): Promise<K[]> { |
解决一些特定问题的方法,并总结起来,给一个名字。
在面向对象软件设计过程中针对特定的问题简洁而优雅的解决方案。
找出程序中变化的地方,并将变化封装起来
如果它走起路来像鸭子,叫起来也是鸭子,那么它就是鸭子。
同一操作作用于不同的对象上面,可以产生不同的解释和不同的执行结果。换句话说,给不同的对象发送同一个消息的时候,这些对象会根据这个消息分别给出不同的反馈。
1 | class Duck {} |
1 | const makeSound = function (animal: Animal) { |
多态最根本的作用就是通过把过程化的条件分支语句转化为对象的多态性,从而消除这些条件分支语句
考虑你的设计中哪些地方可能变化,这种方式与关注会导致重新设计的原因相反。它不是考虑什么时候会迫使你的设计改变,而是考虑你怎样才能够在不重新设计的情况下进行改变。这里的关键在于封装发生变化的概念,这是许多设计模式的主题
基于原型链
保证一个类仅有一个实例,并提供一个访问它的全局访问点
代理模式是为一个对象提供一个代替品或占位符,以便控制对他的访问
顺序访问一个聚合对象的元素,而不需要暴露对象的内部表示。
基本不需要自己实现,大部分语言内置了迭代器
对象间的一对多的依赖关系,当一个对象的状态发生改变时,所以依赖于他的对象都能接受到通知
命令是对命令的封装,每一个命令都是一个操作,请求方发出请求,接收方接收请求,并执行操作。命令模式解耦了请求方和接收方,命令模式属于行为型模式
组合模式(Composite Pattern),又叫部分整体模式,是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象,用来表示部分以及整体层次。这种类型的设计模式属于结构型模式,它创建了对象组的树形结
在模板模式(Template Pattern)中,一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现,但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。
定义一系列的算法,把它们一个个封装起来,并且使它们可以相互替换。
计算绩效
1 | const calculateBonus = function ( |