#algorithm #code
题 2：取出数组中第 K 大的元素（排序 / 暴力）
直接用 a.sort();a[-k] 好了，如果是 iter:

fun Iterable<Int>.topK(k: Int) = PriorityQueue<Int>().run {
forEach@Iterable {
offer(it); if(size>k)poll() // bail out the smallest
}
return peek()
}

也可以修改快排：右先浅先，那么 左指针涨到>k 时，a[-k:] 一定是有序的
很多题目就是在原算法递归前，加优化性的断言

有序队本质上和 iter.minMax 都是逐个比较，但利用了小顶堆(二叉树数组化) 决定顺序
N叉数组化 则被用来实现 Set<A-B配对>, unionFind ，原理是 union(A,挂到B), (C,A) 后，CA的共同祖先是B, AC也该一样

题 1：实现三个线程轮流访问一个变量（加锁 / 原子）
use! java.util.concurrent atomic locks
use kotlin.concurrent

- useAtomic
at:
x AtomicInteger(0) //回合数
job:[i]
if x.get%n == i:
say("Thread $i: x = ${x.get}")
x.incrementAndGet
Thread.sleep(1000)

- useLocks
at now:
x 0
go ReentrantLock()
job:[i]
go.withLock: if x%n == i:
say("Thread $i: x = $x")
x=: +1
Thread.sleep(1000)

- job(n=3, :Fn1<Int>)
(1~n): thread {
loop $Y: fn(it)
}.join

因为x+1 只由一个核计算，不会出现赋值前x已经改变的情况

#ai #hard https://t.me/NewlearnerChannel/11418
感觉反正也看不懂。。GPT 训练流程

#math #algorithm Gauss消元 可以用来解鸡兔同笼、化学分子式等方程组😅

