（做 什么用的呢？ 这里

这位先生也真是 🌚👍厉害厉害。

服，服，服。
可惜我没有某先生那么好的口才、没有大佬们那么犀利的语言，不然这种情况，这个大佬恐怕是要被公裁了（实际上已经是这样了）。

值不值：你骂得越多，他赚得越多

我的回答是不值，所以我选择不回骂他。
既然侯先生要拿这事说话，而且丝毫不顾及一点道德行为规范也不像机器人，我想请问我哪天在哪里问候过除了先生您之外您优秀的家人们了。

我非常诚恳地相信，您妈对她的儿子有这样优秀的语言和行为一定是无比的骄傲和自豪吧。为国争光在被国墙了的 Telegram 上举报不法翻墙。

也衷心祝愿先生您能在反违法 fq 的路上越走越远，离实际越走越远。
到时候已经肉身翻墙的人们可能会在墙外对着自己的孩子指着您，说千万别学这个人，和『不『法』』翻墙斗争一生，结果既没有做到什么有意义的事情，也没有被任何有关部门采纳自己的优秀情报，而且连墙是怎么工作的都不知道。

真的是两边走不通啊。

知道duangsuse吗？之前骂老子家人，后来他妈死了

用到了 openssl 的静态库 libcrypto.a 和 libssl.a, 然后编译出来的 so 会把 openssl 的函数也导出... 设置了

set(CMAKE_CXX_VISIBILITY_PRESET hidden)
set(CMAKE_C_VISIBILITY_PRESET hidden)
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl -exclude-libs,ALL")

但似乎只对自身的 c/c++ 代码有效, openssl 的函数还是被导出了

请问一般是怎么处理呢? 有相应的编译参数吗? 又或者是手动用工具直接对编译后的 so 文件进行处理?

[]: 128
["Android"]: 3
["zhihu"]: 2
["KDE"]: 2
["Android", " Low", " Haha", " life", " tech", " tencent", " WeChat", " weibo"]: 1
["share", " tools"]: 1
["dev", " life"]: 1
["Markups"]: 1
["tech", " Telegram", " Hack", " aop"]: 1
["Huawei"]: 1
["通知"]: 1
["Telegram", " Freedom"]: 1
["sysadmin", " dev", " GitHub", " travis", " CI"]: 1
["Sysadmin", " Linux"]: 1
["Linux"]: 1
["Coolapk"]: 1
["Web", " frontend", " HTML"]: 1
["China", " school", " dev", " Android"]: 1
["Haha", " Microsoft"]: 1
["dev", " Life", " Microsoft", " VisualStudio"]: 1
["-}"]: 1
["OOP", " Android", " web"]: 1
["geekapk"]: 1
["doge"]: 1
["CS", " fix", " CSharp"]: 1
["School", " life"]: 1
["blog", " recommended"]: 1
["Android", " bin"]: 1
["backend", " Kotlin", " Java"]: 1
["Share", " Android", " svg"]: 1
["Android", " blogPOst"]: 1
["PL", " CS", " China"]: 1
["Kotlin", " backend", " JVM", " Java", " Moha"]: 1
["Kotlin", " code"]: 1
["life", " tech", " dev"]: 1
["Kotlin", " ALgotithm", " OOP"]: 1
["DuangsuseSB"]: 1
["backend", " GeekApk", " SQL"]: 1
["Learn"]: 1
["life", " wiki"]: 1
["tech", " CS"]: 1
["Mozilla", " ES6", " JavaScript", " frontend", " backend"]: 1
["Telegram"]: 1
["MoHa", " Paper", " haha", " China"]: 1
["OOP", " dotnet", " bad", " OOP_Delegates"]: 1
["Parallelism"]: 1
["ES6", " PL"]: 1
["JavaScript", " backend"]: 1
["dotNet"]: 1
["dotnet", " Csharp", " Windows", " performance", " CS"]: 1
["Telegram", " Channel"]: 1
["weekly", " tech", " CS"]: 1
["CSharp", " dev", " dotnet"]: 1
["PL", " sysadmin", " Windows", " China"]: 1
["sysadmin", " linux"]: 1
["Ruby", " Project"]: 1

