Mar 6

TourDeBabel 不指定

felix021 @ 2019-3-6 11:54 [IT » 其他] 评论(0) , 引用(0) , 阅读(1610) | Via 本站原创
转自：https://code.google.com/archive/p/windows-config/wikis/TourDeBabel.wiki
原文：https://sites.google.com/site/steveyegge2/tour-de-babel

(无意中翻出了很多年前看过的这篇文章，发现是在google code上的，那就转载作为存档吧)

通天塔导游

(译注：圣经记载：在远古的时候，人类都使用一种语言，全世界的人决定一起造一座通天的塔，就是巴别塔，后来被上帝知道了，上帝就让人们使用不同的语言，这个塔就没能造起来。 巴别塔不建自毁，与其说上帝的分化将人类的语言复杂化，不如说是人类自身心灵和谐不再的分崩离析。之所以后来有了翻译，不仅是为了加强人类之间的交流，更寄达了一种愿望，希望能以此消除人际的隔阂，获求来自心灵的和谐及慰藉。真正的译者，把握血脉，抚平创痕，通传天籁，开启心门。)

这是我写的旋风式的编程语言简介—我本来为亚马逊开发者杂志本月的期刊写的，但是发现我写的东西没法…见人。

首先，我偶尔一不小心口出脏话，或者对上帝不恭的话，所以对很官方很正式的亚马逊上发表是不合适的; 所以我就把它塞到我的博客里了，我的博客反正没人看的。除了你以外。是的，只有你会看，你好啊。

其次，这是一项进行中的工程，现在只是东打一耙西搞一下，还没有精加工过的。又一个把它写到博客里的很大的理由。不需要很好，或很完整。就是我今天想说的一些话。请随便！

我的旋风式简介会讲C，C++，Lisp，Java，Perl，(我们在亚马逊用到的所有语言)，Ruby (我就是喜欢)，和Python，把Python加进来是因为—好吧，你看了就知道了，现在我可不说。

C

你必须懂C。为哈? 因为出于所有现实的理由，这个世界上你过去，现在，将来会用到的每一台计算机都是一台冯·诺曼机器，而C是一种轻量级的，很有表达力的语法，能很好的展现冯·诺曼机器的能力。
Feb 25

使用DNSPOD的API实现动态域名 不指定

felix021 @ 2019-2-25 14:47 [IT » 网络] 评论(0) , 引用(0) , 阅读(3445) | Via 本站原创
0. 你得有一个 dnspod 帐号，并且把你的域名（例如 test.com ）解析迁移过去（略）

1. 添加一个子域名的 A 记录，例如 ddns.test.com 指向 127.0.0.1

  $ export domain=test.com
  $ export subdomain=ddns

2. 生成一个token：参考官方说明 https://support.dnspod.cn/Kb/showarticle/tsid/227/

【务必注意】需要用生成的 ID 和 Token 这两个字段来组合成一个完整的 Token，组合方式为："ID,Token"（用英文半角逗号分割），比如官方示例中，完整的 Token 为：13490,6b5976c68aba5b14a0558b77c17c3932 。

  $ export token=13490,6b5976c68aba5b14a0558b77c17c3932

3. 获取必要信息: 域名和子域名的ID

  $ curl -X POST https://dnsapi.cn/Record.List -d "login_token=${token}&format=json&domain=${domain}&sub_domain=${subdomain}"

返回结果为：{"status":{...}, "domain":{"id":640001, "name":"test.com", ...}, "info":{...}, "records":[{"id":"355300007", "name":"ddns", ...}]}

记录下对应域名的id 和子域名的id

  $ export domain_id=640001
  $ export subdomain_id=355300007

4. 获取外网ip

  $ wanip=`nc ns1.dnspod.net 6666`

5. 更新记录

  $ curl https://dnsapi.cn/Record.Ddns -d "login_token=${token}&format=json&domain_id=$domain_id&record_id=$record_id&sub_domain=$sub_domain&record_line=默认&value=$wanip"

= 完 =

（其实没完）其中 1、2、3 做完以后

6. 把 4、5 可以写到一个脚本里

  $ vi dnspod.sh
