Python 之禅

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea – let’s do more of those!

如何实现

打开 python 编辑器: python3, 直接输入:

1
2
3

import this
print(this.__file__)
>>> /path/to/lib/python3.10/this.py

然后直接在 terminal 输入 cat /path/to/lib/python3.10/this.py, 就会得到 this.py的源码.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#bash cat "/Users/user/anaconda3/lib/python3.10/this.py"
s = """Gur Mra bs Clguba, ol Gvz Crgref

Ornhgvshy vf orggre guna htyl.
Rkcyvpvg vf orggre guna vzcyvpvg.
Fvzcyr vf orggre guna pbzcyrk.
Pbzcyrk vf orggre guna pbzcyvpngrq.
Syng vf orggre guna arfgrq.
Fcnefr vf orggre guna qrafr.
Ernqnovyvgl pbhagf.
Fcrpvny pnfrf nera'g fcrpvny rabhtu gb oernx gur ehyrf.
Nygubhtu cenpgvpnyvgl orngf chevgl.
Reebef fubhyq arire cnff fvyragyl.
Hayrff rkcyvpvgyl fvyraprq.
Va gur snpr bs nzovthvgl, ershfr gur grzcgngvba gb thrff.
Gurer fubhyq or bar-- naq cersrenoyl bayl bar --boivbhf jnl gb qb vg.
Nygubhtu gung jnl znl abg or boivbhf ng svefg hayrff lbh'er Qhgpu.
Abj vf orggre guna arire.
Nygubhtu arire vf bsgra orggre guna *evtug* abj.
Vs gur vzcyrzragngvba vf uneq gb rkcynva, vg'f n onq vqrn.
Vs gur vzcyrzragngvba vf rnfl gb rkcynva, vg znl or n tbbq vqrn.
Anzrfcnprf ner bar ubaxvat terng vqrn -- yrg'f qb zber bs gubfr!"""

d = {}
for c in (65, 97):
    for i in range(26):
        d[chr(i+c)] = chr((i+13) % 26 + c)

print("".join([d.get(c, c) for c in s]))

根据源码可以看到, 其实就是一个文件, 里面存储了这段话, 然后通过一个字典, 将每个字母替换为对应的字母, 最后输出结果. 这个转换使用了 ROT 13. 在 Python3 中, 可以使用 codecs 来实现这个功能. 下面是示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13

import codecs

my_state = (
    "Guvf vf zl phfgbz vzcbeg guvf. Lbh pna hfr vg gb fubj lbhe fgngrzrag sbe "
    "lbhe yvoenel. Nhgube: Murakvnat Wva. Vs lbh yvxr guvf, cyrnfr fgne guvf "
    "ercb.")


def print_my_state():
    print(codecs.decode(my_state, 'rot_13'))


print_my_state()

详细代码可以在 Github 查看.

Linux 用户系统创建/修改新用户时，将修改以下文件:

1. /etc/passwd： 用户账户的详细信息在此文件中更新。
2. /etc/shadow： 用户账户密码在此文件中更新。
3. /etc/group： 新用户群组的详细信息在此文件中更新。
4. /etc/gshadow： 新用户群组密码在此文件中更新。

TL;DR 直接安装 John 然后使用 John 暴力破解

安装 John

1

sudo apt install john

使用 John 暴力破解

1
2
3
4
5
6

# sudo john /etc/shadow
Loaded 4 password hashes with 4 different salts (crypt, generic crypt(3) [?/64])
Warning: OpenMP is disabled; a non-OpenMP build may be faster
Press 'q' or Ctrl-C to abort, almost any other key for status
0g 0:00:00:48 20% 1/3 0g/s 43.65p/s 43.65c/s 43.65C/s Shawn99999/..99999nwahs!
yifan123         (yifan)

查看 passwd 信息

使用命令cat /etc/passwd就可以列出所有的用户信息.

例子

1
2
3
4
5

# 比如:
# cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin

7 个字段的详细信息如下:

• 用户名 （magesh）： 已创建用户的用户名，字符长度 1 个到 12 个字符。
• 密码（x）：代表加密密码保存在 /etc/shadow 文件中。
• 用户 ID（506）：代表用户的 ID 号，每个用户都要有一个唯一的 ID 。UID 号为 0 的是为 root 用户保留的，UID 号 1 到 99 是为系统用户保留的，UID 号 100-999 是为系统账户和群组保留的。
• **群组 ID **（507）：代表群组的 ID 号，每个群组都要有一个唯一的 GID ，保存在 /etc/group 文件中。
• 用户信息（2g Admin - Magesh M）：代表描述字段，可以用来描述用户的信息（LCTT 译注：此处原文疑有误）。
• 家目录（/home/mageshm）：代表用户的家目录。
• Shell（/bin/bash）：代表用户使用的 shell 类型。

查看 shadow 信息

使用命令cat /etc/shadow就可以列出所有的用户信息. 一般其中的信息都是加密的.

例子

1
2
3
4

# cat /etc/shadow
root:$6$Mv12D1VT$maznMnrEBDMmry7A6YhW6lRD2MhdOuPXTQXs9XoIxy1h05B.oOj3hvlw9.9FDs2q/Mcll/I7TX.U.vAY3c0ld1:19585:0:99999:7:::
daemon:*:19213:0:99999:7:::
bin:*:19213:0:99999:7:::

文件中每行代表一个用户，同样使用 “:” 作为分隔符，不同之处在于，每行用户信息被划分为 9 个字段。每个字段的含义如下：

1

用户名：加密密码：最后一次修改时间：最小修改时间间隔：密码有效期：密码需要变更前的警告天数：密码过期后的宽限时间：账号失效时间：保留字段

• 用户名。就是一串代表用户身份的字符串。

• 加密密码。这里保存的是真正加密的密码。所有伪用户的密码都是 “!!” 或 “*”，代表没有密码是不能登录的

• 最后一次修改时间。此字段表示最后一次修改密码的时间

• 最小修改时间间隔。也就是说，该字段规定了从第 3 字段（最后一次修改密码的日期）起，多长时间之内不能修改密码。如果是 0，则密码可以随时修改；如果是 10，则代表密码修改后 10 天之内不能再次修改密码。

• 密码有效期。为了强制要求用户变更密码，这个字段可以指定距离第 3 字段（最后一次更改密码）多长时间内需要再次变更密码，否则该账户密码进行过期阶段。该字段的默认值为 99999，也就是 273 年，可认为是永久生效。如果改为 90，则表示密码被修改 90 天之后必须再次修改，否则该用户即将过期。管理服务器时，通过这个字段强制用户定期修改密码。

• 密码需要变更前的警告天数。与第 5 字段相比较，当账户密码有效期快到时，系统会发出警告信息给此账户，提醒用户 “再过 n 天你的密码就要过期了，请尽快重新设置你的密码！”。该字段的默认值是 7，也就是说，距离密码有效期的第 7 天开始，每次登录系统都会向该账户发出 “修改密码” 的警告信息。

• 密码过期后的宽限天数。也称为“口令失效日”，简单理解就是，在密码过期后，用户如果还是没有修改密码，则在此字段规定的宽限天数内，用户还是可以登录系统的；如果过了宽限天数，系统将不再让此账户登陆，也不会提示账户过期，是完全禁用。

• 账号失效时间。同第 3 个字段一样，使用自 1970 年 1 月 1 日以来的总天数作为账户的失效时间。该字段表示，账号在此字段规定的时间之外，不论你的密码是否过期，都将无法使用！

• 保留。这个字段目前没有使用，等待新功能的加入。

解密 shadow 信息

由于shadow文件加密的密码具有固定格式:

1

$id$salt$encrypted

• id：表示加密算法，1 代表 MD5，5 代表 SHA-256，6 代表 SHA-512。
• salt：表示密码学中的 Salt，由系统随机生成 。
• encrypted：表示密码的 hash。
  冒号后面的数值是一些日期和密码修改间隔天数的信息，可以不用管，以上述示例中 root 账号为例

1

root:$6$Mv12D1VT$maznMnrEBDMmry7A6YhW6lRD2MhdOuPXTQXs9XoIxy1h05B.oOj3hvlw9.9FDs2q/Mcll/I7TX.U.vAY3c0ld1:19585:0:99999:7:::