Android: 7
dev: 6
backend: 5
CS: 5
tech: 5
life: 5
Kotlin: 4
China: 4
Telegram: 4
dotnet: 3
PL: 3
OOP: 3
sysadmin: 3
Windows: 2
JavaScript: 2
ES6: 2
Java: 2
CSharp: 2
Microsoft: 2
frontend: 2
Linux: 2
Haha: 2
Project: 1
Ruby: 1
linux: 1
weekly: 1
Channel: 1
performance: 1
Csharp: 1
dotNet: 1
Parallelism: 1
OOP_Delegates: 1
bad: 1
haha: 1
Paper: 1
MoHa: 1
Mozilla: 1
wiki: 1
Learn: 1
SQL: 1
GeekApk: 1
DuangsuseSB: 1
ALgotithm: 1
code: 1
Moha: 1
JVM: 1
blogPOst: 1
svg: 1
Share: 1
bin: 1
recommended: 1
blog: 1
School: 1
fix: 1
doge: 1
geekapk: 1
web: 1
-}: 1
VisualStudio: 1
Life: 1
school: 1
HTML: 1
Web: 1
Coolapk: 1
Sysadmin: 1
CI: 1
travis: 1
GitHub: 1
Freedom: 1
通知: 1
Huawei: 1
aop: 1
Hack: 1
Markups: 1
tools: 1
share: 1
weibo: 1
WeChat: 1
tencent: 1
Low: 1
KDE: 1
zhihu: 1

#Haha #CS #Java

不管是 CS 学生还是 10+ 年经验的高级工程师，都非常刻苦，并且不耻下问，为了为 Internet 的建设贡献流量，主动排除垃圾 Oracle 的平台文档使用 Google、坚持坚守一门语言不被垃圾 JavaScript 沾染，他们真棒，为他们点赞 👍

tryUpdate:{
Exception exception = null;
for (int i = 0; i < 2; i++) {
try{
postResult = balabala……
if(postResult.code>299){
throw new Exception("trying get update.\ncode:"+postResult.code+"\n"+postResult.body);
}else {
updateString = postResult.body;
}
updatesJSON = JSONObject.fromObject(updateString);
if(!updatesJSON.getBoolean("ok"))throw new Exception("trying translate update to json.\nstring:"+updateString);
resultsJSON = updatesJSON.getJSONArray("result");
break tryUpdate;
}catch (Exception e){
AlPtLog.warning(e);
exception = e;
}
}
AlPtLog.errors("trying getUpdates:\n"+exception);
continue mainService;
}

可能：
如果 balabala...... 这一部分有一个调用非正常退出（Exception thrown）
那么程序直接恢复到捕获
ex = e; 中执行
break tag; 跳转就不会执行

而输出只有 break tag; jump not taken 的时候才有机会被执行到
这种情况只有 Exception caught 的时候才有，所以 ex 肯定不是 null

控制流后件才有可能是

print(ex);

否则就是 Noreturn （Rust 的 std::never 类型, -> !）

#Android #sb

我要当名人! —> 哇! 我好有名!!! —> 怎么没人搭理本名人呢?! —> 哦, 原来 tg 频道不适合分享｡
—> 辣鸡 tg, 本名人去知识星球捞钱啦!!!

简述事件经过:

Drakeet (以下简称 D) 在其频道宣布, 停更 tg 平台, 转移到某国产付费粉丝平台, 引起广泛讨论
—> 本频道瞎凑热闹, 对此嘲讽了一下
—> D 粉丝群群情激愤, 骂本频道编辑: 包括 蠢、脑残、恶臭 等｡ 我嘲讽你, 你骂我, 很正常｡ 本频道到此为止懒得理｡
—> 直到某 D 粉以小人之心猜测, 说本频道会转发他们的消息, 让大家小心
—> 本频道受到挑衅, 恭喜对方挑衅成功, (我还真转了怎么地) 于是转发, 且仅转发了 这条挑衅的消息
—> D 粉群的群主立马说, 因为我们群的消息被转发了, 所以我们要销毁这个群
—> 本频道于是转发了上述两句, 作为第一条转发引发的后续报道｡
—> 对方反应激烈, 骂了更难听的词｡ 本频道也因此反思, 遂删除了后两条转发
—> 本频道背上对方删群 (或宣布删群) 的黑锅