#!/bin/bash

domain_id=640001
record_id=355300007
sub_domain=ddns

wanip=`nc ns1.dnspod.net 6666`
curl https://dnsapi.cn/Record.Ddns -d "login_token=${token}&format=json&domain_id=$domain_id&record_id=$record_id&sub_domain=$sub_domain&record_line=默认&value=$wanip"


7. 设置 crontab

  $ crontab -e

引用
*/15 * * * * sh /path/to/dnspod.sh


=完=
Jan 29

推荐训练平台 LeetCode（力扣） 不指定

felix021 @ 2019-1-29 16:58 [IT » 程序设计] 评论(0) , 引用(0) , 阅读(2885) | Via 本站原创
TLDR版本：https://leetcode-cn.com/explore/ ，注册一个帐号开始做题就行了。

== 以下是正文 ==

作为一个程序员，编码能力是基础的基础。

我比较幸运，在大学的时候参加了学校的 ACM/ICPC 集训队，接触了 ACM/ICPC 比赛。这是一个针对大学生编程能力的世界级比赛，要求在几个小时的时间里完成若干道不同难度的题目，其中很多题目不仅需要复杂的算法、有各种特殊情况需要考虑，而且还有变态级的效率要求。强如楼教主（楼天城），也仅在 2009 年获得世界总决赛的第二名。

此外，从我观测到的结果来看，但凡从集训队走出去的成员（无论其竞赛成绩如何），**其毕业后的第一份工作（通常都是 BAT ）乃至之后的发展，都显著高于计算机专业的平均水平**。

虽然在集训队里有教练，也有大神，但日常学习主要还是靠自己。看书学习固然是一种方式，但是比较枯燥，也不容易衡量自己的学习成果。另一方面，由于赛事多年的发展和积淀，国内参赛实力较强的大学（例如北大、杭州电子科技大学、华中科技大学）都创建了自己的在线测评系统（英文名叫 Online Judge，简称 OJ）。

OJ 上沉淀了多年来的竞赛题目，每一个题目都包含相应的题面、输入说明、输出要求、基础测试用例；用户按要求编写代码后，将代码提交给 OJ，系统会在后台启动自动化测试，告知测评结果。

由于 OJ 系统的存在，做题变成了一种乐趣，通过努力解决了一个问题，系统会给出红色的 Accepted 字样，就像一种奖赏；而在这个过程中，也可以直接地看到自己的进步。

工作以后，我非常庆幸当年自己在 OJ 系统刷过这些题，夯实了编程能力，在工作中能够完成更高质量的代码。而在过去几年的面试过程中，我发现很多来应聘的程序员，往往只能应对简单的情况，处理不好边界问题、例外情况、运行效率带来的挑战。

遗憾的是，由于学校自建的 OJ 往往都是学生自己开发、自己维护（我也写过一个，维护过几年，深有体会），体验较差，对存量题目的组织、整理也比较随意（往往只是简单的罗列），而且由于比赛是英文环境，题面往往也都是纯英文的，给竞赛圈之外的同学带来了一定门槛。

所幸，近年来，第三方（商业公司、志愿者社区）的 OJ 系统也逐渐完善，其中一个我很喜欢的平台是 LeetCode ，大约成立于 2008 年吧，上面的题多是业内 TOP 公司的面试题，很多人通过刷这些题来应聘喜欢面试算法的 NTMGBA 系列公司（注：Netease，Tencent，Microsoft，Google，Baidu，Alibaba/Amazon）。

相比各个学校维护的 OJ 平台，LeetCode 的体验令人称道：

* 支持多种语言，包括 PHP、Python、Go、Rust、Javascript，甚至还有基于 MySQL 的题目
* 推出了完整的中文版，包括纯中文的题面
* 对题目做了细致的整理，打上各种标签，包括难度（简单、中等、困难）、话题（字符串、堆/栈、贪心算法、动态规划等）
* 通过合集的方式，将题目整理归档（例如腾讯精选50题、初级算法、中级算法等）
* 对于错误的情况，给出明确的错误原因，及相应的输入输出数据，方便自我纠正
* 许多题目有详尽的官方解答，即使不会做也能够直接学习