id=6，即使用SHA-512哈希算法

salt=Mv12D1VT

encrypted=maznMnrEBDMmry7A6YhW6lRD2MhdOuPXTQXs9XoIxy1h05B.oOj3hvlw9.9FDs2q/Mcll/I7TX.U.vAY3c0ld1

我们可以直接使用 john 去破解 shadow 文件：

9种请求方法

HTTP1.0 定义了三种请求方法：

1. GET
2. POST
3. HEAD

HTTP1.1 新增了六种请求方法：

4. OPTIONS
5. PUT
6. PATCH
7. DELETE
8. TRACE
9. CONNECT

因此截止到 HTTP1.1, 一共有 9 种请求方式.

使用场景

建立Websocket

HTTP 协议中的 GET 和 POST 请求都可以作为升级到 WebSocket 连接的起点。在 HTTP 1.1 规范中定义了协议升级机制，允许客户端通过 Upgrade 首部字段发起将连接从 HTTP 更改为另一种协议（如 WebSocket）的请求。

但是用于启动 WebSocket 连接的 HTTP 请求通常是 GET 方法，因为 WebSocket 的目的是建立一个持久的双向通信通道，而 GET 请求更符合这一目的，而且更容易被代理服务器和中间件处理。但理论上 POST 方法也可以用来升级为 WebSocket.

原因是docker使用unix socket进行通讯，但是unix socket属于root用户，但是普通用户需要使用sudo才能开启root权限，但是普通的操作并没有root权限。

Ubuntu:

• sudo usermod -aG docker ${USER}

Mac:

1. cmd-shift-p
2. 点击 "Preferences: Open Workspace Settings"
3. 搜索 “docker path”
4. 输入docker client的绝对路径 (通常在 "/usr/local/bin/docker")

Windows:

同 Mac

Windows WSL:

暂未解决

启用 Go Modules 功能

go env -w GO111MODULE=on

配置 GOPROXY 环境变量，以下三选一

七牛 CDN

号称中国最值得信赖的Go模块代理。

go env -w GOPROXY=https://goproxy.cn,direct

阿里云

go env -w GOPROXY=https://mirrors.aliyun.com/goproxy/,direct

官方

go env -w GOPROXY=https://goproxy.io,direct

确认是否已更新

1
2

>>> go env | grep GOPROXY
>>> GOPROXY="https://goproxy.cn" # 检查输出

什么是 SSTable？

Google 发布的Bigtable论文中解释道：SSTable提供一个可持久化[persistent]，有序的、不可变的从键到值的映射关系，其中键和值都是任意字节长度的字符串。SSTable提供了以下操作：按照某个键来查询关联值，可以指定键的范围，来遍历其中所有的键值对。每个SSTable内部由一系列块(block)组成(通常每块大小为64KB，是可配置的)。使用存储在SSTable结尾的块索引(block index)来定位块；当SSTable打开时，索引会被加载到内存里。一次磁盘寻道(disk seek)就可以完成查询(lookup)操作：首先通过二分查找在存储在内存的索引中找到对应的块，然后从磁盘上读取这块内容。SSTable也可以完整地映射到内存里，这样在执行查询和扫描(scan)的时候就不用操作磁盘了.

SSTable 结构

Scylladb在其官网(What is a SSTable? Definition & FAQs | ScyllaDB)中做出了以下解释：

Sorted Strings Table (SSTable) is a persistent file format used by ScyllaDB, Apache Cassandra, and other NoSQL databases to take the in-memory data stored in memtables, order it for fast access, and store it on disk in a persistent, ordered, immutable set of files. Immutable means SSTables are never modified. They are later merged into new SSTables or deleted as data is updated.

其实除了Scylladb以外，当有很多公司使用SSTable，这些SSTable有些许轻微的不同。这里我们只研究BigTable中的SSTable。

SSTable 有何作用？

01：储存格式