—> D 粉丝群内, 友好发表和群主不同意见的人, 陆续被踢, 群主说 "我不在乎" 的同时, 也说被踢走之人的坏话 (可恶之人、弱智等)

https://t.iss.one/dsuse/6547

好魔法~

好像不行呢？

Xor 的真值表：

i0 i1 o0
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 0

不需要特别 complex 的情况，input （这里只需要缩小一点，unsigned int8_t 先）是:

0000 0001
0000 0011
0000 0010

0000 0011
0000 0011
0000 0000

0000 0011
0000 0001
0000 0010 ; duplicate

直接 fold xor 一遍... 我也不知道怎么判，看起来没有一个是 0xFF 或者 0x00 的，但是有一个危险信号：

0000 0001
0000 0010

0000 0011
0000 0000

这里，如果 0000 0000 改成 0000 0011 就又回去了（成为全零）
然而这俩没有啥特殊的，他们不代表任何的重复项...

如果是 join xor，则更不可行，因为它只考虑到了相邻两项....

... 看来这算法可能不可行 ...

如果我要写这个算法... 我也不清楚，可能要利用到位移动和信息空间什么的吧...
但是我只有一种 O(n) space 的方法，就是直接创建每个 item 的 count，然后 O(n) travelse 一遍，然后得出结论，空间是 O(n)

去吃饭的路上又想到了两种方法，不过两个都不能做到同时时间复杂度 O(n) 空间复杂度 O(1)

第一种就是利用 HashMap（或者 HashSet），HashMap 插入查询的时间复杂度是 O(1)，但是空间复杂度（理论上）是 O(n), n 是保存的数据个数

所谓 HashMap，就是一个数据结构，它是 Python 里的 dict、Ruby 里的 Hash、Lua 里的（一种情况，Lua 的 table 有两个部分，它融合了数组和 Hash）table、JavaScript 里的 Object、Java 和 Rust 里的 HashMap
C++ stl 的 std::map 我就不清楚，可能是 HashMap 吧

比如说，这里有一个 HashMap m：

m.put(2, '2')
m.put(3, '3')
m.put( object with hashCode method, value )
m.get( object with hashCode method )
m.get(2) #=> '2'

它内部可以这么弄（当然实际上实现基本都是基于桶 buckets 和取余、散列值碰撞时以列表替换的方法，比较复杂这里不说）：

[, , '2', '3']

只是个例子，反正 hashCode 就是能把 Object 映射到 int (哈希值)，从而做到『映射到不需要逐个 equals() 判断的空间』而已

这个算法的时间复杂度的确是 O(n)，但是空间做不到不随着输入长度 m 的变化而变化...（最差情况，空间是 O(m)）

极端情况下，也可以预先分配一个（输入的索引，在 C 里面是 size_t，假设环境是 x86，就只有 32 位二进制）能容下所有 i32 整形数的容器充当散列映射空间（这时候映射函数就是 lambda x: x 了emmm），非常 dirty

第二种方法是二分查找、线性查找和快速排序... 都看出来了

时间不可能是 O(n)（除非使用并行的快速排序，但是依然得遍历第二次...）空间则可以是 O(1) （不需要任何的额外分配）

线性查找的复杂度是 O(n**2)
二分的是 O(log2 n)
快速排序 + 线性扫描的如果使用并行快排，复杂度可能是 O(n)，但是又有点感觉让人站不住脚。

总而言之... 我觉得是不是可能需要使用位运算并查集、离散化查重什么的...

其实这就是一个 set 的 uniq 算法（list to set）
有很多计算机科学家实现过，但是我算法上很浅薄，无从下手

我把所有我学过的算法和数据结构，所有线性表，Array, Linked List, Queue, Deque, Stack, 循环线性表什么的，简单查找二分查找快速查找什么的
Hash map、所有树（Binary Search Tree）、排除 dfs, bfs, dijkstra 算法、动态规划算法、贪婪算法都考虑过了，没找到可能 space O(1) 的同时还能 O(n) 的...

#Telegram #life

也是和 drakeet 之前的事情弄的（

毕竟我也是有点看不太惯现在在 M$ 的离开大学五年然后技术除了熟练度几乎没有任何长进，一直在写简单的逻辑从未有过别的想法的... 呃... 虽然这是有点过分了

我没有居高临下，我和他是平级的