LeetCode 上的题目大致可以分成两种(参考 CoolShell 博客说明)：

1. 算法题。大多是套路题，每道题目都需要特定的算法，例如BFS、DFS、动态规划、回溯等。通过做这些题，能够让自己对这些最基础的算法的思路有非常扎实的了解和训练，也能很好地锻炼自己的思维能力（烧脑）。

2. 编程题。比如：atoi，strstr，add two num，括号匹配，字符串乘法，通配符匹配，文件路径简化，Text Justification，反转单词等等。这些题目的题面都很简单，大部分程序员都能读懂，但是魔鬼藏在细节中，具体的实现往往需要考虑多种情况。通过做这些题，可以非常好的训练自己对各种情况的考虑，以及对程序代码组织的掌控能力（其实就是其中的状态变量）。程序中的状态正是程序变得复杂难维护的直接原因。

每个程序员内心都有一个大神梦，但是别忘了，大神也是从菜鸟一步一个脚印走过来的，而 LeetCode 就是一个很好的垫脚石，共勉。
Jan 7

Excel单元格高度调整+10 不指定

felix021 @ 2019-1-7 00:22 [IT » 软件] 评论(0) , 引用(0) , 阅读(2329) | Via 本站原创
使用Excel的过程中经常需要调整行的高度，由于各行的高度不同，统一设定高度往往不适用，而手动逐行调整比较麻烦。有一个常见的小技巧是先按Ctrl+A全选，然后再双击左侧数字标题栏的任意分割线，Excel会自动调整行高。

但是对于精神处女座的我来说，行与行之间没有间隔，所有字密密麻麻挤在一起有点受不了；但是excel又不像css里面可以一句话统一给单元格设置padding或margin（就没有这个属性）。

所幸还有很多其他精神处女座的同学，他们给出的方案 是用宏：

Sub AutoFitPlus()
  Dim rng As Range
  rowCount = 0
  Selection.EntireRow.AutoFit
  For Each rng In Selection.Rows
    rng.RowHeight = rng.RowHeight + 10
    rowCount = rowCount + 1
    If rowCount > 100 Then Break
  Next rng
End Sub


将这段代码保存为一个宏（可以设置一个快捷键，例如 Ctrl + Shift + L），选中某些行，再执行这个宏，就解决问题了。

Nov 23

浏览器客户端证书 不指定

felix021 @ 2018-11-23 23:06 [IT » 其他] 评论(0) , 引用(0) , 阅读(2014) | Via 本站原创
2015年，从某传统金融国企跳槽来到我司的时候，发现后台管理系统竟然需要安装客户端证书才能登陆，简直惊为天人，通过利用 https 的客户端认证，配合证书中嵌入的用户名做权限控制，把内部系统的入侵难度至少增加了一个量级（当然，安装证书的过程对于非技术线的同学说也麻烦了不少）。

后来发现，原来是把 github.com/OpenVPN/easy-rsa 这个项目包装了一下实现的，其实也并不是很困难。

今年年初因为新项目也需要这个方案，自己心血来潮，参考网上的一些说明，用 openssl 的 genrsa、req、x509、pkcs12 这几个命令试着自己颁发客户端证书，并且包装了一套脚本，勉强能用。

但当时没有太多时间，吊销的功能并没有做，因为比颁发证书麻烦多了，不只是敲几个命令，还需要一套更复杂的方案，包括维护一个证书信息列表、按一定规范的文件目录结构，以及DIY的 openssh 配置文件等。

最近抽了两个晚上把整个流程重新梳理了一遍，填了几个坑，终于做了一套完整的脚本出来，这才好意思写这篇博客介绍一下。

这套脚本可以在这里获取：

  https://github.com/felix021/openssl-selfsign

使用起来可以说是非常简单了：

1. 创建CA

  $ ./1-sign-site.sh dev.com

会创建 ca 证书，并在 cert/site/dev.com/ 下面创建 *.dev.com 的 https 证书，并且生成一个 nginx.conf 配置文件供参考（直接可以用的）。

2. 颁发客户端证书

  $ ./2-sign-user.sh test1

