1. 自我介绍
2. 规划是什么
3. 做过的比较有意义的项目
4. 对公司的贡献
5. 分库分表的问题 垂直分水平分
6. require include 区别
7. php 加快响应速度的办法
8. 一个亿级访问量网站的架构
9. session 共享的问题
10. 公司服务器架构
11. 前端相关东西

linux

GOOS=linux GOARCH=amd64 bee pack

看了别人的快速排序实现之后，写了新的一版快排，不同之处就是数组的分割函数。
比上一版看起来更容易理解，而且实现的更加高明一些？(不确定)

var quickSort = function(arr, left , right) {
    if (left < right) {
        var pivotIndex = partition(arr, left, right);
        quickSort(arr, left, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, right);
    }
}

var partition = function(arr, left, right) {
    var pivotIndex = left;
    var pivotValue = arr[left];
    // 升序排列 所以把基准数 放到后面
    swap(arr, pivotIndex, right);

    var storeIndex = left;
    for (i = left; i < right; i++) {
        if (arr[i] < pivotValue) {
            swap(arr, storeIndex, i);
            storeIndex++;
        }
    }

    swap(arr, storeIndex, right);

    return storeIndex;
}

var swap = function(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

var arr = [15, 4, 23, 32, 2, 7, 14, 24, 3, 1, 44, 51, 17];
quickSort(arr, 0, arr.length - 1);
console.log(arr);

js 实现的快速排序
目前是升序排列，改成降序只需要将 arr[j] >= mid 和 arr[i] <= mid 中的 >= 和 <= 互换
算法优化：

• 随机取基准数
• 采用三数取中的方式取基准数
• 多种排序算法配合 - 当数组元素比较少的时候采用插入排序

const quickSort = (arr, left, right) => {
    if (left < right) {
        // 取第一个数为基准数
        let mid = arr[left];
        let i = left;
        let j = right;
        let temp = 0;

        while (i < j) {
            // 先从 *右边* 开始找 *小于* 基准数的值
            while (i < j && arr[j] >= mid) {
                // 在 i < j 的前提下 直到找到小于基准数的值 本次循环结束
                j--;
            }
            // 再从 *左边* 开始找 *大于* 基准数的值
            while (i < j && arr[i] <= mid) {
                // 在 i < j 的前提下 直到找到大于基准数的值 本次循环结束
                i++;
            }
            // console.log(i, j);
            // 交换 - 这里 肯定是 i <= j 的，加上 i < j 的判断可以少一次无用的赋值
            if (i < j) {
                temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;            
            }
        }

        // 到这里的话 i = j
        arr[left] = arr[i];
        arr[i] = mid;
    
        // 再排左半边
        quickSort(arr, left, i - 1);
        // 再排右半边
        quickSort(arr, i + 1, right);
    }
}

var arr = [15, 4, 23, 32, 2, 7, 14, 24, 3, 1, 44, 51, 17];
// var arr = [153, 234, 4364, 565, 32423, 2, 5, 55, 35, 23, 24, 23, 32, 22, 27, 14, 4, 3, 1, 14];

quickSort(arr, 0, arr.length - 1);
console.log(arr);

package main

import (
    "encoding/base64"
    "fmt"
    "io"
    "os"
    "regexp"

    "github.com/imroc/biu"
)

func main() {
    
    s := `二进制字符串`
    s = strings.Replace(s, "_", "1", -1)
    arr := regexp.MustCompile("\\d+").FindAllString(s, -1)

    var r = make([]byte, 0, len(arr))

    for _, x := range arr {
        var a byte
        biu.ReadBinaryString(x, &a)
        r = append(r, a)
    }

    wireteString, _ := base64.StdEncoding.DecodeString(string(r))
    // fmt.Println(wireteString)
    f, err := os.Create("/Users/jiayx/workspace/jiayx/go/src/lean/a.tar.gz") //创建文件
    if err != nil {
        panic(err)
    }
    n, _ := io.WriteString(f, string(wireteString))
    println("写入文件成功, 长度：", n)
}