在新数据写入时，这个操作首先提交到日志中作为redo纪录，最近的数据存储在内存的排序缓存memtable中；旧的数据存储在一系列的SSTable 中。在recover中，tablet server从METADATA表中读取metadata，metadata包含了组成Tablet的所有SSTable（纪录了这些SSTable的元 数据信息，如SSTable的位置、StartKey、EndKey等）以及一系列日志中的redo点。Tablet Server读取SSTable的索引到内存，并replay这些redo点之后的更新来重构memtable。在读时，完成格式、授权等检查后，读会同时读取SSTable、memtable（HBase中还包含了BlockCache中的数据）并合并他们的结果，由于SSTable和memtable都是字典序排列，因而合并操作可以很高效完成。

02：压缩（Compaction）过程中的使用

随着memtable大小增加到一个阀值，这个memtable会被冻住而创建一个新的memtable以供使用，而旧的memtable会转换成一个SSTable而写道GFS中，这个过程叫做minor compaction。这个minor compaction可以减少内存使用量，并可以减少日志大小，因为持久化后的数据可以从日志中删除。在minor compaction过程中，可以继续处理读写请求。
每次minor compaction会生成新的SSTable文件，如果SSTable文件数量增加，则会影响读的性能，因而每次读都需要读取所有SSTable文件，然后合并结果，因而对SSTable文件个数需要有上限，并且时不时的需要在后台做merging compaction，这个merging compaction读取一些SSTable文件和memtable的内容，并将他们合并写入一个新的SSTable中。当这个过程完成后，这些源SSTable和memtable就可以被删除了。
如果一个merging compaction是合并所有SSTable到一个SSTable，则这个过程称做major compaction。一次major compaction会将mark成删除的信息、数据删除，而其他两次compaction则会保留这些信息、数据（mark的形式）。Bigtable会时不时的扫描所有的Tablet，并对它们做major compaction。这个major compaction可以将需要删除的数据真正的删除从而节省空间，并保持系统一致性。

SSTable 设计成immutable的优点

1. 在读SSTable是不需要同步。读写同步只需要在memtable中处理，为了减少memtable的读写竞争，Bigtable将memtable的row设计成copy-on-write，从而读写可以同时进行。
2. 永久的移除数据转变为SSTable的Garbage Collect。每个Tablet中的SSTable在METADATA表中有注册，master使用mark-and-sweep算法将SSTable在GC过程中移除。
3. 可以让Tablet Split过程变的高效，我们不需要为每个子Tablet创建新的SSTable，而是可以共享父Tablet的SSTable。

更多

《Bigtable: A Distributed Storage System for Structured Data》
《Bigtable: A Distributed Storage System for Structured Data》论文翻译

图像分割

图像分割：图像分割就是把图像分成若干个特定的、具有独特性质的区域并提出感兴趣目标的技术和过程。 它是由图像处理到图像分析的关键步骤。图形分割是Target Segmentation，是data/image segmentation的一种。任务是把目标对应的部分分割出来。对于一般的光学图像而言，分割像素是一个比较常见的目标，就是要提取哪一些像素是用于表述已知目标的。这种Segmentation可以是一个分类（classificatio）问题，就是把每一个pixel做labeling，提出感兴趣的那一类label的像素。也可以是clustering的问题，即是不知道label，但需要满足一些optimality，比如要cluster之间的correlation最小之类的。（像素级的对前景与背景进行分类，将背景剔除）

图像分割

目标检测

目标检测：目标检测是Target Detection。最早的detection system应该是搞雷达的人首先提出并且heavily study的，最简单的任务就是从看似随机（random）又充满干扰（interference）和噪音（noise）的信号中，抓取到有信息的特征（information-bearing pattern）。最简单的一个栗子，就是当你拿到一段随机的雷达回波，可以设置一个threshold，当高于这个threshold，就认为是探测到了高速大面积飞行器之类的高回波的目标。当然，这里面的threshold该怎么设计，涉及到False Alarm和Miss Detection之间的平衡。人们往往需要寻找最佳的transform或者domain去对信号进行分析。（定位目标，确定目标位置及大小）

图像检测

从输入和输出来比较的话,物体检测的输入和图像分割的输入都是一样的. 一般情况下都是x * y * 3的数组(可以理解为RGB各一层)或者是x * y的 binary image. 物体检测的输出一般都是一个bounding box的列表,而图像分割的输出是一个矩阵, 用来表示mask.

