1d:T2830,今天自己写项目玩，想要实现一个类似邀请码的机制，没想到小小邀请码还真没那么简单 ## 需求分析首先是硬性需求： - 不可重复 - 单射看到这两点需求，我第一反应就是 Hash，但是Hash需要处理冲突，并不是一个很好的解决方案。另外出于美学之类的考虑，我们还有一些别的需求，毕竟谁也不想面对面分享邀请码的时候拿出来一串 ``18ce3ca04a725cc6b57d5ec0ae0ccd66`` 这样的~~乱码~~吧非硬性需求： - 定长 - 不易被推测出规律 - 效率高 - 支持并发 - 可溯源仔细思考了一下 Hash 的可行性后我决定放弃这种方案... ## 方案分析群里的菊苣给出了洗牌算法的方案，这是一个预生成的方案这里就预生成方案统一分析 ### 预生成讲真，不考虑别的因素，预生成方案确实不错，洗牌算法也非常的棒这种方案的思想是根据随机生成算法，预先生成一批邀请码，然后将这些邀请码缓存，当用户请求时将其分配给用户，当邀请码分配完时，再生成一批，如此循环。 #### 弊端 - 每次重新生成时都要检查是否重复 ~~而且多数情况下都为否~~ - 邀请码本身需要持久化存储 - 用户和邀请码的关系需要记录对于唯一性我啪的一下就想到了 UUID 和 MD5，~~很快啊~~ MD5作为一种 Hash 在一开始就被我放弃了，接下来我们看一下 UUID ## UUID 引用一下Wikipedia的说法 > 通用唯一识别码（英语：Universally Unique Identifier，缩写：UUID）是用于计算机体系中以识别信息数目的一个128位标识符，根据标准方法生成，不依赖中央机构的注册和分配，UUID具有唯一性，这与其他大多数编号方案不同。重复UUID码概率接近零，可以忽略不计。这下唯一性是真的强，但是分享一串128位标识符的画面确实也很美... 没啥好想法的我上网搜了一下，又得到了两种方案，一种类似于Base64，这种没啥好说的，接下来主要说一下另一种方案 ### 密码学方案这种方案本质上是一个实现了由用户ID空间到邀请码空间的双射，通过用户ID确定了邀请码的唯一性，同时又可通过反函数来对邀请码溯源，既不需要保存邀请码，又不需要保存关系，针不戳我们先来写个简单函数实现双射 ```go func test(id uint) { const Chars = "0123456789ABCDEF" const CodeLength = 6 const Base = 16 const Salt = 233 pid := id + Salt // 为了避免用户 ID的直接泄漏，我们可以先加点盐 var b [CodeLength] uint b[0] = pid for i := 0; i < CodeLength-1; i++ { b[i + 1] = b[i] / Base b[i] = b[i]% Base } fmt.Printf("ID: %-2d ---> %c %c %c %c %c %c\n",id, Chars[b[5]],Chars[b[4]],Chars[b[3]],Chars[b[2]],Chars[b[1]],Chars[b[0]]) } ``` 这个函数本质上和进制转换函数没什么区别，我们跑一下看看效果 ``` ➜ test go run test.go ID: 0 ---> 0 0 0 0 E 9 ID: 1 ---> 0 0 0 0 E A ID: 2 ---> 0 0 0 0 E B ID: 3 ---> 0 0 0 0 E C ID: 4 ---> 0 0 0 0 E D ID: 75 ---> 0 0 0 1 3 4 ID: 76 ---> 0 0 0 1 3 5 ID: 77 ---> 0 0 0 1 3 6 ID: 78 ---> 0 0 0 1 3 7 ID: 79 ---> 0 0 0 1 3 8 ``` 啊这...这完全在预料之中，~~换下Chars里字母的顺序也能当个凯撒密码用用~~ 好吧不就是看起来太规律了么，我们来把这个结果用密码学方法扩散和混淆一下 #### 扩散和混淆在密码学当中，混淆（confusion）与扩散（diffusion）是设计密码学算法的两种主要方法。这样的定义最早出现在克劳德·香农1945年的论文《密码学的数学理论》当中。在克劳德·香农的定义之中，混淆主要是用来使密文和对称式加密方法中密钥的关系变得尽可能的复杂；而扩散则主要是用来使用明文和密文关的关系变得尽可能的复杂，明文中任何一点小更动都会使得密文有很大的差异。混乱用于掩盖明文与密文之间的关系。这可以挫败通过研究密文以获取冗余度和统计模式的企图。做到这一点最容易的方法是“代替”。扩散通过将明文冗余度分散到密文中使之分散开来。即将单个明文或密钥位的影响尽可能扩大到更多的密文中去。产生扩散最简单的方法是换位（置换）。改进后的算法如下 ```go func test(id uint) { const Chars = "0123456789ABCDEF" const CodeLength = 6 const Base = 16 const Salt = 233 const Prime = 7 pid := id * Prime + Salt // 放大 var b [CodeLength] uint b[0] = pid for i := 0; i < CodeLength-1; i++ { b[i + 1] = b[i] / Base b[i] = (b[i] + uint(i) * b[0]) % Base } fmt.Printf("ID: %-2d ---> %c %c %c %c %c %c\n",id, Chars[b[5]],Chars[b[4]],Chars[b[3]],Chars[b[2]],Chars[b[1]],Chars[b[0]]) } ``` 这里我们给用户ID放大的时候乘了个和 Base 互质的数 Prime，这是基于循环群的性质：若 m 和 p 互质，则 ( id * m ) % p 的结果遍历[0, p) 的所有整数。这保证了放大后结果的分布和原数据的分布同样均匀。让我们来跑一下试试： ``` ➜ test go run test.go ID: 0 ---> 0 4 B 2 7 9 ID: 1 ---> 0 0 0 0 F 0 ID: 2 ---> 0 C 5 E 6 7 ID: 3 ---> 0 8 A C D E ID: 4 ---> 0 4 F B 5 5 ID: 75 ---> 0 8 2 E 5 6 ID: 76 ---> 0 4 7 C C D ID: 77 ---> 0 0 C B 4 4 ID: 78 ---> 0 C 1 9 B B ID: 79 ---> 0 8 6 7 3 2 ``` 啊这...怎么开头全是0啊...算了，正好拿它做校验位，顺便再给结果洗个牌最终代码如下 ```go func test(id uint) { const Chars = "0123456789ABCDEF" const CodeLength = 6 const Base = 16 const Salt = 233 const Prime = 7 const Prime2 = 5 pid := id * Prime + Salt // 放大 var b [CodeLength] uint b[0] = pid for i := 0; i < CodeLength-1; i++ { b[i + 1] = b[i] / Base b[i] = (b[i] + uint(i) * b[0]) % Base } // 校验位 for i := 0; i < CodeLength-1; i++ { b[CodeLength-1] += b[i] } b[CodeLength-1] = b[CodeLength-1] * Prime % CodeLength fmt.Printf("ID: %-2d ---> ",id) for i := 5; i >= 0; i-- { fmt.Printf(" %c",Chars[b[(i*Prime2) % CodeLength]]) // 洗牌 } fmt.Printf("\n") } ``` 这里用了一个和 CodeLength 互质的数 Prime2 对生成结果进行了洗牌，原因和之前的 Prime 一样跑一下看看效果 ``` ➜ test go run test.go ID: 0 ---> 7 2 B 4 3 9 ID: 1 ---> F 0 0 0 3 0 ID: 2 ---> 6 E 5 C 2 7 ID: 3 ---> D C A 8 3 E ID: 4 ---> 5 B F 4 4 5 ID: 75 ---> 5 E 2 8 5 6 ID: 76 ---> C C 7 4 0 D ID: 77 ---> 4 B C 0 1 4 ID: 78 ---> B 9 1 C 2 B ID: 79 ---> 3 7 6 8 2 2 ``` ohhhhhhhhh 效果相当不错！ #### 解码具体解码流程就是上面的最终函数倒过来写，可能反函数不太好理解，在纸上推一下就好了 ```go func test2(code string) int{ if len(code) != CodeLength { return -1 } var b [CodeLength] uint // 反洗牌 for i := 0; i < CodeLength; i++ { b[(i*Prime2) % CodeLength] = uint(i) } // 转换回 Chars 下标 for i := 0; i < CodeLength; i++ { j := strings.Index(Chars, string(code[b[i]])) if j == -1 { return -1 // 非法字符检查 } b[i] = uint(j) } // 校验 var expect uint for i := 0; i < CodeLength-1; i++ { expect += b[i] } expect = expect * Prime % CodeLength if b[5] != expect{ return -1 } // 反函数 for i := CodeLength-2; i >=0; i-- { b[i] = (b[i] - uint(i) * (b[0] - Base)) % Base } var res uint = 0 for i := CodeLength-2; i >0; i-- { res += b[i] res *= Base } // 反放大 res = ((res + b[0]) - Salt) / Prime fmt.Printf("%d\n",res) return int(res) } ``` 需要注意的是我们之前是从b[5]...b[0]反着print的所以解码的时候记得倒一下 ```go test(76) // CC740D test2("D047CC") // 因为我们之前是反着print的 ``` 最终输出如下 ``` ➜ test go run test.go ID: 76 ---> C C 7 4 0 D 76 ``` 稍微分析一下，6位16进制邀请码，1位校验，可用范围为0x00000到0xFFFFF，减去扩大和加盐带来的损耗，大概能生成14万个邀请码，对于我来说是够用了，如果你觉得少的话可以 - 扩大Base，比如用32进制或者64进制~~（其实我本人用的10进制，只有数字多好看啊小声bb）~~ - 增加邀请码位数，8位不也挺好的么？ ## 最终代码思路验证完毕，让我们把函数的输出补上，并把第一个函数的输出给倒回来，顺便润润色 ```go package main import ( "fmt" "strings" ) const Chars = "0123456789ABCDEF" const CodeLength = 6 const Salt = 233 const Prime = 7 const Prime2 = 5 const Base = uint(len(Chars)) func main() { str := genCode(76) decode(str) } func genCode(id uint) string{ var b [CodeLength] uint var res string pid := id * Prime + Salt //扩大 b[0] = pid for i := 0; i < CodeLength-1; i++ { b[i + 1] = b[i] / Base b[i] = (b[i] + uint(i) * b[0]) % Base } // 校验位 for i := 0; i < CodeLength-1; i++ { b[CodeLength-1] += b[i] } b[CodeLength-1] = b[CodeLength-1] * Prime % CodeLength for i := 0; i < CodeLength; i++ { res += string(Chars[b[(i*Prime2)%CodeLength]]) // 洗牌 } fmt.Println(res) return res } func decode(code string) int{ if len(code) != CodeLength { return -1 } var b [CodeLength] uint // 反洗牌 for i := 0; i < CodeLength; i++ { b[(i*Prime2) % CodeLength] = uint(i) } // 转换回 Chars 下标 for i := 0; i < CodeLength; i++ { j := strings.Index(Chars, string(code[b[i]])) if j == -1 { return -1 // 非法字符检查 } b[i] = uint(j) } // 校验 var expect uint for i := 0; i < CodeLength-1; i++ { expect += b[i] } expect = expect * Prime % CodeLength if b[5] != expect{ return -1 } // 反函数 for i := CodeLength-2; i >=0; i-- { b[i] = (b[i] - uint(i) * (b[0] - Base)) % Base } var res uint = 0 for i := CodeLength-2; i >0; i-- { res += b[i] res *= Base } // 反放大 res = ((res + b[0]) - Salt) / Prime fmt.Printf("%d\n",res) return int(res) } ``` ## Reference - https://my.oschina.net/bravozu/blog/1827254 ~~这老哥代码有问题（小声bb~~ - https://zh.wikipedia.org/wiki/P盒 - https://zh.wikipedia.org/wiki/循環群 - https://zh.wikipedia.org/wiki/通用唯一识别码 - https://www.knowpia.cn/pages/混淆与扩散 1e:T1a3d,## 前言本学期开了编译原理课，嗯写作本文的原因就这么简单... ## 基本概念 - 字母表：非空有限集，一般用$∑$表示，如$∑=\{a,b,c\}$ - 符号： $∑$中的元素称为符号。 - 符号串：符号的有穷序列称符号串，也可称为字，用ε表示空字符串。 - 长度：符号串中包括的符号的个数，如$|ab|=2,|ε|=0$ - 连接：设x和y是字符串，则称$x·y$是其连接，符号‘·’一般可省略。对于任意字符串$β$，有$βε=εβ=β$ - 乘积：设A和B是符号串集，则用AB表示它们的乘积： $$ AB=\{xy|x∈A,y∈B \} $$ 显然$\{ε\}A=A\{ε\}=A$ - 空集：不含任何元素的集合φ，对任何字符串集A有： $$ φA=Aφ=A $$ - 方幂：设A是字符串集，则A的方幂定义为： $$ A^0 =\{ε\}; A^1 =A; A^n =A^{n-1} A $$ 特别地，若x是$∑$中的字符，则x的n次自身连接即$x^n$ - 闭包/正闭包/星闭包：设A是符号集，用$A^+$表示A的正闭包: $$ A^+=A^1∪A^2∪\dots∪A^n∪\dots $$ 用$A^*$表示A的星闭包: $$ A^*=A^0∪A^1∪A^2∪\dots∪A^n∪\dots=\{ε\}∪A^+ $$ 两者统称为A的闭包。举个例子[^1]：设$A = \{a,b\}$ 则： $$ \begin{aligned} &A^0 = \{ε\}\cr &A^1 = \{a,b\}\cr &A^2 = AA = \{aa,ab,ba,bb\}\cr &A^3 = AAA = \{aaa,aab,aba,abb,baa,bab,bba,bbb\}\cr &\dots\cr \end{aligned} $$ ### 符号和符号串任何程序设计语言都是某一基本符号集上的字符序列，其中的字符用来构造单词，单词构造更大的语法单位，表达式、语句等复合对象。其中，**单词是最小的语义单位**,它不包含任何子结构，因此每个单词是简单的字符序列。 ## 语言程序设计语言是一个**记号系统**，同自然语言一样，完整的定义应包括**语法**和**语义**两个方面。语言的语法是指**一组规则**，用它可以形成和产生一个合适的程序。语法规定了特定符号序列的合法性，而与符号的含义没有关系。任何程序设计语言都是某一基本符号集上的字符序列。对于语义的分析与处理到目前为止仍然没有公认的形式系统用于自动构造正确的编译程序。 ### 形式语言形式语言（英语：Formal language）是用精确的数学或机器可处理的公式定义的语言。在形式语言理论中，形式语言是一个字母表上的某些有限长字符串的**集合**。每个形式语言都是某个字母表上按某种规则构成的所有符号的集合，反之，任何一个字母表上符号串的集合均可定义为一个形式语言，不涉及考虑语义问题。 #### 语言间的运算因为形式语言在本质上是由数学定义的的集合，所以语言间的运算就是$Σ^*$幂集上的运算。与普通的集合数学运算无异。 ### 语言的表示方法从形式语言的角度看，一个语言也就是字符串集。如果字符串集是有穷的，可以用枚举的办法表示出来。例如，设有字母表 $A=\{a,b,c\}$，则 $$ \begin{aligned} &L_1 = \{a,b,c\}\cr &L_2 = \{a,aa,ab,ac\}\cr &L_3 = \{c,cc\} \end{aligned} $$ 均表示字母表A上的一个形式语言。当集合无穷时，~~我们可以使用无限猴子定理~~枚举的办法就不行了，需要寻找合适的有穷表示方法——**文法**。除形式文法外，语言也可使用正则表达式或某些自动机表示，在本章暂不讨论。 ## 文法在形式语言理论中，文法（为了避免歧义，常称作“形式文法”）是形式语言中字符串的一套产生式规则。这些规则描述了如何用语言的字母表生成符合语法的有效的字符串。文法不描述字符串的含义，也不描述在任何上下文中可以用它们做什么——只描述它们的形式。形式文法是从一个“开始符号”出发的一套重写字符串的规则。因此，文法通常被认为是语言生成器。[^2] ps: 形式语言理论是应用数学的一个分支，是研究形式文法和语言的学科。 ### 规则我们以汉语句子的文法为例： ``` 句子 → 主语·谓语主语 → 代词∣名词代词 → 我∣你∣他名词 → 司机∣农民∣学生∣汽车∣锄头谓语 → 动词·直接宾语动词 → 学习∣拿起∣开直接宾语 → 代词∣名词 ``` 其上的每一条被称为**产生式**或**语法规则**，符号“→”也可以写成“∷=”，表示“被定义为”。符号“·”和“∣”是集合运算符号，“·”表示“连接”，该符号往往被省略，“∣”表示“或”，该符号两边的符号串称候选串。由上面的规则可以**产生或推导出句子**，引进符号“=>”表示推导，比如句子“农民拿起锄头”的推导过程为：句子=>主语·谓语=>名词·谓语=>农民·谓语=>农民·动词·直接宾语=>农民·拿起·直接宾语=>农民·拿起·名词=>农民拿起锄头 ## 形式定义接下来我们以数学为工具，利用符号和公式，精确地定义文法和语言。 ### 文法的形式定义文法是规则的**非空**有穷集合。其形式定义为四元组$G[S]=(V_N,V_T,P,S)$ - $V_N$是规则中非终结符号的集合。 - $V_T$是规则中终结符号的集合，显然文法在这里结束。 - P是文法规则的合集。 - S是一个非终结符号，显然文法从这里开始。 ### 语言的形式定义当一个文法已知时，我们可以确定出该文法所定义的语言，但在此之前我们需要先弄明白什么是句子，这里我们需要引入推导的概念。 #### 推导如果存在一个直接推导序列 $$ a_0 \Rightarrow a_1 \Rightarrow a_2 \Rightarrow \dots \Rightarrow a_n $$ 则称这个序列是$a_0$到$a_n$的长度为n的推导，记为$a_0\stackrel{+}{\Rightarrow}a_n$。表示从$a_0$出发，经过1到n步可以推导出$a_n$。 #### 广义推导广义推导的符号为$\stackrel{*}{\Rightarrow}$ $a_0 \stackrel{*}{\Rightarrow} a_n$表示从$a_0$出发，经过0到n步可以推导出$a_n$。 #### 句型与句子对于文法 $G[S]$，如果 $$ S \stackrel{*}{\Rightarrow} x $$ 称符号串x为文法 $G[S]$ 的句型。 $$ S \stackrel{*}{\Rightarrow}x, x∈V_T^* $$ 则称符号串x是文法$G[S]$的句子。 --- 有了以上概念后，我们可以给出语言的形式定义：文法 $G[S]$ 产生的所有句子的集合称为文法G所定义的语言，记为$L(G[S])$ $$ L(G[S])=\{x|S\stackrel{+}{\Rightarrow}x,x∈V_T^*\} $$ ## Reference [^1]: 编译原理刘铭、徐兰芳等｜电子工业出版社 [^2]: 维基百科 [形式文法](https://zh.wikipedia.org/wiki/形式文法)1f:T1045, ## 目标 ``` HTTP/1.1 200 OK Server: nginx Date: Sun, 05 Jan 2020 17:39:08 GMT Content-Type: text/html; charset=UTF-8 Connection: close Vary: Accept-Encoding X-Powered-By: PHP/5.6.10 Content-Length: 6 123Abc ``` --> parse --> ```json { "reqline": "HTTP/1.1 200 OK", "headers": { "server": "nginx", "date": "Sun, 05 Jan 2020 17:39:08 GMT", "content-type": "text/html; charset=UTF-8", "connection": "close", "vary": "Accept-Encoding", "x-powered-by": "PHP/5.6.10", "content-length": "6", } "body": "123Abc" } ``` ## 状态机 ![http parser fsm](res/fsm.jpg) ## 代码实现 ```javascript var httpParser = {}; (function () { function Stream (str) { this.pos = 0; this.str = str; } Stream.prototype.hasNext = function () { return this.pos < this.str.length; } Stream.prototype.next = function () { return this.str[this.pos++]; } const STATE = { BEGIN : 0, LINE_ALMOST_DONE : 1, LINE_DONE : 2, KEY_DONE : 3, HEADER_ALMOST_DONE : 4, HEADER_DONE : 5, END : 6 }; httpParser.state = STATE.BEGIN; function updateState(st){ httpParser.state = st; } function currentState(){ return httpParser.state; } httpParser.parse = function (str) { if (str.length < 4) return -1; updateState(STATE.BEGIN); var result = {}; result["headers"] = {}; var lastword = ""; var word = ""; var stream = new Stream(str); while (stream.hasNext()) { var ch = stream.next(); switch (currentState()) { case STATE.BEGIN: // they might be just sending \n instead of \r\n so this would be // the second \n to denote the end of headers if (ch == '\r' || ch == '\n') { updateState(STATE.LINE_ALMOST_DONE); result["reqline"] = word; word = ""; break; } word += ch; break; case STATE.LINE_ALMOST_DONE: if (ch == '\n') { updateState(STATE.LINE_DONE); }else{ return -1; } break; case STATE.LINE_DONE: if (ch == ':') { updateState(STATE.KEY_DONE); lastword = word; word = ""; break; } if (ch == '\r' || ch == '\n') { updateState(STATE.HEADER_ALMOST_DONE); lastword = ""; word = ""; break; } word += ch; break; case STATE.KEY_DONE: if (ch == '\r' || ch == '\n') { updateState(STATE.LINE_ALMOST_DONE); result["headers"][lastword.toLowerCase()] = word; lastword = ""; word = ""; break; } if (word == "" && ch == ' ') break; word += ch; break; case STATE.HEADER_ALMOST_DONE: if (ch == '\n') { updateState(STATE.HEADER_DONE); }else{ return -1; } break; //Need to optimize case STATE.HEADER_DONE: word += ch; while (stream.hasNext()){ word += stream.next(); } result["body"] = word; word = ""; break; default: return -2; } } return result; } })(); ```20:T9c4, ## 这是个啥？ > 答：是小时候写的垃圾，现已被[这篇文章](/posts/invite-code-gen)取代 2021.9.22 现如今，每个人都有不少网站的帐号，为每一个帐号设置不同的密码会增加大脑的记忆负担，而使用相同的密码则会引发安全问题。 Simple password generator，是一个简单的密码生成器，但这绝不表示生成的密码是简单密码（弱口令）。通过本生成器可使用户仅需记住一个密码（即所有密码的公匙），来通过算法动态生成实际密码，每次密码皆为动态生成，由公匙确保生成密码的一致性，密码数据不做任何保持，具有较高的安全性。 ## 如何使用启动后输入储存在**大脑** 中的密码，然后根据不同网站输入不同的key，生成器会实时计算出唯一的值来作为实际密码，密码不做任何保存处理。输入 exit 退出程序。 ## 原理其实就是随机数种子的应用= =||| 还有个缺点，前三（四）位固定是大小写字母、数字（符号）搭配... ## 源码 ```python import random lower="abcdefghijklmnopqrstuvwxyz" upper="ABCDEFGHIJKLMNOPQRSTUVWXYZ" symbols="!%@#^,./?*;:_" number="0123456789" def getstr(legth,str1): tmp="" for i in range(legth): tmp = tmp + random.choice(str1) return tmp def getpwd(pwd,key,legth,havesymbol): passworld="" random.seed(pwd+key) if(havesymbol): passworld = getstr(1,upper)+getstr(1,lower)+getstr(1,number)+getstr(1,symbols) for i in range(legth-4): switch=random.randint(0,3) if(switch==0): passworld += getstr(1,upper) elif(switch==1): passworld += getstr(1,lower) elif(switch==2): passworld += getstr(1,number) else: passworld += getstr(1,symbols) else: passworld = getstr(1,upper)+getstr(1,lower)+getstr(1,number) for i in range(legth-3): switch=random.randint(0,2) if(switch==0): passworld += getstr(1,upper) elif(switch==1): passworld += getstr(1,lower) else: passworld += getstr(1,number) return passworld pwd=input("请输入公匙：") while(True): key=input("请输入关键字（或输入 exit 退出）：") if(key!="exit"): print("密码为： "+ getpwd(pwd,key,12,True)) else: break ```2:["$","html",null,{"lang":"zh-cn","suppressHydrationWarning":true,"children":["$","body",null,{"children":["$","$L12",null,{"children":["$","div",null,{"className":"relative flex min-h-screen flex-col overflow-clip","children":[["$","a",null,{"href":"#main-content","className":"fixed left-4 top-3 z-[60] -translate-y-20 rounded-lg bg-primary px-4 py-2 text-sm font-semibold text-primary-foreground transition-transform focus:translate-y-0","children":"Skip to content"}],["$","$L13",null,{"children":["$","$L14",null,{"posts":[{"metadata":{"title":"当知识管理回归本质：一种基于文件系统的极简主义实践","description":"首次尝试 DeepSeek 帮忙写Blog...","tags":["Knowledge"],"date":"2025-04-28T11:06:03.000Z","lang":"zh-CN","mod":"$undefined"},"content":"$15","id":"construct-knowlegde-database-in-file-system"},{"metadata":{"title":"Nvidia 硬件加速的 FFMPEG","description":"Conda 环境下编译 CUDA 加速的 FFMPEG","tags":["Compile"],"date":"2025-03-10T12:18:00.000Z","lang":"zh-CN","mod":"$undefined"},"content":"$16","id":"nvidia-hardware-accelerate-ffmpeg"},{"metadata":{"title":"语音合成：从离散声学编码到自回归建模","description":"又是作业改的...","tags":["AIGC","TTS","Audio","Codec"],"date":"2024-11-26T09:28:00.000Z","summary":"语音合成（TTS），即文本到语音，旨在从给定文本条件下生成可被理解的人类语音信号，是语音、语言和机器学习界的热门研究课题，在业界有着广泛的应用。随着深度学习和人工智能的发展，近年来基于神经网络的 TTS 显著提高了合成语音的质量。本文回顾了语音合成领域的发展，并从离散声学编码与词元预测的角度出发综述了语音的自回归建模方法。","lang":"zh-CN","mod":"$undefined"},"content":"$17","id":"neural-codec-language-models"},{"metadata":{"title":"自用租房检查清单","description":"踩坑踩怕了","tags":["Checklist"],"date":"2024-08-08T07:20:00.000Z","mod":"2024-08-12T10:56:00.000Z","lang":"zh-CN"},"content":"\n本页面组件支持交互，看房时可以直接照着 checklist 去检查，也可以在租房合同签订前参考。\n\n## 房屋本身\n\n以下内容重要程度**从高到低**排列\n\n\n\n## 租房合同\n\n以下内容没有优先级，**同等重要**\n\n","id":"rental-house-checklist"},{"metadata":{"title":"搭建基于容器的 HomeLab 平台","description":"草稿","tags":["Linux","Container"],"date":"2024-07-24T06:14:14.000Z","lang":"zh-CN","mod":"$undefined"},"content":"\n\n\n## 约定\n\n- HomeLab 数据保存在 `/home/lex/Datas` 目录下\n- 所有容器都使用 `podman` 运行\n- 所有容器的持久化文件都保存在 `/home/lex/Pods` 目录下\n\n## Podman\n\nPodman 是一个经常被拿来和 Docker 做对比的 Linux 容器管理工具，尽管它们都是通过 runc 来运行容器。Podman 是无 daemon 的，容器可以运行在 rootless 的环境中，这在一定程度上避免了容器逃逸的问题，作为无 daemon 的另一个好处是，它可以通过 `$http_proxy` 环境变量直接使用代理，而不需要额外的配置，这在 docker hub 被 GFW 封锁的今天显得尤为重要。\n\n## Deluge\n\n```sh\npodman run -d \\\n --name=deluge \\\n -e PUID=1000 \\\n -e PGID=1000 \\\n -e TZ=Asia/Shanghai \\\n -e DELUGE_LOGLEVEL=error \\\n -v /home/lex/Pods/deluge/config:/config \\\n -v /home/lex/Datas/pt:/downloads \\\n --restart unless-stopped \\\n --network host \\\n docker.io/linuxserver/deluge:latest\n```\n\n大多数的PT站点都支持 IPv6，不幸的是，当前版本的 Deluge 对 IPv6 的支持有问题，需要手动修改配置文件 `core.conf`，参考： https://github.com/deluge-torrent/deluge/pull/300\n\n\n```json\n{\n // ...\n \"listen_interface\": \"[::]\",\n // ...\n}\n```\n","id":"containerized-homelab"},{"metadata":{"title":"Happy Birthday 2024","description":"然而并不哈啤","date":"2024-07-22T21:03:00.000Z","tags":["log"],"lang":"zh-CN","mod":"$undefined"},"content":"\n26岁了，又活了一年...\n\n过年的时候总是很忙，年度总结不如放到生日这天写。\n\n今年从中国科学院大学毕业，\n\n春招确定去 Shanghai AI Lab 读博，结果被同济卡了，\n\n没办法，春招找工作，三家厂子给开了 60 万，\n\n最终决定去讯飞，虽然不是给的最多的，\n\n但胜在合肥消费比较低，三年差不多能全款买一套房。\n\n没想到工资卡都办好了，老师打电话问我还要不要读博，最终去了北理工...\n\n可能我内心还是对合肥这个地方不满意吧，\n\n这几个月去苏杭转了一圈，感觉未来可以去苏州定居。\n\n今天睡了一天，晚上约了饭，结果下午6点下起了暴风雨，吃不了一点。\n\n\n","id":"birthday-2024"},{"metadata":{"title":"生成语音检测任务简介","tags":["Audio"],"date":"2024-07-01T20:26:00.000Z","mod":"2024-07-05T16:25:00.000Z","description":"是哪里来的呢？？？","lang":"zh-CN"},"content":"$18","id":"introduce-fake-audio-detection"},{"metadata":{"title":"浅谈音乐生成算法","tags":["AIGC","Audio","Music"],"date":"2024-06-17T00:00:00.000Z","lang":"zh-CN","mod":"$undefined"},"content":"$19","id":"aigc-for-music-gen"},{"metadata":{"title":"JPEG 的实现原理","tags":["Algorithm"],"date":"2022-05-31T16:00:29.000Z","lang":"zh-CN","mod":"$undefined"},"content":"$1a","id":"the-jpeg-algorithm"},{"metadata":{"title":"语音合成技术的发展","description":"翻译和总结的综述，更新中...","tags":["AIGC","Audio","TTS"],"date":"2022-05-21T09:00:00.000Z","mod":"2022-05-21T09:00:00.000Z","lang":"zh-CN"},"content":"$1b","id":"introduce-tts"},{"metadata":{"title":"使 macOS 的光标像 windows 一样移动","description":"不会真的有人不会使用鼠标吧？不会吧，不会吧？","tags":["macOS"],"date":"2021-10-13T03:12:26.000Z","lang":"zh-CN","mod":"$undefined"},"content":"\n如果你同时在使用 Windows 和 mac OS，你可能会发现，mac OS 上的鼠标用起来有点怪异。\n\n这是因为 mac OS 上的光标加速特性导致的，简单来说就是：\n\n如果鼠标移动的慢，那么用户可能是想进行精密的指针操作，指针慢一点。\n如果鼠标移动的快，那么用户可能是想快速转移光标位置，指针就快一点。\n\n这个设计的初衷是为了让人们更容易地实现对光标的精密操作，使鼠标更易于上手。\n\n但非定长移动的光标，在降低了上手难度的同时，也降低了鼠标操作的上限，由于光标移动距离存在不确定性，难以完成一些专业操作，特别是在游戏领域（例如 FPS 中的甩狙操作）中鼠标的手感稀烂。\n\n如果你有串流、游戏需求或是 Windows 老用户，可以考虑关闭光标加速功能，来解决这个问题。\n\n不过 macOS 没有为这项设置提供 UI 界面，需要使用命令行进行设定。\n\n```sh\ndefaults write .GlobalPreferences com.apple.mouse.scaling -1\n```\n\n**上面**这条指令可以完全关闭光标加速功能，你也可以将 ```-1``` 修改为其他值来自行调节光标加速效果。\n\n需要注意的是当你通过第三方驱动更改了鼠标的 DPI 数值以后，加速度的数值会自动重置。需要再次使用指令进行设置。\n","id":"make-macos-cursor-move-like-windows"},{"metadata":{"title":"大革命，一种扑克卡牌游戏","description":"这货其实就是日本斗地主（","tags":["Game"],"date":"2021-04-09T09:55:35.000Z","mod":"2021-07-03T14:22:48.000Z","lang":"zh-CN"},"content":"$1c","id":"revolution-a-poker-game"},{"metadata":{"title":"浅谈邀请码的生成","tags":["Encrypt","Algorithm"],"date":"2021-02-08T17:53:00.000Z","summary":"本文探讨了实现邀请码机制的多种方法。作者首先分析了邀请码的基本需求，如唯一性、单射等，然后指出了Hash函数的不足。接着，作者考虑了预生成方案和UUID方案，并提出了密码学方案，通过用户ID生成邀请码并实现溯源。文中详细介绍了密码学方案的实现过程，包括生成和解码函数，并通过Go语言代码示例展示了如何生成和解码邀请码。最终，作者提供了一个完整的Go语言程序，用于生成和解码邀请码，同时讨论了可能的改进方向，如扩大基数或增加邀请码长度。(Kimi)","lang":"zh-CN","mod":"$undefined"},"content":"$1d","id":"invite-code-gen"},{"metadata":{"title":"编译原理学习笔记：文法与语言","description":"应该是不会有后续了🕊🕊🕊","tags":["Compile"],"date":"2020-02-21T15:00:00.000Z","mod":"2021-06-28T13:22:00.000Z","lang":"zh-CN"},"content":"$1e","id":"grammar-and-anguage"},{"metadata":{"title":"使用 JavaScript 实现一个基于 FSM 的 http 请求头 parser","description":"为啥会有人搞这么奇怪的东西...","tags":["Compile","Internet"],"date":"2020-02-17T08:20:00.000Z","lang":"zh-CN","mod":"$undefined"},"content":"$1f","id":"http-header-parser-in-js"},{"metadata":{"title":"Whisper 样式一览","description":"本文章现被用来测试主题样式","summary":"本文主要用来展示主题样式","tags":["Theme"],"date":"2019-11-07T15:13:00.000Z","mod":"2021-06-29T13:06:22.000Z","lang":"zh-CN"},"content":"\n# 一级标题\n\n你不应当考虑在文本中使用一级标题，这是一种错误的做法。\n另外，这段话是普通文本。\n\n## 二级标题\n\n### 三级标题\n\n#### 四级标题\n\n##### 五级标题\n\n###### 六级标题\n虽然目录对于标题的索引只支持到五级。\n但你依然可以在文章中使用六级标题。\n这在创建希望引起注意的长文本时会很好用。[^1]\n请注意！该标题不宜过长。\n\n> 引言块\n\n```c\n/* 代码块 */\n#include \nint main(void)\n{\n printf(\"Hello, world!\");\n return 0;\n}\n```\n\n$$\n\\lim_{x \\to \\infty} \\exp(-x) = 0\n$$\n\n这是一条行内公式$AB=\\{xy|x∈A,y∈B \\}$\n\n|商品|价格|\n|---|---|\n|猪肉|∞|\n|节操|0|\n\n\n 1. 有序\n 2. 列表\n\n - 无序\n - 列表\n\n中文和English之间会自动插入空格符！\n\n这里是**加粗**，*斜体*，和~~删除~~。\n\n***~~当然，你也可以把它们同时应用！~~***\n\n下面是```分割线``` 当你文章存在脚注时会自动生成这条分割线\n\n[^1]:这是一条脚注。当然，你也可以把它当作Reference来用～","id":"whisper-theme"},{"metadata":{"title":"一个简单的密码生成算法","description":"小时候写的垃圾，长大后又生产了一篇高级垃圾😅","tags":["Encrypt","Algorithm"],"date":"2015-06-08T06:00:00.000Z","lang":"zh-CN","mod":"$undefined"},"content":"$20","id":"a-simple-code-gen"}]}]}],"$L21","$L22"]}]}]}]}] 21:["$","main",null,{"id":"main-content","className":"relative z-10 w-full flex-1","children":["$","$L5",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L6",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":[[["$","title",null,{"children":"404: This page could not be found."}],["$","div",null,{"style":{"fontFamily":"system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"","height":"100vh","textAlign":"center","display":"flex","flexDirection":"column","alignItems":"center","justifyContent":"center"},"children":["$","div",null,{"children":[["$","style",null,{"dangerouslySetInnerHTML":{"__html":"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"}}],["$","h1",null,{"className":"next-error-h1","style":{"display":"inline-block","margin":"0 20px 0 0","padding":"0 23px 0 0","fontSize":24,"fontWeight":500,"verticalAlign":"top","lineHeight":"49px"},"children":404}],["$","div",null,{"style":{"display":"inline-block"},"children":["$","h2",null,{"style":{"fontSize":14,"fontWeight":400,"lineHeight":"49px","margin":0},"children":"This page could not be found."}]}]]}]}]],[]],"forbidden":"$undefined","unauthorized":"$undefined"}]}] 22:["$","footer",null,{"className":"relative z-40 border-t border-border/60 bg-white/35 px-5 py-10 backdrop-blur-lg dark:bg-black/10","children":["$","div",null,{"className":"mx-auto flex max-w-7xl flex-col gap-7 text-sm text-muted-foreground sm:flex-row sm:items-end sm:justify-between","children":[["$","div",null,{"children":[["$","div",null,{"className":"mb-3 flex items-center gap-2 text-foreground","children":[["$","span",null,{"className":"grid size-7 place-items-center rounded-lg bg-gradient-to-br from-violet-600 to-fuchsia-500 text-xs font-bold text-white","children":"S"}],["$","span",null,{"className":"font-semibold","children":"StarWhisper"}]]}],["$","p",null,{"children":["© ","2015","—",2026," ","Lethon"]}],["$","p",null,{"className":"mt-1","children":"In Pursuit of Absolute Simplicity."}]]}],["$","p",null,{"className":"font-mono text-xs uppercase tracking-[0.16em]","children":"Powered by Meteor · Made with curiosity"}]]}]}] 8:["$","$L23",null,{"className":"mx-auto grid gap-4 py-4 md:py-0","children":[["$","$L24","whisper-theme",{"className":"group overflow-hidden rounded-2xl border border-white/75 bg-white/65 p-0 shadow-[0_10px_35px_rgba(48,32,90,0.06)] backdrop-blur-xl transition-all hover:border-violet-200 hover:bg-white/90 hover:shadow-[0_18px_50px_rgba(99,60,180,0.13)] dark:border-white/10 dark:bg-white/[0.035] dark:hover:border-violet-400/25 dark:hover:bg-white/[0.06]","children":["$","$L25",null,{"className":"grid gap-5 p-5 sm:grid-cols-[3.5rem_1fr] sm:p-6","href":"/posts/whisper-theme","children":[["$","span",null,{"className":"font-mono text-xs font-semibold tracking-widest text-violet-500/75","children":"01"}],["$","div",null,{"className":"min-w-0","children":[["$","h2",null,{"className":"text-balance break-words text-xl font-semibold tracking-tight transition-colors group-hover:text-violet-700 sm:text-2xl dark:group-hover:text-violet-300","children":"Whisper 样式一览"}],["$","p",null,{"className":"mt-2 text-pretty text-sm leading-relaxed text-muted-foreground sm:text-base","children":"本文章现被用来测试主题样式"}],["$","div",null,{"className":"flex gap-3 text-muted-foreground mt-4 flex-wrap text-xs","children":[["$","div",null,{"className":"flex min-w-0 items-center space-x-1","children":[["$","div",null,{"className":"inline-flex items-center space-x-1 min-w-0","children":[["$","$L26",null,{"ref":"$undefined","iconNode":[["circle",{"cx":"12","cy":"12","r":"10","key":"1mglay"}],["path",{"d":"M12 6v6l4 2","key":"mmk7yg"}]],"className":"lucide-clock","size":"14"}],["$","span",null,{"className":"text-sm","children":"2019 年 11 月 7 日"}]]}],["$","$L27",null,{"children":["$","$L28",null,{"children":[["$","$L29",null,{"className":"text-sm underline cursor-alias","children":"(已编辑)"}],["$","$L2a",null,{"children":["$","span",null,{"className":"text-sm","children":"2021 年 6 月 29 日"}]}]]}]}]]}],["$","div",null,{"className":"flex min-w-0 items-center space-x-1","children":[["$","$L26",null,{"ref":"$undefined","iconNode":[["path",{"d":"M13.172 2a2 2 0 0 1 1.414.586l6.71 6.71a2.4 2.4 0 0 1 0 3.408l-4.592 4.592a2.4 2.4 0 0 1-3.408 0l-6.71-6.71A2 2 0 0 1 6 9.172V3a1 1 0 0 1 1-1z","key":"16rjxf"}],["path",{"d":"M2 7v6.172a2 2 0 0 0 .586 1.414l6.71 6.71a2.4 2.4 0 0 0 3.191.193","key":"178nd4"}],["circle",{"cx":"10.5","cy":"6.5","r":".5","fill":"currentColor","key":"12ikhr"}]],"className":"lucide-tags","size":"14"}],["$","span",null,{"className":"text-sm","children":"Theme"}]]}]]}]]}]]}]}]]}] e:[["$","meta","0",{"charSet":"utf-8"}],["$","meta","1",{"name":"viewport","content":"width=device-width, initial-scale=1"}]] b:null 10:[["$","title","0",{"children":"StarWhisper"}],["$","meta","1",{"name":"description","content":"In Pursuit of Absolute Simplicity."}],["$","meta","2",{"property":"og:title","content":"StarWhisper"}],["$","meta","3",{"property":"og:description","content":"In Pursuit of Absolute Simplicity."}],["$","meta","4",{"property":"og:type","content":"website"}],["$","meta","5",{"name":"twitter:card","content":"summary"}],["$","meta","6",{"name":"twitter:title","content":"StarWhisper"}],["$","meta","7",{"name":"twitter:description","content":"In Pursuit of Absolute Simplicity."}],["$","link","8",{"rel":"icon","href":"/favicon.ico?favicon.2vob68tjqpejf.ico","sizes":"256x256","type":"image/x-icon"}],["$","$L2b","9",{}]]