## Kiwix

维基百科是非常实用的知识搜索引擎。然而受制于国内的网络环境，在访问维基百科时往往会受到某些限制，这对于希望使用维基这一巨大知识库的人来说是非常不爽的。

为了解决这个问题，可以使用这款用于离线化维基百科的浏览工具：Kiwix。

## 下载地址

Kiwix：[https://kiwix.org/en/](https://kiwix.org/en/)


Kiwix-离线版维基百科

## 集合存储原理

data = set() data.add('a') print(data)  # {'a'}

- 利用哈希函数将“a”转换成一个数值，例如：1280120246861766981
- 取余数：1280120246861766981 % 6 = 3
- 将“a”放在哈希表的索引3位置

## 添加删除元素

data = {"a", "b"} data.add("c") print(data)  # {'a', 'b', 'c'}

data.update(["d", "e"])  # 添加多个元素
print(data)  # {'a', 'e', 'c', 'd', 'b'}

data.remove("c")  # 删除元素，如果元素不存在，会引发 KeyError
print(data)  # {'a', 'e', 'd', 'b'}

data.discard("f")  # 安全地删除元素，不会引发异常
print(data)  # {'a', 'e', 'd', 'b'}

## 交并差

v1 = {"a", "b", "c"} v2 = {"w", "b", "d"}

res = v1 & v2  # 交集 或 v1.intersection(v2)
res2 = v1 | v2  # 并集 或 v1.union(v2)
res3 = v1 - v2  # 差集 或 v1.difference(v2)
res4 = v1 ^ v2  # 对称差集 即 交集-并集 或 v1.symmetric_difference(v2)

print(res)  # {'b'}
print(res2)  # {'a', 'b', 'c', 'd', 'w'}
print(res3)  # {'a', 'c'}
print(res4)  # {'a', 'c', 'd', 'w'}

## isdisjoint

判断两个集合是否包含相同的元素，如果没有返回true，否则返回false。 data = {"a", "b", "c"} data2 = {"w", "b", "d"} result = data.isdisjoint(data2) print(result) # False


Python集合

## Mimo

使用Mimo按照自己的节奏进行编码学习。提供Python、JavaScript、HTML、CSS等初学者友好的课程。参与互动练习、真实世界的项目，并获得可共享的证书。加入Mimo社区，立即开始您的编码之旅！

这个轻量的编程学习网站，团队来自各个国家，非常年轻和有活力，课程编写也很生动～

🔸从产品体验来看，Mimo团队非常关注用户的学习卡点，会针对每一步学习过程中可能出现的问题，提前做好铺垫和解答；帮助小白无痛入门，而不是一边学一边堆满问号。

🔹一行代码里如果出现多个知识点，Mimo会细致地分拆步骤，每一步都只关注一个重点，这样既不容易因为出错而沮丧，也不会漏掉任何一个入门阶段的细微但重要的知识点。

🔸最近新上线了社区板块，技术大大和小白在版块里交流心得。对于编程初学者来说，开始容易放弃更容易，这些有意义的交流应该是可以给到小白们很大的信心，克服心理上的畏惧和找到正确的方法，相信一定会有坚持和突破哒。

🔹编程和语言一样是一个在应用中不断进步的工具，所以大大们也特别提到要多练习，亲自上手写代码比匆匆往前赶课程进度更重要！各位加油！

## 网站地址

Mimo：[https://mimo.org/](https://mimo.org/)


Mimo-教小白无痛编程入门

## 冒泡排序

在所有排序算法中最简单，然而，从运行时间的角度看，冒泡排序是最差的一个。

    function swap(array, a, b) {
      const temp = array[a]
      array[a] = array[b]
      array[b] = temp
    }
    function bubbleSort(array) {
    const { length } = array
    for (let i = 0; i < length; i++) {
    for (let j = 0; j < length - 1 - i; j++) {
    if (array[j] > array[j + 1]) {
    swap(array, j, j + 1)
    }
    }
    }
    console.log(array)
    }
    bubbleSort([1, 3, 5, 2, 0])

## 选择排序

一种原址比较排序算法。选择排序大致思路是找到数据结构中的最小值并将其放置在第一位，接着找到第二小的值并将其放在第二位，以此类推。

    function selectionSort(arr) {
    const { length } = arr
    let indexMin
    for (let i = 0; i < length - 1; i++) {
    indexMin = i
    for (let j = i; j < length; j++) {
    if (arr[indexMin] > arr[j]) {
    indexMin = j
    }
    }
    if (i !== indexMin) {
    swap(arr, i, indexMin)
    }
    }
    console.log(arr)
    }
    selectionSort([1, 3, 5, 2, 0])

## 插入排序

    function insertionSort(array) {
    const { length } = array
    let temp
    for (let i = 1; i < length; i++) {
    let j = i
    temp = array[i]
    while (j > 0 && array[j - 1] > temp) {
    array[j] = array[j - 1]
    j--
    }
    array[j] = temp
    }
    console.log(array)
    }
    insertionSort([1, 3, 5, 2, 0])

## 归并排序

第一个可以实际使用的排序算法。前三个排序算法性能不好，但归并排序性能不错，其复杂度为O(nlog(n))。

归并排序是一种分而治之算法。其思想是将原始数组切分成较小的数组，直到每个小数组只有一个位置，接着将小数组归并成较大的数组，直到最后只有一个排序完毕的大数组。

    function mergeSort(array) {
    if (array.length > 1) {
    const { length } = array
    const middle = Math.floor(length / 2)
    const left = mergeSort(array.slice(0, middle))
    const right = mergeSort(array.slice(middle, length))
    array = merge(left, right)
    }
    return array
    }
    function merge(left, right) {
    let i = 0
    let j = 0
    const result = []
    while (i < left.length && j < right.length) {
    result.push(left[i] < right[j] ? left[i++] : right[j++])
    }
    return result.concat(i < left.length ? left.slice(i) : right.slice(j))
    }
    console.log(mergeSort([1, 3, 5, 2, 0]))

## 快速排序

也许是最常用的排序算法了。它的复杂度为O(nlog(n))，且性能通常比其他复杂度为O(nlog(n))的排序算法要好。和归并排序一样，快速排序也使用分而治之的方法，将原始数组分为较小的数组（但它没有像归并排序那样将它们分割开）。

    function quickSort(arr) {
    const { length } = arr
    if (length < 2) {
    return arr
    }
    let base = arr[0]
    let minArr = arr.slice(1).filter((item) => item <= base)
    let maxArr = arr.slice(1).filter((item) => item > base)
    return quickSort(minArr).concat(base).concat(quickSort(maxArr))
    }
    console.log(quickSort([1, 3, 5, 2, 0]))

## 计数排序

是分布式排序。

    function countSort(arr) {
    if (arr.length < 2) {
    return arr
    }
    const maxValue = findMax(arr)
    const counts = new Array(maxValue + 1)
    arr.forEach((item) => {
    if (!counts[item]) {
    counts[item] = 0
    }
    counts[item]++
    })
    let sortIndex = 0
    counts.forEach((count, index) => {
    while (count > 0) {
    arr[sortIndex++] = index
    count--
    }
    })
    return arr
    }
    function findMax(arr) {
    let max = arr[0]
    for (let i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
    max = arr[i]
    }
    }
    return max
    }
    console.log(countSort([1, 3, 5, 2, 0]))

## 桶排序

也被称为箱排序，是分布式排序算法。它将元素分为不同的桶（较小的数组），再使用一个简单的排序算法，例如插入排序（用来排序小数组不错的算法），来对每个桶进行排序。然后，它将所有的桶合并为结果数组。

    function bucketSort(array, bucketSize = 3) {
    if (array.length < 2) {
    return array
    }
    const buckets = createBucket(array, bucketSize)
    return sortBucket(buckets)
    }
    function createBucket(array, bucketSize) {
    let minValue = array[0]
    let maxValue = array[0]
    for (let i = 1; i < array.length; i++) {
    if (array[i] < minValue) {
    minValue = array[i]
    } else if (array[i] > maxValue) {
    maxValue = array[i]
    }
    }
    const bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1
    const buckets = []
    for (let i = 0; i < bucketCount; i++) {
    buckets[i] = []
    }
    for (let i = 0; i < array.length; i++) {
    const bucketIndex = Math.floor((array[i] - minValue) / bucketSize)
    buckets[bucketIndex].push(array[i])
    }
    return buckets
    }
    function sortBucket(buckets) {
    const sortedArray = []
    for (let i = 0; i < buckets.length; i++) {
    if (buckets[i] != null) {
    insertionSort(buckets[i])
    sortedArray.push(...buckets[i])
    }
    }
    return sortedArray
    }
    function insertionSort(array) {
    const { length } = array
    let temp
    for (let i = 1; i < length; i++) {
    let j = i
    temp = array[i]
    while (j > 0 && array[j - 1] > temp) {
    array[j] = array[j - 1]
    j--
    }
    array[j] = temp
    }
    }
    console.log(bucketSort([1, 3, 5, 2, 0]))

## 基数排序

也是一个分布式排序算法，它根据数字的有效位或基数（这也是它为什么叫基数排序）将整数分布到桶中。基数是基于数组中值的记数制的。

    function radixSort(arr) {
    const base = 10
    let divider = 1
    const maxValue = Math.max(...arr)
    while (divider <= maxValue) {
    const buckets = [...Array(10)].map(() => [])
    for (let i of arr) {
    buckets[Math.floor(i / divider) % base].push(i)
    }
    arr = [].concat(...buckets)
    divider *= base
    
    }
    return arr
    }
    console.log(radixSort([1, 3, 5, 2, 0]))


JavaScript数据结构与算法(排序算法)

因服务器不在国内的缘故，网站没有很好的速度，所以苦苦钻研加速之道。

## Github

### 创建Github仓库

- 登录到Github之后点击右上角头像旁边的「+」，选择new repository创建新仓库
- 在仓库创建页面 ，填写仓库名，其他默认就行

### 通过Git同步到Github

进入要托管的网站目录，创建.gitignore文件（[https://www.toptal.com/developers/gitignore](https://www.toptal.com/developers/gitignore)）：

    cd 站点目录
    touch .gitignore
    vi .gitignore

把以下内容复制到.gitignore：

    ## 排除文件目录
    *.php
    *.html
    *.xml
    *.po
    *.mo
    *.json
    *.txt
    *.htaccess
    *.zip
    *.gz
    *.phtml
    *.html.gz
    *.bmp
    *.md
    !/wp-content/cache/
    !/wp-content/upload/

通过Git同步静态文件到Github：

    git init #初始化git
    git add -A wp-content wp-includes .gitignore # 添加要上传的文件
    git commit -m "Up statics" # 提交说明，可以自定义
    git remote add origin 自己仓库的SSH链接
    git push -u origin master

## WP Super Cache

安装好WP Super Cache插件后，在CDN一栏：

    1、开启CDN支持勾选上
    2、Off-site URL填入：https://cdn.jsdelivr.net/gh/用户名/仓库名@分支

## jsDelivr

访问网站，查看图片和js地址，变成 [https://cdn.jsdelivr.net](https://cdn.jsdelivr.net) 地址开头，说明成功了。


WordPress+jsDelivr+WP Super Cache开启伪全站CDN

这里是 aboss.top 的自留地。写了十几年野路子代码，攒了些摸爬滚打的经验，做成系列课程慢慢讲；也留了一小块地方，记记代码之外的胡思乱想。