分割和检测融合?

目前也有很多算法将分割和检测进行融合：比如:

• RDSNet: A New Deep Architecture for Reciprocal Object Detection and Instance Segmentation
• Joint 3D Instance Segmentation and Object Detection for Autonomous Driving
• Gated-SCNN: Gated Shape CNNs for Semantic Segmentation
• etc.

通过一个/一种深度学习的结构是很难把这两种不同的任务结合到一起的,以Gated-SCNN: Gated Shape CNNs for Semantic Segmentation为例, 作者认为通过一个深度CNN网络同时处理图像的颜色，形状和纹理信息用于像素级分类可能不是理想的做法，因此该论文提出two-stream CNN结构，将形状信息作为单独处理的分支。两分支包括shape stream和regular stream，二者相互协作且是并行的，通过设计的门控卷积层和局部监督损失有效地移除了噪声并帮助shape stream仅仅处理与边界相关的信息，然后通过ASPP模块保留多尺度上下文信息，融合regular stream的语义区域特征和shape stream的边界特征产生refined的分割输出，尤其refine在边界周围的像素分割。

单括号与双括号的对比

此外, [ ] 是bash 内置命令 而**[[ ]] 是bash 关键词, 双方括号表达式会返回一个退出码**.

==与-eq的对比以及延伸

一般来说, 使用 =或者==来做字符串的对比; 使用-eq来做数值的对比.

使用==来对比字符串

使用 -eq 等命令来对比数值

文件状态检查

块存储的用户是可以读写块设备的软件系统.

文件存储的用户是自然人.

对象储存的用户是其他计算机软件.

Linux系统中所有文件/文件夹都是已文件的格式保存的. 但是为了更容易区分.文件和文件/文件夹不同的命令区分开来列出.

双括号 [[ ]] 对比单括号 [ ] 的优势

