>>> mapLongInputBy(huoxin)

def siηgιeCharDict(pairs: str):
  assert ιeη(pairs) % 2 == 0, "μηpaired"
  κs, vs = map(ιambda i0: [pairs[i] fσr i iη raηge(i0, ιeη(pairs), 2)], [0, 1])
  retυrη dict(zip(κs, vs))

greeκSimiιar = siηgιeCharDict("ιιγγηηκκχχωω"+"ΡΡΓΤΥΥΙΙΗΗΓΓΖΖΧΧΒΒΝΝΜΜ")
greeκSimiιar.μpdate({'σ': "οθσ", 'μ': "υμ", 'Σ': "ΕΣΞ", 'Ω': "ΘΟΩ", 'Δ': "ΑΔΛ"}) 

frοm raηdοm impοrt chοice 
def ιet(σp, χ): retυrη οp(χ) if χ != Νοηe eιse Νθηe

def hυσχiη(teχt):
  chars = [ ιet(chθice, greeκSimiιar.get(c)) σr c fοr c iη teχt ]
  retυrη "".jθiη(chars)

>>> mapLongInputBy(huoxinBack)

def singleCharDict(pairs: str):
  assert len(pairs) % 2 == 0, "unpaired"
  ks, vs = map(lambda i0: [pairs[i] for i in range(i0, len(pairs), 2)], [0, 1])
  return dict(zip(ks, vs))

greekSimilar = singleCharDict("llyynnkkxxww"+"PPTΤYYIIHHTTZZXXBBNNMM")
greekSimilar.update({'o': "ooo", 'u': "uu", 'E': "EEE", 'O': "OOO", 'A': "AAA"}) 

from random import choice 
def let(op, x): return op(x) if x != None else None

def huoxin(text):
  chars = [ let(choice, greekSimilar.get(c)) or c for c in text ]
  return "".join(chars)

"自举"了（开个玩笑，定义不正确） 😂 #Python #Haha #tools

https://github.com/itorr/nbnhhsh/pull/4#issuecomment-602673719 #JavaScript #project #web #Github

又更新了一下

#web #security #Python 😂

太艹了，居然这都不会写…… 🤪
def combinations(items: set):
return [[item] + combinations(items - set([item])) for item in items]
[[1, [2, [3]], [3, [2]]], [2, [1, [3]], [3, [1]]], [3, [1, [2]], [2, [1]]]] 也不对…… a*b 吗……
def combinations(xs):
return [ [x]+combinations(xs[1:]) for x in xs ] if len(xs) != 0 else []
还是不对…… 其实这个是要 flatMap 的

from itertools import chain

def flatMap(f, xs):
return f(xs[0]) if len(xs) == 1 else chain(f(xs[0]), flatMap(f, xs[1:]))

list(flatMap(lambda c: [c, c.upper()], "abc")) == ['a', 'A', 'b', 'B', 'c', 'C']
好了，我终于记起来最开始是咋组织的程序了……
啊……不对，我想起来了，之前处理的数据结构是 [a, [b1, b2], [c1, c2]] …… 这次的有点区别，不过实际上可以一样处理

def combinations(xs);
return flatMap(lambda x0: [x0+], xs)

def subtractSet(set, item):
newSet = set.copy(); newSet.remove(item)
return newSet

def flatMap(f, xs: iter):
try: return chain(f(next(xs)), flatMap(f, xs))
except StopIteration: return []
list(flatMap(lambda a: [a,a+1], iter([1,2,3]))) == [1, 2, 2, 3, 3, 4]

def combinations(items: set):
return flatMap(lambda item: [item, combinations( subtractSet(items, item) )], items)

……我真是服了，list set 都不是 iter、iter 又没有 copy，算了就此为止吧

今天早上起来我又想到了一种方法，好像解决问题了，给大家讲一下。

解：问A「如果我问B，他会说你的是真话，异或(logical xor) 左边的路是生路」
若真，左边的路是死路；否则右边的路是死路。

“他会说你的是真话” 和 “他会说你的是假话” 都一样，结果也无二 （不，应该是正好相反），我不讲这个了。

基本思路就两个：
1. 两个人，一个真话一个假话；任何的 logical negation 和反套命题到另一边都是没有意义的，做不到区分
我不知道这和 (&&) (||) (!) 以及 (=) 有什么关系，但看起来没法直接靠单层提问分出真假

比如，问「你是诚实的？」， map(A(it) neg B(it), cases)，事实上没法挑出撒谎的人，问「你说的是谎话？」也一样。

除非断言某个条件是真的，但这需要以第一个子问题是假的为代价提问