在 cert/newcerts/test1-01/ 下面创建 test1 用户的一个客户端证书 cert.p12 ，并给出对应的密码，双击按提示导入即可。

3. 参考第一步生成的 nginx.conf 配置文件，配置好 web 服务器，就行了。

4. 稳妥起见，应当在代码中读取 http 头里的 SSL_DN 参数，从中获取邮箱或者用户名来作为系统的用户名。

至于吊销的过程，要更复杂一些，可以参考该项目的 README 。
Nov 6

vim：新打开文件，第一个字符是p（或者g？） 不指定

felix021 @ 2018-11-6 00:51 [IT » shell] 评论(0) , 引用(0) , 阅读(2942) | Via 本站原创
改 vimrc 没什么卵用，搜了一下，说是因为终端的兼容问题，只要在 ~/.bashrc 里面加上  "export TERM=linux" 就好。

refer: https://stackoverflow.com/questions/31783160/why-vim-is-changing-first-letter-to-g-after-opening-a-file
Sep 19

跳表 - 简明教程 in Python 不指定

felix021 @ 2018-9-19 05:30 [IT » 程序设计] 评论(0) , 引用(0) , 阅读(3894) | Via 本站原创
# 1. 什么是跳表

跳表（Skip List）是基于链表 + 随机化实现的一个有序数据结构，可以达到平均 O(logN) 的查找、插入、删除效率，在实际运行中的效率往往超过 AVL 等平衡二叉树，而且其实现相对更简单、内存消耗更低。