(#bing 第一遍就能用了，但还是有5小时“确认” 算法，最后大体没改

# 对系数组A，进行高斯消元求 Ax '=b'
def elim(A, b):
M = np.hstack((A, b.reshape(-1, 1))) # M=(A|常数项b)
n, m = A.shape; assert n==m, "没有唯一解"

# 向下找j格最强的行，换为本行
for j in range(n):
i=np.argmax(abs(M[j:, j]))+j; assert M[i,j]!=0, "主元为零"
if i!=j: #; ij=(行ji)
M[[i,j]] = M[[j,i]]
# j归一，将下行的j格消为 0
M[j] /= M[j, j]
for i in range(j + 1, n):
M[i] -= M[i,j]* M[j]

就只添加了「逆序代入」、确认了「向下归一」化简了😅 M[i] -=m[j]*M[i,j] / M[j,j]

(没错，”大无语事件“，数 学 家 们的代码太乱了，bing都不知道谁是正确…… 我甚至无法证明 逆序带入“不就是” M[:, -1]

也倒了很多苦水，包括在kt讨论组
—
无语了，你看不懂的信息能不能不要过滤掉？ 广度和深度都挺重要 OK？
如果我致力于用100行描述好本质10行的一些组件流程，我也能很有信息量

但是也要去写实质上值得100行的算法和思想的， 不能因为“没功能” 就耽搁掉

不要把设计的创作者和 CS Math 毕业生混为一谈，实现功能算法和设计做法是意义不同的
ice1k 的中文博客都删了，而且看我你至少能复制到base64,fft, 缩进解析, parse(x).toString 这些罕见功能模板……

（不过有时觉得自己很像 GPT ，写的许多代码根本没有运行过，都只是看起来正确

我想锐评几个数学文档：
- wikiZH 除了注释🙉都看不懂，自然语言噪声的极限。 所以矩阵是否有要求 n==m 啊？
- wiki 伪代码的VB式循环。 A[i, k] = 0 是啥？不该用 -= 吗
- OI wiki 根本看不懂公式和 C++ 有啥联系. L7-L13 是一段查k=max() 的面条代码🤮, EPS 是浮点误差，这和消元有个?关系
- bing 一会说 n<=m 也行，一会把 A,b 分开操作，突然又用单参数， 最后才发现 A|b = 单增广矩阵，A必须是正方

#dev #algorithm #statement 「只要搜对了接口」
把问题写出来，就等于解决问题。顺便消灭所有事后、事前的坑

所谓编程语言能力，就是这样创建「伪接口」叙事的编程习惯，带来了治未病的价值观。

伪代码，不通用、不好思考
真代码，不易于溯源和穷举

我不需要「设计模式」，因为真实生活的对象之间的模式，比刻意设计术语和样板更加深广
我没有编过程，只是用数据的算式，展示算法和用法、答案和问题的本来面貌

OCR截屏, 字符画 <10行
fib 和杨辉三角、螺旋矩阵的定义 <20行
自动重构 map({it+1},[0]) 的py代码并不困难，包括可视化的 astexplorer.net , godbolt.org
YAML式缩进不难解析, reader 和 writer 也只是格式“正则”的附属品

强类型序列化 只是让T的元类创建 cat()读, cut(写) 所需的val-类型字典
中文SQL 也“可取”
Linux内核 CRIU 能实现进程级“快照回溯”, Lua 能编写设备驱动, Docker 和 Magisk 都依赖 overlayFS

Base{16,64,32,.} 当然是64行; emoji, 也可以调整 👩🏾‍=👩+ '🏾
Trie,Suffix 用前缀分组优化的枚举，但在1行内就能创建; 稍微加个失败指针，变成AC，退化成KMP
频谱 的正逆实现只有5行,js 40行: dot(x, exp(-2j*np.pi * i/N * i.reshape((N,1))) )
解方程组: 转为矩阵版 xyz 编号为 j。逐行i化为'关于j'，其他行消(减)去j， 最终 解=M[j, -1] for j

简单是可靠的先决条件，不是可靠的牺牲品。

这列出的每一个算法，多可以用5千字来解析，但它们甚至不配被称为算法。 因为没有问题的答案、不被语境束缚的思考，在物理学和计算机上都缺少根据。
因此，我的 编程无关计算机，就像天文无关望远镜

#py 周刊

- Excel 支持 import pandas, statsmodels, matplotlib / seaborn 了, Guido 亲自推广（可能是云计算，要订阅）
- PowerToys添加“可交互”的截图
- Google 等各种大公司的技术blog #list
- #apple #design 设计师法则
- #learn 看美军的脏话官话(F-words)学英语 。

- 单靠 #sql 如何保存数据
- APL 里有的 py 基本列表处理式
- FastAPI 最佳实践 list
- async stdlib: 对比理解各种流行实现

- fixit linter: py 版本的 IDEA 自动迁移 (无AI), cffi: 我用什么 C parser 链接到.h 文件
- 用 difflib 开发一个文件比较工具
- KeymouseGo, ahkunwrapped py : 类似按键精灵的鼠标键盘录制和自动化操作
- quivr：生成式 AI 打造你的第二大脑, trafilatura: GUI 文本/评论 爬虫
检索非结构化的信息，可以理解成支持人工智能的 Obsidian。可以处理各种形式的文件如文本、图片、代码、音频和视频等，依赖于 ChatGPT、Docker、Supabase

- FastAPI + SSE new EventSource('/http流') API 下发文本消息
- 用py编写代码高亮图片生成 (carbon.now.sh ..)
- Streamlit 地图高亮生成
- Streamlit GPT4文件摘要工具

- Mojo #ai #rust: 对Py的渐强类型&优化 的语法改进 [waitlist]

def mandelbrot_0(c: ComplexFloat64) -> Int: #CPU FMA优化, 1Mojo = 15Numpy = 89CPy
    z = c, nv = 0
    for i in range(1, 200): #清晰度
      if abs(z) > 2: break
      z = z*z + c
      nv += 1
    return nv

👀 Rust 确实是资本的语言，融资1亿刀乐

#code #algorithm 埃氏素数筛

def gen_primes():
    """Generate an infinite sequence of prime numbers."""
    D = {}
    q = 2
    while True:
        if q not in D: D[q * q] = [q];yield q
        else:
            for p in D[q]: D.setdefault(p + q, []).append(p)
            del D[q]
        q += 1

#py 周刊
#recommend #tool 带有 "Android 子系统", taskmgr,... 的网页版Win12 demo 🎨
#algorithm Hello Algo 多语言实例
#tool EasySpider +可视化编程
#android 高级包管理器
js: await using fp = openFile()

Flask 深入探索: 请求上文、会话、CORS
fastapi-users：开箱即用的 FastAPI 用户管理库
Django 发送带有验证链接的电子邮件
FastAPI 使用 Tailwind CSS + SQLAlchemy
Streamlit 初学者指南: 类似 Juypter UI
Polars：快如闪电的 #rust DataFrame 库, 优化表达式和上下文、惰性
dara：轻松创建交互式 Web 图表程序 📊
Python Asyncio 之 socket() 网络编程理论详解

可视化+深入学习数据结构与算法：C++、Swift、Python、Java、C#、JavaScript
bisect,heapq 如何保持数组有序
upiano：命令行里的钢琴 FluidSynth
探索国家/文化多样性：Pyetho — 用于列出国家及其语言
深入介绍 Python 3.12 中的永生对象（如 None 关键字和小整数）
下划线的十种用法(REPL, match, i18n)


7、h2ogpt：私人文档+图像的问答 PyMuPDF 识别与提取表格
8、refact：开源编码助手，支持自动补全、代码重构、代码分析
9、dify：创建自己的 AI 应用 +CN

#py 周刊
HackerNews 等新闻聚合
本该辅助思维的工具，如何异化我们
pysentation: 在终端展示你的py代码
js anti-debug: 尝试阻止全编程界最优秀的 DevTools,
https://github.com/theajack/disable-devtool/blob/master/src/detector/sub-detector/func-to-string.ts
v0.dev: 生成预览和迭代HTML设计

Mojo 🔥 Linux版本可用, 自带 Tensor(nd),DType 支持
(ps. 这人怎么 parser 都不会写啊， (1+ 换行 1) 时解析失败,等待下一行不就行了吗？ 他只是写了个众所周知的hint
这个 let var 是干嘛啊(还有Java式的 class Benchmark..)，Python 简洁的优势都丢了

🤖 Falcon 作为当前最大的开源大模型，有 180B 参数，在 3.5 万亿词的 TII RefinedWeb 上训练
jieba的替换: pkuseg-python , hanlp

#wasm #plt 500行迷你C编译器
🥧 半手工绘制 plt.极座标直方图

📈 #algorithm min/maxHeap 有序列实现
#bin Bloom filter 集合 位运算实现 —性质类似WeakSet, 非常快

🐳 用Podman部署py包 [维护pip包]
📝 使用 Protobuf message{} 储存和传输

protoc --python_out=. .\music.proto

from music_pb2 import Library
Library().add(music).K=V
lib.SerializeToString()
lib.ParseFromString(f.read())

compress：基于个人语料库的快捷输入工具
gpt_academic #zh gui : 为 ChatGPT/GLM 提供实用化交互界面
GPT 学术优化，特别优化论文阅读/润色/写作体验，模块化设计，支持自定义快捷按钮&函数插件，支持 Python 和 C++ 等项目剖析&自译解功能，PDF/LaTex 论文翻译&总结功能

#py 周刊
Python,YAML 的缩进为何比C系优秀

4、strictyaml：类型安全的 YAML 解析和校验库
用于解析 YAML 的受限子集，拒绝解析丑陋的、难以阅读和不安全的 YAML 简写，有严格的标记验证和直接的类型转换
TOML 文件格式有什么问题？
“改进的” INI 文件，是 pip 推荐的配置文件格式。但连 TOML 的作者也认为它是一种糟糕的格式！

12、Python Fire：自动生成命令行接口
谷歌开源的一个用于生成 CLI 的库，Github 25K star。这篇文章介绍了它的一般命令、组合命令、链式命令、复杂命令等用法。

5、facefusion：更先进的换脸工具
最新开源的一个人像换脸库，star 涨得飞快！（star 6.9K）

#tool 把网页转换成 Markdown 格式存储
一站式 LLM 底层技术原理入门指南
基于数学点乘的 Transformer原理引言
7、instagraph：将文本内容或 URL 转换为可视化的知识图谱
可以提取复杂信息中的名词实体，生成它们的关系图谱。使用了 GPT-3.5，以及 Flask

该以一种怎么样的心态对待开源
🐎 网易云音乐 Tango 低代码引擎正式开源！

文章集 Writing an #OS in Rust , 从linker-BIOS ABI到算法
Thorium.rocks : Chromium 改版

10、使用 Django 和 HTMX 开发一个数据库搜索项目
一篇详细的 Django 项目教程，实现一个全栈的项目。文中有作者的教程视频。

11、异步 SqlAlchemy 和多数据库管理
利用 asyncio 和 SqlAlchemy 库，文章探讨了如何有效地连接和管理多个数据库，获得可扩展且具有弹性的架构。文章介绍了两种实现方法。

前端新轮子 Nue JS，作者称要打造全新的 Web 生态 [docs]
tornado Web 框架 的协程调度原理

14、为什么 Python 代码在函数中运行得更快？
代码执行的工作原理是什么？如何测试与优化 Python 函数的性能？

13、我最爱的解 LeetCode 问题的 Python 技巧

#algorithm 玩转遗传算法
遗传算法（Genetic Algorithm）是一种受生物进化理论启发的优化算法，用于解决复杂的搜索和优化

9、调试 Python 中正则表达式的灾难性回溯
作者使用 py-spy 定位一个 CPU 100% 占用问题，找出了罪魁祸首的正则表达式

Python abc 类型提示的轻量化：接口

from typing import Protocol

@typing.runtime_checkable
class DuckLike(Protocol):
    def walk(self, to: str) -> None: ...

#py #code #recommend 说到有趣的py接口，有个 iself()
def read_as_io(f):
class T(io.TextIOBase):
read=lambda o,size: f(o)
return T
-匿名对象
之前写贪吃蛇 snk.c 就用到链表
不想缓冲区溢出的话Vec还是好的。C里你要实现[] 需要懂链表/strcat， rust 里你写 Vec<i32> push 就好了
Rust的生命周期现在基本不需要考虑（尤其是对应用开发时）， type infer 是非常自动的

# 匹配左右括号 paren
_c01 = {'(':')', '[':']', '{':'}'}
def eat(s,c1):
  for c in s:
      # 如果是左括号，就把它压入栈中
      if (c1:=_c01[c]): ifErr='行号'; eat(s,c1)
      elif c==c1:return # 如果是右括号，左括号便与之匹配
      else: assert'','多余项而栈空' #仅支持纯括号文本, 否则要_c10,反向
  assert c0=='eof','栈尚不为空'

-S表达式

optab={[';']:-1, "=;+ -;* /"}
exp=(s/*token o算符x单项*/, l/*evels 大则紧,深 *<+ */)=>{
  let o,x=()=>add(Number(s())), ord=[],add=x=>ord.push(x),
  at=O=>{let A,B; x()
    for(o=s();(A=l[o])>=(B=l[O]);)if(A!=B)at(o);else{add(O);x(); O=o;o=s()}  add(O)
  }
  at(";");return ord
}

-运算链

叠加整理了下思路 一个 T(x).f(arg): T 的链，并试图兼容还未f()的T

data Adder(list:Ln<Int>)
  - add()=list(Sum).sum

- [].as( Sum(0, (A,B)=>A+B) )
["x"].as( Sum(it, (A,B)=>A+B) ) 就相当于 reduce,fold的 ，不需要class封装，用于支持分组过滤

在没有this的语言里调用链挺好玩的，但java里都有 new ArrayList(){{add(1,2); add(3)}} 这种用法
Player.MP3("")|:
time=length*.5
title=" hello ": "## ${trim()}"
start()

有趣的脚本语言：
Vlang (Go+Rust)
Esno (滤镜图)
Gravity(Kt)

class Vector{var..}
var v1 = Vector(1,2,3)
"\(v1+Vector(4,5,6))"

Wren(ES6+C#)

class Wren {
  flyTo(city) {
    System.print()
f=Fiber.new { //有点像Duktape
  ["small", "clean", "fast"].each {|word| Fiber.yield(word) }
}
while (!f.isDone) System.print(f.call())

coco Py(函数式)

def int_map(
    f: int -> int,
    xs: int[],
) -> int[] =
    xs |> map$(f) |> list

Latte

class User(id: int, name: String)
object Singleton
interface Supplier
    def supply
fun sum(a, b)
  for i in 0 until a.size
    println(a[i]+b)

val (x,y) = Bean(1,2)
o match
 case People(name, age,Bean(x, _)) if age > 20 => ...

分词器
Lexer=kv=>{
let re=Object.keys(kv).map(x=>`(${x})`).join('|'), mf=Object.values(kv),m,i,j=0
re=RegExp(re, 'gy')
return (s,ontok)=>{
for(m of re[Symbol.matchAll](s)) ontok(
mf[(j=m.findIndex((x,i)=>null!=x &&i!=0))-1](m[j]), (i=m.index), i+m[0].length
)
}
}

f=Lexer({
'\\d+':parseInt,
'[a-zA-Z]+':s=>s,
'\\s+'(){}
})

rep=(txt,on, n=null)=>f(txt,x=> (x==null)?on(' '):
(x.substr)? (on(x.repeat(n)),n=null) :
(n=x)
)

buildAry=(f,a=[])=>(f(x=>a.push(x)), a)

rnSel=(e,A,B,o=new Range)=>(o.setStart(e,A),o.setEnd(e,B), o)
rnHL=(e)=>
e.oninput=()=>{CSS.highlights.clear(); f(e.textContent, (x,A,B)=>{
let on=tag=>CSS.highlights.set(tag, new Highlight(rnSel(e.firstChild,A,B)))
;(x==null)?0:
(x.substr)? on('str') :
on('num')
})
hout.textContent=buildAry(rep.bind(0, e.textContent)).join('')
}


document.write(`
<style>::highlight(num) {
background-color: #f06;
color: white;
}
::highlight(str) {color:red}
</style>
<div contentEditable id=hl></div>
<mark id=hout>
`)
rnHL(hl)

#PLT #algorithm vs Moonbit 结构化编程 🥰 无印痕流控+内联可变

pkg
dbg
- Ln<Int> qsort=zero{this}:
this[0]:[p]
this{<p}.qsort+this{!<p}.qsort
- main
d=[2 3 6 8 1 4].qsort

#ai #algorithm 看来GPT3在你知道一些基础时，还是可信的 😱

>这是高斯消元.py 的实现：

def elim(A, y):
  n, m = A.shape; assert n==m, "需方阵"
  M = np.hstack([A, y.reshape(-1, 1)]) # M=(A|常数项b)

  for j in range(m):
    # 向下[j:] 找元最强的行，换为本行(i,j=j,i)。会在回代里获取
    i= np.argmax(abs(M[j:,j]))+j; assert M[i,j]!=0, "无解,不可逆矩阵"
    if i!=j: M[[i,j]] = M[[j,i]]
    # 归一，因此后面行消它
    M[j] /=  M[j, j]
    for i in range(j+1, m):
      M[i] -=  M[i,j]* M[j]

  x=np.zeros(n) #逐行 y-约旦回代
  for i in reversed(range(n)):
    x[i] = M[i,m] - M[i, i:m] @x[i:m]
  return x

请你将其改为矩阵求逆

<这个实现中，我们将矩阵 $A$ 和单位矩阵拼接在一起，得到一个增广矩阵 $M$，然后对 $M$ 进行高斯消元，最终得到的矩阵就是 $A$ 的逆矩阵。具体来说，我们将 $M$ 的左半部分（即 $A$）化为单位矩阵，然后 $M$ 的右半部分就是 $A$ 的逆矩阵。

>不愧是AI，轻松就做到网络博文做不到的事！
谢谢夸奖！我会继续努力的 💪🤖💻

总之就是只改了两处，然后成功了

爆杀那些把矩阵求逆，独立于gauss消元来讲的中文博客…… 真的太牛了

#recommend #learn #algorithm
https://github.com/krahets/hello-algo
https://github.com/practical-tutorials/project-based-learning

#algorithm #history 方脸：为计划经济诞生的「线性规划」 https://youtu.be/1cLWzo78Q5g?t=900
#code

import numpy as np
import scipy.optimize as lp

# 优化目标函数：maximize 2X + 3Y
c = [-2, -3]
# highs限制条件：5X + 8Y <= 50, 10X + 12Y <= 120
A = np.array([[5, 8], [10, 12]])
b = np.array([50, 120])

# 设置变量的取值范围
x_bounds = (0, None)
y_bounds = (0, None)

# 解决线性规划问题
r = lp.linprog(c, A_ub=A, b_ub=b, bounds=(x_bounds, y_bounds), method='highs')
val,x,y=-r.fun,*r.x
print(f"最大利润为 ${val}，此时生产 {x} 个产品 A 和 {y} 个产品 B。")

在列宁格勒呢，有一家胶合板生产厂。它有80台两种型号的机床，生产5种不同型号的胶合板。而不同型号的机床生产胶合板的能力不同。

那么，如何合理的分配每台机床的作业时间和物料投入，使得胶合板的产量最大，就是胶合板问题。这个呢，看起来是一个简单的数学问题，和我们日常做的一些高考数学题呢是类似的。当然了这对一个高中生来说，只要好好学数学，这个问题呢，并不难解。但是问题是这里面我们能解出来是因为我们只考虑了单一工厂的前提之下的。可是苏联的实际情况却不同，

就比如这个胶合板的生产。除了要考虑自己的工厂怎么样生产效率最高，它还要考虑胶合板的原材料，比如木材的供应量。而考虑到木材的供应量，除了要考虑伐木工人的数量，还要考虑到伐木机的生产数量。而伐木机的制造数量又要考虑到钢厂的产量。此外，胶合板的生产还要考虑到使用的问题。胶合板有的时候用于房屋建设，有的时候呢也用于飞机制造。因此，还要考虑整个国家的房屋建设数量以及飞机制造数量。而飞机制造数量房屋制造数量又牵扯到非常多的问题。所以一个胶合板的生产规划是远比我们想象的要复杂得多的。

而根据苏联自己的记载呢，在1960年代，苏联国家计划委员会要对苏联及其加盟国的10,500个商品实施生产计划，而统一规划生产的工厂更是达到百万之多。想要分配这些产能在没有计算机的时代是一个非常困难的事情啊，甚至在当下有计算机这也是一个非常困难的事情。而为了优化这个计算，苏联时期还诞生了不少的知名经济学家，比如列昂尼德坎托罗维奇，他就在优化上面提到了胶合板生产问题时提出了线性规划，从而获得了1975年的诺贝尔经济学奖。所以这个计划经济虽然是个笑话，但是实施起来并不像我们想象的那么简单，只要国家一声令下就可以搞起来。

我们看历史总说中苏交恶之后苏联撤走了原子弹的专家撤走了这个那个专家导致中国的科技发展停滞。但其实对于当时中国最为致命的不是撤走专家之后原子弹发明不出来，而是撤走专家之后中国的计划经济搞不起来了。苏联因为有一系列的数学大师和经济专家，虽然他的计划经济呢可能会因为生产规划的问题导致大饥荒，但是，起码在有数学家和经济学家的前提下，这个计划经济他是能跑起来的。 🤓

#learn #cg #go #bilibili #algorithm
> https://www.bilibili.com/video/BV16g411B7Ff
尝试实现下视频里的”大一“代码，感兴趣的话可以深耕

并不天才啊，就是 https://www.desmos.com/calculator/ 里像素化个灰度函数 (y-abs(x)^c)^2+x^2=1
可以把每个运算当成对样条的变换，例如删掉abs(x)不会对称
https://mathworld.wolfram.com/HeartCurve.html
推荐这个超好玩的 https://www.shadertoy.com/results?query=Boids

https://golang.google.cn/tour/moretypes/18
你可以 在Go入门试玩一下
或者下载 Jupyter , p5js
推荐 https://jupyterlite.github.io/demo/lab/index.html?path=p5.ipynb
> 我记得大学的时候，我实现一个水波纹，搞了快一星期
那是因为你的工具没用对

只要降低五花八门IDE的杂音，只交互式写代码就可以了
创作式编程就是需要注意力
https://codelabclub.github.io/blog/2020/06/28/当我们谈论编程时，其实是在谈论玩乐与创作/
就是吧，你用jspy写，不关心杂七杂八的部署问题
就ok了

> 像素着色器才能并行，利用GPU的性能
当时就是C++写的，有个很垃圾的国产引擎（cocos2dx）
numpy,torch也行啊…… GLSL也不是很难
性能不是最重要的，主要是效果好

其实你在墙外，会搜关键字就能比许多人强了

因为编程的本质是摘抄缝合
像百度那种垃圾搜索引擎是不用看的
用那种工具搜那种圈子的程序员没有进步能力
https://coolshell.cn/ 已猝死的陈大佬说的很清楚，程序员的第一工作就是拉黑内容农场

陈大佬自己也开公司呢，不过去年猝死了
挺可惜 他也是个公知
他明明是个很广的全栈程序员
可惜天妒英才， 每次都是优秀的程序员死，称职的活
然后七大姑八大夷拿这个去劝退称职的程序员

>那么要用哪种搜索引擎好？墙外那些吗？
duck.com bing.com 什么的啊
反正不能用墙内的
对程序员来说一手资料是最重要的
英文wiki都比中文全面
其实不要以为只有抖音快手在洗稿，GFW只是内对外的墙
中国内部各圈层的资讯都是极不流通的
所以张雪峰这种人能火

duangsuse: #读写线 #bin #FP #algorithm
1.所以我认为这种partial是错的，比如lexer吧，至少把Node的wsPre 保留下来-比如对注释文档，这样rust fmt/doc也会好写很多。

2.你举得例子太tricky了，而且JSON就不是一种minimal dynKV- 它有一大堆无效的;, 需要过滤

3.内存buf问题应该交给linux swap处理，而且用 fit(inoutT参数) 替代read():T 并不会阻止windowing

4.所以只要在pull的回调里注册onmut，就能免费定义出writeback()，当然实践起来确实没那么简单

duangsuse:
冷知识： int** 可以被scanf读取

C是存在静态数组的，i=0..sizeof a/sizeof int
https://blog.csdn.net/GGN_2015/article/details/119902369

我们可以确定一个共识： readXX() 的本质，是通过ret和赋值stack var把file的一部分加载到mem的KV乃至于[]里，这也是为何libc的tcp和inode都是 iostream API --以及为何会jspy的人不懂C移植

因此，虽然它叫IO，却被框在call-return并赋值、 forEach-call并write 的枷锁里，明明只是asn.1那样的databind手段，却被递归下降的样板代码给框住了

但这种模式在C里，就是struct,set_type和set_size的递归下降，可以靠os的vm功能缓存、1次读完 mmap():bytes，当然任何新语言都没有直观对应出这个

如果有些struct var 是不需要读的，完全可以用 isDbg: 来mock自己读到了，然后不实际赋值，反正JS是动态的

对了，你觉得为啥js版bytes(blob,abuf) 都不提供流API

难道它是想让用户手写py structs那样的封装？

py有cString,jvm有Reader，js没有byte流接口；那就是只想read一个二进制header喽？

TextDecoder那个啊，感觉java味大
尤其是async*() ，不得不用State(var)取代吧

https://developer.mozilla.org/en-US/docs/Web/API/Streams_API

最大的功能就是补丁fetch()和onrequest ，其他和WebSocket重叠了

duangsuse:
额。。就是讲用回调的人为何被coro不明觉厉到了，呗

Object的本质就是可扩展的fn.bind()
打包好避免难传递

用回调的人根本没有错，错就错在coro.then为什么那么间接，还没人解读

不同的OOP还是有区别的，虽然大家的实质都是在提供参数N->1和if typeof 这些CLOS都懂的函数式风格的技术

但Java对closureArg 样板化的支持（通过重写和重载）更好，这也是为什么MBPC classdef比lisp的defclass有意义
往大了说语法差异都是没有意义的，无非就是alloca和malloc、递归下降、流水线这些算法嘛

另外，这还有个魔怔的中英emoji双语嵌入式编程支持原型链 def T.class(vars):ret{}

https://gitee.com/chen-chaochen/lpk#https://gitee.com/link?target=https%3A%2F%2Flosu.tech%2Fplayground

#java #news #algorithm https://www.ithome.com.tw/news/163820

当我听说这个月Gosling退休时，其实我挺开心的，因为java API在我看来普及了不少无语意的知识，为八股文爱好者提供了极大方便，可以说是糟粕
这样给程序员带来麻烦的老灯，退休当然是好事，让他们的OOP繁衍下去是浪费人类的逻辑

但另一方面，这并不是JDK本身或 Doug Lea 等工程师的问题。与C++相比，java并不难。除了简化发布流程，还自带电池，提供了许多xml这类最终被滥用的工具
尽管在数据结构/IO上灵活性低，以及导致了十亿美元bug（nullish），java API并没有做错什么.

错就错在跨领域研究编程范式的人太少，以至于过去20年里没有新模型，Rust go 这些还是在拿interface 模仿OOP，没有一种把 json struct enum union override,FP 混合起来的通用编程方法

#algorithm 动态规划 dynamic programming
eg. lcs公共子串, knapack背包最佳配重, edit-distance编辑距离
http://www.bilibili.com/video/BV1FJ4m1M7RJ

🌚这是连“二参记忆化递归”这个常识都没说出来啊。
其实DP的经典案例是fib f x=x if x<2 else f(x-1)+f(x-2)
转化为一维的 f=[0,0]; f.i=f.(i-1)+f.(i-2)
这样，动归比递归的主要难度，是确立基线，以及用抽象的2D数组.ij取代fib()思考「状态转移方程」

二者的相似，好比「积分傅里叶变换」与离散DFT
动归比 @memo def fib 只优化了常量时间
fib只需要朝0的方向计算两个子问题，可以 iter 优化

实现上，如 lcs
f(,)=0
f(a,ab)=1
f(b,ab)=1
来，可视化一个corner case!
\ a b
a 1 0
b 0 2
可见，参数网格

r.(0 0)= A0==B0
r.(i j)= (Ai==Bj? 1:0)+
try max( r.(i-1) r.(j-1))
i==0: r.(0 j-1) #第0行没法再减
j==0: r.(i-1 0)

晦涩就对了，因为它等效这个：
lcs([A],[B])=A==B
lcs([A,a],[B,b])=
max(lcs(a,b) lcs(b,a))+(A==B? 1:0)
lcs([A,a],[B])= lcs(a)+(A==B? 1:0)
+2分支

f(a,ab)=1 直接匹配AaBb +1
f(b,ab)=1 则匹配ABb，居然也与表格等效

更易懂了吗？见仁见智，尤其是 (a,b)(b,a)是干啥？ 当然，因为lcs本身就有交换律啊..
不过我要指出，这个语法是有问题的(尽管 #haskell 在红黑树/快排上比cpp可易读不止一半)，如果专门对DP设计，一定有 np.einsum 那样更优雅的表述

DP教学总是涉及表格[i,j] 而可视化并不方便，不过解「编辑距离」，你总得先学diff(abc, aBc)=[1: -1+B] 怎么计算吧

* https://t.me/dsuses/5335 基于memo的lcs，人不如AI
* https://t.me/dsuse/18877?single fib流

只能先留个坑🌝触摸屏累死了

#rust #go #algorithm UmbraString 是对带长度指针(py.bytes, rs.slice) 的(免链接inline)，而 SwissTable 是对Hash预分组查表的免链接！

我们知道，Java 存在(装箱boxing) 一说，也就是int,char等字面值的堆分配 (这是泛型擦除 vs template<>化新建的编译期细节)，因此JDK8用class Stream.OfInt{}缓解了reified泛型的缺失

那么，(拆箱unwrap) 其实就是在值的内存上内联，像C++栈分配。 除了禁止null，拆箱在运行时有省内存GC、免链接、CPU快取等好处

这么好的算法升级，实现难吗？
map采用预分组查表,哈希值冲突(哈希值一样)的键值对会被放在一个桶中，查找桶=hash(key) mod size，然后再遍历桶中Eq的元素，这里有通过额外的bit做更快的检查。 #dalao https://gufeijun.com/post/map/1/

一旦map的负载因子(键值对个数与桶个数比值)过大，查找需要线性遍历多个桶，性能会退化为O(n)，所以这种实现需要更频繁地对桶进行扩容，保持负载因子在低水平。
拉链法是大多数编程语言的选择，每个桶后面跟上一个链表，所有的同义词通过链表中节点形式串联

SwissTable 使用一种称为Closed Hashing的方案。每一个哈希值都会有一个自己的槽位(slot),槽的选择是由哈希值决定，从hash(key) mod size的槽开始查找，一直往后查找到空的槽(null)
SwissTable也是和内建的map一样采用短哈希(8b hash),以便支持快速检查，但是它的元数据却是独立存储的，和哈希值存储分开。

把hash值分为高7位和低57位：
高7位用在control byte中解决hash冲突 (这7位只是以很低的代价，减少了90%键与键的比较。)

低57位是slot的指针，每个slot对应一个1一个byte的控制字节。

Control byte的高1位用于表示状态 0xFF=undef, 0x80=null值 ，低7位用于存储hashcode的高7位
128bit对齐的连续8字节的control byte称为一个group

使用这种方式，可以通过SIMD 指令并行比较 16 个短哈希，比 std::unord_set 快两倍 （map只是K:V元组按K搜的set）
Flat hashtable不仅仅只是CPU CACHE友好，这样的结构配合原子操作，相信很容易做出一个并发版本的hash table

#algorithm #防自学 🤓 让我来示范一下怎么概括算法思路
要介绍的是在stdlib里，用于组织集合类、JSON的3个重要结构: b"ytesPtr", {K:V}, sorted([0 2 1])=[0 1 2]
它们对各种app和其他算法性能效能的重要性，好比json(cbor.me)之于REST、zip之于jvm和pip。 因为是涉及SDK实现的内容，也主观评价下语法设计

下面用胖指针(x64上void*是8b, 胖指16b)、链表、快速排序简单的实现3者 #code

#define Col(...) typedef struct{__VA_ARGS__;} T;

#define T Str
Col(size_t n; char* buf) //C的类型本应默认为指针, *胖指针，像kt那样对Int等类型免链接化。简洁的UNIX里，Type* 快成为public那样的形式主义啦

#define T_Link(E,T) struct T{E x; T* xs;}
T_Link(int,Nums)  //template<T> 允许类型推理，即一致化调用和返回处的<T>。可怜gcc/clang无论对宏还是模板的报错皆如内容农场，不具有可读性

https://colobu.com/2023/06/29/replace-std-map-faster/chunk-index-memory.jpg
用例和 #haskell #code https://gist.github.com/duangsuse/26b80c39e1d8f7549b9cf244d8de1ce4
题外话，闭包值和 x.interface_cast(T) 的双指针&dyn 随结构传入T的函数表

qsort :: (Ord a) => [a] -> [a]
qsort [] = []  
qsort (x:xs) = 
    let smallerSorted = qsort [a | a <- xs, a <= x]
        largerSorted = qsort [a | a <- xs, a > x]
    in smallerSorted ++ [x] ++ largerSorted

UmbraString 和上文Str{n,buf}胖指针一样是16b，但它的.n和jvm一样只寻址[4b:int]的长度，其后最少随4b的免链接char 用于比大小
对于n>12的buf，剩下8b换成指针，指针的高2位用于标记GC信息： 持久pin、临时ref、用后即焚val

很明显！这是一种灵活利用了x86内存布局的b"length"实现，和x32压缩指针一样，节省了sort解指针的时间

SwissTable 是对Hash预分组查表的免链接。我们知道， dict/HashMap/lua.Table 这样的{K:V, K1:V} 单映射常被用于查找和缓存，在C++里更是会区分 unordered_map, rb_map(以排序radix,SortedSet,而非hash作为预分组线索)
它的最简实现是lisp里的链表 T_Link(struct {int A,B;}, int_LnKV) ：没留任何线索来减枝！

即便8b hashCode，也是一定会冲突的，哪怕是int.hash也会因 buck[hash%nBuck] 有限而退化为线性查找，负载因子(kv/nBuck 过大)，这时就要扩容。Go的扩容基于一种空间换时间的优化(图1, 为了减少求余数的冲突，除数都会采用2的指数)
扩容后的冲突集，可以用链表(UnionFind)或数组(slot), 从那往右找
Swiss 更聪明，它对每slot对应1b的元数据，最高位0x80=无效项 ，0xFF=null结尾 ，低7位用于存储hashcode的高7位，这么摘要是为了SIMD128bit 1次对比8个KV
不仅仅只是CPU CACHE友好，这样的结构配合原子操作，相信很容易做出一个并发版本的hash table

快速求余(x,n)= uint32((uint64(x) * uint64(n)) >> 32)
#dalao https://init.blog/fast-newton-sqrt/

float InvSqrt(float x) {
    float xhalf = 0.5f*x;
    int i = *(int*)&x;
    i = 0x5f3759df - (i >> 1);
    x = *(float*)&i;
    x = x*(1.5f - xhalf*x*x);
    return x;
}

最近的一种基于partition(区间而非idx)的快排也很有趣： less than pivotL | between pivotL and pivotR | greater than pivotR