variable A, B : Predicate
variable way : Bool
given {
  A(p) => not B(p)
  B(p) => not A(p) //至少有一个是“真话”
}

然后思考一下怎么让 A 变成 truth(p), B 变成 falsely(p) 🤔
“如果我问另一人，他会说你的是真话”
A(B(way))
A(not B(way)) 不对，我的表达思路有点问题…… 算了不设计符号表达方式了，太菜

如果你问诚实者，“撒谎者会说你在说谎”，肯定
如果你问撒谎者，“诚实者会说你在说谎”，否定 🤔（WIP：错的？那好像依然不可判定啊……）（不对，撒谎者会把诚实者的断言再 negate 一遍，所以逻辑正确）
关于这个“撒谎”与否的问题，可以在保证两者定义（一个断言恒成立、一个断言恒为假）的同时，达到区分二者的目的
仅仅问关于 way 的断言，是不行的。

2. 等我们知道了谁是诚实的人，再利用子问题同时把关于路的判断“编码”进第一个提问，取回来
当然我们问的问题只能是「是否问题」，所以信息量比较有限，我们来看看：

需要注意的是，这里的等号 (=) 是一个双向关系(commutative relation)，你可以从左边推到右边，也可以倒着推回来。
（或者说，下面等号的语义实际是数学上的 <=> ）

有 p (这是谎话)、q (左边的路是生路)，

logical and:
T && T = T
T && F = F
F && T = F
F && F = F

若答案为F，无法分辨出 q=F 时是不是真话。
(T && F) 真相是 (neg way)，与 (F && F) 的真相 (way) 在确定上是冲突的

logical or:
T && T = T
T && F = T
F && T = T
F && F = F

若答案为T，结论同上无法分辨。
(T && T) ; (neg way) 和 (F && T) ; (way) 是冲突的

logical not:
!T = F
!F = T

刚才咱已经说了，不可能仅靠一元关系解决

logical xor:
T ^ T = F
T ^ F = T
F ^ T = T
F ^ F = F

这个就比较有意思了，因为最后的结论不会冲突，我们来看看。

F = 假话&生路 | 真话&死路

T 的情况是重点，因为它看起来像和 and/or 的情况差不多，但 T/F 和 F/T 实际上是一样的！
T = 假话&死路 | 真话&生路

所以得到否定答案可以确定那不是生路，肯定答案可以确定那是生路！

这个文，感觉什么「肯定」「断言」「确定」「消极」「T/F」用得比较没规范…… 请海涵。

这个答案感觉应该也是对的，所以这个问题实际上很简单

关于生路在左边“是真的”，
B撒谎、A诚实，生路在右边
B诚实、A撒谎，生路在右边

所以“串联”在表述上是对的，只不过后面的文字看起来不太严谨
……不对啊

关于生路在右边“是真的”，
B撒谎、A诚实，生路在左边
B诚实、A撒谎，生路在左边

依然没法区分啊！不对…… 可以区分 🙈

def honest(p: bool): return p
def cheat(p: bool): return not p

def wayProblem(is_right: bool, a=honest, b=cheat):
return (a(is_right), b(is_right))

bools = [True, False]
[wayProblem(p) for p in bools] == [(True, False), (False, True)]
def compose(f, g): return lambda x: f(g(x))
[wayProblem(p, a=compose(honest, cheat), b=compose(cheat, honest)) for p in bools] == [(False, False), (True, True)]
🤔 这算是区分开了？……！ 要不然你想怎么区分

秒打脸 气死我了 #Learn #Python #logics #Algorithm
太丢人了

#life 建议从电脑桌上下来休息的人 采取下蹲 / 把小腿压在不太高的桌子上 的方式 舒展身体
个人感觉效果还可以，从别人分享的 PDF 上看到的。

https://www.barretlee.com/blog/2019/12/17/the-value-of-expression/ #dev #tech

作者: Barret李靖 2019-12-17 13:25:00 本文发布时间为2019年12月17日13时25分00秒 分类: 随笔 标签: 领英行家 下面是正文内容 评论数: 0 热度: 280

领英中国近期推出了一个年度行家的榜单，关注我的朋友可能知道，我有幸入了榜。
领英对行家的定义是，在自己的领域中，根据自身经验和知识，为他人答疑解惑，分享行业洞察，提供经验干货。简单来说，所谓的行家，就是善于思考，乐于发声的人。

http://mouto.org/ #blog #frontend #dalao

#ParserKt 关于这个可选的 LayoutPattern，也的确是一个保留问题 🤔
不过现在可以设计一个关系式求解器了？

最后评论区提到 Vol. 75 把『hash function』说成是『加密函数』，而不是一般的准确度底线：散列，有点牛逼了