1. [[是 bash 程序语言的关键字。并不是一个命令，[[ ]] 结构比[ ]结构更加通用。在[[和]]之间所有的字符都不会发生文件名扩展或者单词分割，但是会发生参数扩展和命令替换。

2. 支持字符串的模式匹配，使用=~操作符时甚至支持shell的正则表达式。字符串比较时可以把右边的作为一个模式，而不仅仅是一个字符串，比如[[ hello == hell? ]]，结果为真。[[ ]] 中匹配字符串或通配符，不需要引号。

3. 使用[[ … ]]条件判断结构，而不是[… ]，能够防止脚本中的许多逻辑错误。比如，&&、||、<和> 操作符能够正常存在于[[ ]]条件判断结构中，但是如果出现在[ ]结构中的话，会报错。

4. bash把双中括号中的表达式看作一个单独的元素，并返回一个退出状态码。

使用[[ … ]]条件判断结构, 而不是[ … ], 能够防止脚本中的许多逻辑错误. 比如,&&, ||, <, 和> 操作符能够正常存在于[[]]条件判断结构中, 但是如果出现在[ ]结构中的话, 会报错. 因此推荐直接选用双括号.

1962 年，美国数学家 David Gale 和 Lloyd Shapley 发明了一种寻找稳定婚姻的策略。不管男女各有多少人，不管他们各自的偏好如何，应用这种策略后总能得到一个稳定的婚姻搭配。换句话说，他们证明了稳定的婚姻搭配总是存在的。

解决算法

先对所有男士进行落选标记，称其为自由男。当存在自由男时，进行以下操作：

1. 每一位自由男在所有尚未拒绝她的女士中选择一位被他排名最优先的女士
2. 每一位女士将正在追求她的自由男与其当前男友进行比较，选择其中排名优先的男士作为其男友，即若自由男优于当前男友，则抛弃前男友；否则保留其男友，拒绝自由男。
3. 若某男士被其女友抛弃，重新变成自由男。

在算法执行期间，自由男们主动出击，依次对最喜欢和次喜欢的女人求爱，一旦被接受，即失去自由身，进入订婚状态；而女人们则采取“守株待兔”和“喜新厌旧”策略，对前来求爱的男士进行选择：若该男子比未婚夫强，则悔婚，选择新的未婚夫；否则拒绝该男子的求婚。被女友抛弃的男人重获自由身，重新拥有了追求女人的权利——当然，新的追求对象比不过前女友。

这样，在算法执行期间，每个人都有可能订婚多次——也有可能一开始就找到了自己的最爱，从一而终——每订一次婚，女人们的选择就会更有利，而男人们的品味则越来越差。只要男女生的数量相等，则经过多轮求婚，订婚，悔婚和再订婚之后，每位男女最终都会找到合适的伴侣——虽然不一定是自己的最爱（男人没能追到自己的最爱，或女人没有等到自己的最爱来追求），但绝对不会出现“虽然彼此相爱，却不能在一起”的悲剧，所有人都会组成稳定的婚姻。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

# Python3 program for stable marriage problem

# Number of Men or Women
N = 4

# This function returns true if
# woman 'w' prefers man 'm1' over man 'm'
def wPrefersM1OverM(prefer, w, m, m1):
    
    # Check if w prefers m over her
    # current engagement m1
    for i in range(N):
        
        # If m1 comes before m in list of w,
        # then w prefers her current engagement,
        # don't do anything
        if (prefer[w][i] == m1):
            return True

        # If m comes before m1 in w's list,
        # then free her current engagement
        # and engage her with m
        if (prefer[w][i] == m):
            return False

# Prints stable matching for N boys and N girls.
# Boys are numbered as 0 to N-1.
# Girls are numbered as N to 2N-1.
def stableMarriage(prefer):
    
    # Stores partner of women. This is our output
    # array that stores passing information.
    # The value of wPartner[i] indicates the partner
    # assigned to woman N+i. Note that the woman numbers
    # between N and 2*N-1. The value -1 indicates
    # that (N+i)'th woman is free
    wPartner = [-1 for i in range(N)]

    # An array to store availability of men.
    # If mFree[i] is false, then man 'i' is free,
    # otherwise engaged.
    mFree = [False for i in range(N)]

    freeCount = N

    # While there are free men
    while (freeCount > 0):
        
        # Pick the first free man (we could pick any)
        m = 0
        while (m < N):
            if (mFree[m] == False):
                break
            m += 1

        # One by one go to all women according to
        # m's preferences. Here m is the picked free man
        i = 0
        while i < N and mFree[m] == False:
            w = prefer[m][i]

            # The woman of preference is free,
            # w and m become partners (Note that
            # the partnership maybe changed later).
            # So we can say they are engaged not married
            if (wPartner[w - N] == -1):
                wPartner[w - N] = m
                mFree[m] = True
                freeCount -= 1

            else:
                
                # If w is not free
                # Find current engagement of w
                m1 = wPartner[w - N]

                # If w prefers m over her current engagement m1,
                # then break the engagement between w and m1 and
                # engage m with w.
                if (wPrefersM1OverM(prefer, w, m, m1) == False):
                    wPartner[w - N] = m
                    mFree[m] = True
                    mFree[m1] = False
            i += 1

            # End of Else
        # End of the for loop that goes
        # to all women in m's list
    # End of main while loop

    # Print solution
    print("Woman ", " Man")
    for i in range(N):
        print(i + N, "\t", wPartner[i])

# Driver Code
prefer = [[7, 5, 6, 4], [5, 4, 6, 7],
        [4, 5, 6, 7], [4, 5, 6, 7],
        [0, 1, 2, 3], [0, 1, 2, 3],
        [0, 1, 2, 3], [0, 1, 2, 3]]

stableMarriage(prefer)

# This code is contributed by Mohit Kumar

数学问题的现实应用价值

现实中的婚姻问题比这个模型要复杂的多, 不过这个模型的思想可以用来在实际社会中的匹配任务. 比如医学生毕业时的工作分配.

如果在文件编辑、修改之后再更新的.gitignore, 那么这个时候Git并不会作用于现在当前文件夹里的文件。因为这个时候Git已经认为这些文件已经是这个Repository的一部分了。这个时候只需要用以下命令来清理缓存然后再重新添加文件就好。

1
2

git rm -rf --cached .   # remove cache
git add .               # add contents to the index