Redis 的 ZSET 底层实现就是用的 Skip List，这里是 [Antirez对此的说明](https://news.ycombinator.com/item?id=1171423)。

这是一个典型的跳表：

[0] -> 0 -> 1 -> 3 -> 4 -> 5 -> 6 -> 7 -> 9 -> nil
[1] -> 0 ------> 3 ------> 5 ------> 7 ------> nil
[2]----------------------> 5-----------------> nil


解释一下：

1. SkipList 是一个多层的链表

2. 第[0]层的链表包含所有节点，其他层的链表包含部分节点，层次越高，节点越少

3. 每层链表之间会共享相同的节点（节省内存，但为了方便展示，每一层都输出了它的值）

4. 对于某个节点，在插入时通过概率判断它最高会出现在哪一层，并且也会出现在之下的每一层

通过这样的设计，当需要查找某个 key 时，可以从最高层的链表开始往前找，在这一层遇到末尾或者大于 key 的节点时往下走一个层，直到找到 key 节点。

例如:

引用
4 的查找路径为 [2] -> [1] -> 0 -> 3 -> 3@[0] -> 4
6 的查找路径为 [2] -> 5 -> 5@[1] -> 5@[0] -> 6
8 的查找路径为 [2] -> 5 -> 5@[1] -> 7 -> 7@[0] -> 9 （找不到）


# 2. 跳表的节点

从上面的描述，我们大概可以知道 (1) 每个节点需要保存一个 key; (2) 每个节点需要有多个next指针 (3) 其 next 指针的数量会在插入时确定

因此我们可以用下面这个 class 来表示节点:

class Node(object)
    def __init__(self, height, key):
        self.key = key
        self.next = [None] * height

    def height(self):
        return len(self.next)


# 3. 创建跳表

一个新创建的跳表是没有节点的。但为了实现的简单起见，可以添加一个头节点：

class SkipList(object):
    def __init__(self):
        self.head = Node(0, None) #头节点高度为0，不需要key


到目前为止都特别简单，但是还什么也干不了。

# 4. 创建节点

创建节点时，需要先按一定的概率分布确定其高度。

为了保证高层的节点比低层少，我们可以用这样的概率分布：

引用
Height(n) = p^n


实现其实非常简单：

import random

def randomHeight(self, p = 0.5):
    height = 1
    while random.uniform(0, 1) < p and self.head.height() >= height:
        height += 1
    return height


这样可以保证平均的路径长度是 log(n) 。

精确一点的话，实际上是 log(n-1, 1/p) / p，也就是说， p 的选择会影响跳表层数、平均路径长度。

具体的计算比较复杂，有兴趣可以参考跳表的原论文《Skip Lists: A Probabilistic Alternative to Balanced Trees》。（TL;DR）

然后我们就可以这样来创建一个新的节点：

    node = Node(self.randomHeight(), key)

# 5. 添加节点

如果只是为空跳表添加一个新的节点，只要更新头结点的每一个next指针：

def insertFirstNode(self, key):
    node = Node(self.randomHeight(), key)
    while node.height > self.head.height():
        self.head.next.append(None) #保证头节点的next数组覆盖所有层次的链表

    for level in range(node.height()):
        node.next[level] = self.head.next[level]
        self.head.next[level] = node


但很显然这个方法只能用一次。

如果跳表中已经有多个节点，那我们就必须找到每一层中适合插入的位置：

def getUpdateList(self, key):
    update = [None] * self.head.height()
    for level in range(len(update)):
        x = self.head
        while x.next[level] is not None and x.next[level].key < key:
            x = x.next[level]
        update[level] = x
    return update


这个函数返回一个 update 节点数组，其中的每个节点都是在这一层中小于 key 的最后一个节点。

也就是说，在 level = i 层，总是可以把新的节点插入 update[i] 之后：

def insert(self, key):
    node = Node(self.randomHeight(), key)
    while node.height > self.head.height():
        self.head.next.append(None) #保证头节点的next数组覆盖所有层次的链表

    update = self.getUpdateList(key)
    next0 = update[0].next[0]
    if next0 is not None and next0.key == key:
        return # 0层总是包含所有元素；如果 update[0] 的下一个节点与key相等，则无需插入。

    for level in range(node.height()):
        node.next[level] = update[level].next[level]
        update[level].next[level] = node


但是由于这一版 getUpdateList 是 O(n) 的，插入效率并没有达到跳表的设计目标。

# 6. 添加节点++

考虑这一点：跳表的每一层都是有序的。

也就是说，我们在找到 update[n] = x 以后，其实可以从节点 x 的 n - 1 层继续查找 update[n-1] 应该是哪个节点。

由于查找路径的平均长度是 log(N) ，所以我们可以实现一个更快的 getUpdateList 方法

注意，需要从最高层开始查

def getUpdateList(self, key):
    update = [None] * self.head.height()
    x = self.head
    for level in reversed(range(len(update))):
        while x.next[level] is not None and x.next[level].key < key:
            x = x.next[level]
        update[level] = x
    return update


# 7. 里程碑1

把上面的代码整合起来，我们就可以得到第一版跳表代码：能够插入节点。

为了更好地展示我们的成果，我们可以用这样一个函数，把链表按第1节的例子样式输出：

def dump(self):
    for i in range(self.head.height()):
        sys.stdout.write('[H]')
        x = self.head.next[0]
        y = self.head.next[i]
        while x is not None:
            s = ' -> %s' % x.key
            if x is y:
                y = y.next[i]
            else:
                s = '-' * len(s)
            x = x.next[0]
            sys.stdout.write(s)
        print ' -> <nil>'
    print


试试看：

sl = SkipList()
for i in range(10):
    sl.insert(sl)
    s1.dump()



[H] -> 0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> <nil>
[H]----- -> 1 -> 2 -> 3---------- -> 6 -> 7---------- -> <nil>
[H]---------- -> 2-------------------- -> 7---------- -> <nil>


多尝试几次，以及选择不同的 p 值，可以观察生成跳表的区别。

# 8. 查找节点

实际上查找节点的过程，已经包含在 insert 的实现里了：

def find(self, key):
    update = self.getUpdateList(key)
    if len(update) == 0:
        return None

    next0 = update[0].next[0]
    if next0 is not None and next0.key == key:
        return next0 # 0层总是包含所有元素；如果 update[0] 的下一个节点与key相等，则无需插入。
    else:
        return None


# 9. 删除节点

既然已经能找出 update 节点数组，在 level = i 层，只要判断 update[i].next[i] 是否等于要删除的 key 就可以了：

def remove(self, key):
    update = self.getUpdateList(key)
    for i, node in enumerate(update):
        if node.next[i] is not None and node.next[i].key == key:
            node.next[i] = node.next[i].next[i]


# 10. 里程碑2

整合 find 和 update 数组，就可以实现跳表的基础操作了，试试看：

node = sl.find(3)
print node

for i in range(7, 14):
    sl.remove(i)
    sl.dump()


# 11. 其他

我们在 Node 中只添加了一个 key 属性，在具体的实现中，我们往往可能需要针对 key 存储一个 value，例如 Python 自带的 dict 实现。改造起来也很简单:

1. node 中添加一个 value 属性，并且添加相应的初始化逻辑(__init__方法)

2. 将 SkipList.insert 修改为 `insert(self, key, value)`，在新建 Node 时指定其 value

3. 再添加一个 `update(self, key, value)` API，方便调用方的使用

4. 可以考虑针对语言适配，例如实现 python 的 __getitem__ 、 __setitem__ 等魔术方法


# 12. 完整代码

#coding:utf-8

import random

class Node(object):
    def __init__(self, height, key=None):
        self.key = key
        self.next = [None] * height

    def height(self):
        return len(self.next)

class SkipList(object):
    def __init__(self):
        self.head = Node(0, None) #头节点高度为0，不需要key

    def randomHeight(self, p = 0.5):
        height = 1
        while random.uniform(0, 1) < p and self.head.height() >= height:
            height += 1
        return height

    def insert(self, key):
        node = Node(self.randomHeight(), key)
        print node.height(), node.key
        while node.height() > self.head.height():
            self.head.next.append(None) #保证头节点的next数组覆盖所有层次的链表

        update = self.getUpdateList(key)
        if update[0].next[0] is not None and update[0].next[0].key == key:
            return # 0层总是包含所有元素；如果 update[0] 的下一个节点与key相等，则无需插入。

        for level in range(node.height()):
            node.next[level] = update[level].next[level]
            update[level].next[level] = node


    def getUpdateList(self, key):
        update = [None] * self.head.height()
        x = self.head
        for level in reversed(range(len(update))):
            while x.next[level] is not None and x.next[level].key < key:
                x = x.next[level]
            update[level] = x
        return update

    def dump(self):
        for i in range(self.head.height()):
            sys.stdout.write('[H]')
            x = self.head.next[0]
            y = self.head.next[i]
            while x is not None:
                s = ' -> %s' % x.key
                if x is y:
                    y = y.next[i]
                else:
                    s = '-' * len(s)
                x = x.next[0]
                sys.stdout.write(s)
            print ' -> <nil>'
        print

    def find(self, key):
        update = self.getUpdateList(key)
        if len(update) == 0:
            return None

        next0 = update[0].next[0]
        if next0 is not None and next0.key == key:
            return next0 # 0层总是包含所有元素；如果 update[0] 的下一个节点与key相等，则无需插入。
        else:
            return None

    def remove(self, key):
        update = self.getUpdateList(key)
        for i, node in enumerate(update):
            if node.next[i] is not None and node.next[i].key == key:
                node.next[i] = node.next[i].next[i]


完。
Sep 6

蠢货Excel之 - 批量应用日期格式 不指定

felix021 @ 2018-9-6 13:31 [IT » 软件] 评论(0) , 引用(0) , 阅读(2300) | Via 本站原创
excel很强大，但也有非常蠢的地方：比如今天遇到的，导出文档的日期列是“文本”格式，这时候用数据透视表，excel不能识别这是日期，于是无法根据月或者年对数据进行聚合。

即使选中整列，然后将格式全都修改为日期也不行。

即使再弄一列格式为日期的，然后用黏贴数值也不行。

按照过去的经验，只有逐个格子双击，然后回车，才能把格式应用到数据上，真是蠢到爆炸。

今天觉得实在不能忍了，放狗搜了下“excel apply format instead of double click on each column”，总算找到一个解决方案：

1. 选中该列

2. 在“数据”Tab里点击“分列”（按格式将单列文本拆分成多列，英文版是 Text To Columns）

3. 点击完成

搞定
分页： 7/103 第一页 上页 2 3 4 5 6 7 8 9 10 11 下页 最后页 [ 显示模式： 摘要 | 列表 ]