• Lightweight RPC based communications
• Event broadcasting and notifications
• CRDT Data synchronisation and storage
• Consensus protocol and execution engine
• WebAssembly target compilation support
• Unique randomized token generation aka BLS
• P2P gossip networking defined in user space

• 基于轻量级的RPC通信
• 事件驱动和消息通知
• CRDT数据同步和存储（CRDT是Conflict-free Replicated Data Type的简称,也称为a passive synchronisation,即免冲突的可复制的数据类型）
• 一致的协议和执行引擎
• 实验性的编译器支持
• 唯一token生成器BLS
• 用户空间自定义P2P网络

两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 
输出：7 -> 0 -> 8
原因：342 + 465 = 807LeetCode

func myPow(a,n int) int {

  result := int(1)

  for i:= n; i >0 ; i >>= 1 {

    if i&1 != 0 {

      result *=a

    }

    a *=a

  }

  return result

}

​

func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {

  var a,b,c,i,j int

  p1 := l1

  for p1!= nil {

    a = a + p1.Val * myPow(10,i)

    i++

    p1 = p1.Next

  }

  p2 := l2

  for p2!= nil {

    b = b + p2.Val * myPow(10,j)

    j++

    p2 = p2.Next

  }

  c = a + b

​

  str := strconv.Itoa(c)

  headNode := new(ListNode)

  current := headNode

  current.Next = nil

  for _,one := range str {

    preNode := current

    current.Val = int(one-48)

    current = new(ListNode)

    current.Next = preNode

​

  }

  

  return current.Next

}

func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {

    headList := new(ListNode)

    head := headList

    num := 0



    for (l1 != nil || l2 != nil || num > 0) {

        headList.Next =  new(ListNode)

        headList = headList.Next

        if l1 != nil {

            num = num + l1.Val

            l1 = l1.Next

        }

        if l2 != nil {

            num = num + l2.Val

            l2 = l2.Next

        }

        headList.Val = (num) % 10

        num = num / 10 

    }



    return head.Next

}

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 

示例： 

给定 nums = [2, 7, 11, 15], target = 9 

因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]LeetCode
 

func twoSum(nums []int, target int) []int {

    len := len(nums)

    var x,y int



    for i:=0; i < len && x|y == 0; i++ {

        findNum := target - nums[i]

        for j:=0; j < len; j++ {

            if findNum == nums[j] {

                x = i;

                y = j;

            }

        }

        

    }



    return []int{x,y}

}

func twoSum(nums []int, target int) []int {

    var hashMap map[int]int

    len := len(nums)

    var x,y,found int



    //初始化字典

    hashMap = make(map[int]int)

    for i:=0; i < len; i++ {

        hashMap[nums[i]] = i

    }



    for j:=0; j < len && found == 0; j++ {

        findNum := target - nums[j]

        v, ok := hashMap[findNum]

        if ok && v != j {

            found = 1

            x = j

            y = v

        }

        

    }



    return []int{x,y}

}

var bufpool = sync.Pool{

    New: func() interface{} {

        buf := make([]byte, 512)

        return &buf

    }}

// reset resets all fields of the AuthenticationResponse before pooling it.

func (a* AuthenticationResponse) reset() {

    a.Token = ""

    a.UserID = ""

}



rsp := authPool.Get().(*AuthenticationResponse)

defer func() {

    rsp.reset()

    authPool.Put(rsp)

}()

import (

    "fmt"

    "runtime"

    "strconv"

    "time"

)



const (

    numElements = 10000000

)



var foo = map[string]int{}



func timeGC() {

    t := time.Now()

    runtime.GC()

    fmt.Printf("gc took: %s\n", time.Since(t))

}



func main() {

    for i := 0; i < numElements; i++ {

        foo[strconv.Itoa(i)] = i

    }



    for {

        timeGC()

        time.Sleep(1 * time.Second)

    }

}

gc took: 98.726321ms

gc took: 105.524633ms

gc took: 102.829451ms

gc took: 102.71908ms

gc took: 103.084104ms

gc took: 104.821989ms

import (

    "fmt"

    "runtime"

    "time"

)



const (

    numElements = 10000000

)



var foo = map[int]int{}



func timeGC() {

    t := time.Now()

    runtime.GC()

    fmt.Printf("gc took: %s\n", time.Since(t))

}



func main() {

    for i := 0; i < numElements; i++ {

        foo[i] = i

    }



    for {

        timeGC()

        time.Sleep(1 * time.Second)

    }

}

gc took: 3.608993ms

gc took: 3.926913ms

gc took: 3.955706ms

gc took: 4.063795ms

gc took: 3.91519ms

gc took: 3.75226ms

package json



// Marshal take an object and returns its representation in JSON.

func Marshal(obj interface{}) ([]byte, error) {

    // Check if this object knows how to marshal itself to JSON

    // by satisfying the Marshaller interface.

    if m, is := obj.(json.Marshaller); is {

        return m.MarshalJSON()

    }



    // It doesn't know how to marshal itself. Do default reflection based marshallling.

    return marshal(obj)

}

easyjson -all $file.go$file.go

pkg: github.com/sjwhitworth/perfblog/strbuild

BenchmarkStringBuildNaive-8          5000000           255 ns/op         216 B/op          8 allocs/op

BenchmarkStringBuildBuilder-8       20000000            54.9 ns/op        64 B/op          1 allocs/op

BenchmarkStrconv-8      30000000            39.5 ns/op        32 B/op          1 allocs/op

BenchmarkFmt-8          10000000           143 ns/op          72 B/op          3 allocs/op

data：切片中指向底层数据的指针
len：切片中的当前元素数目
cap：在不重新分配内存的前提下，切片能够增长到的元素数目

var userIDs []string

for _, bar := range rsp.Users {

    userIDs = append(userIDs, bar.ID)

}

userIDs := make([]string, 0, len(rsp.Users)

for _, bar := range rsp.Users {

    userIDs = append(userIDs, bar.ID)

}

输入: 1->2->3->4->5->NULL

输出: 5->4->3->2->1->NULL

struct ListNode {

	int val;

	struct ListNode *next;

};

1. 定义一个新head头指针，标记为newHead，将它初始为NULL，并非指向NULL，最后我们选择返回这个newHead指针作为新链表的头指针。

1. 定义一个结点node作为"临时中转站"，初始化与否并无大影响。
2. 进行循环遍历链表各个结点，判定head指针是否为空，即是否到达了原链表的结尾。如果不为空，说明还没有到达尾部。如果程序第一次运行就没有进入循环，说明传入了一个空链表，此时返回newHead新链表的头指针，同样返回NULL，这样处理也是合理的。
3. 以下开始逆序链表逻辑：在当前指针不为NULL时，先对原链表做头删操作，再对新链表做头插操作。即使用循环进行操作：
4. 让node指针指向传入函数链表的头指针head，两指针指向保持相同。
5. 然后让head指针指向它的next结点，此时旧链表已经完成了头删操作。第一个结点已经被"切割"下来。接下来要做的就是对新链表进行头插操作，使结点放入新链表。
6. 让node指针的next下一个结点指向新链表的头指针newHead，完成结点的链接，即头插入新的链表中。然后更新newHead指向为新链表的头结点。进行下一次循环。
7. 最终head指针指向了原链表的结尾，即为NULL，退出循环，此时新链表已经反转完毕，情况如图：
8. 最终返回新链表头指针newHead即可。

struct ListNode *reverseList(struct ListNode* head) {

	struct ListNode *newHead = NULL;

	struct ListNode *node;

	while (head != NULL) {

		//1. 对之前的链表做头删

		node = head;

		head = head->next;

		

		//2. 对新链表做头插

		node->next = newHead;

		newHead = node;

	}

	return newHead;

}

1. 利用选择语句，找到空链表的情况，此情况返回NULL空指针，因为空链表不能反转，或者说反转之后还是一个空链表，返回空。
2. 利用三个指针p0"前指针"、p1“当前指针”、p2"后指针"来分批处理链表元素，p0置为NULL，它将作为链表的尾结点向前推进处理，p1指向旧链表的头指针head，p2指向旧链表的头指针的next结点。
3. 开始遍历链表，循环判定因子为p1，当它为空时到达链表尾部跳出循环。否则在表中执行循环内逻辑：将p1指向的当前结点的下一个结点指向p0，即前一个结点。此时p0为NULL，那么p1的下一个结点就为空了，它现在是最后一个结点。
4. 然后将p0指针指向p1，将p1指针指向p2，注意这两步不可以调换顺序，否则正确向后挪移一位。此时完成了三个指针的一轮更迭。
5. 判定p2指针是否为空，如果为空说明此时p2到达了链表结尾，当前指针p1的指向为最后一个结点，它的next即为空。如果不为空，将p2更新到下一个结点，进行下一次循环。
6. 下一次进行循环时，就会把截断结点链接到新链表的头部，同时更新三个指针。继续循环。
7. 循环终止条件为：p1指向了链表尾部的NULL，此时p1的前指针p0即指向了反转后的链表，它就是新链表的head头指针。此时返回p0即可。

struct ListNode *reverseList(struct ListNode* head) {

	if (head == NULL) {

		return NULL;

	}

	struct ListNode *p0 = NULL;

	struct ListNode *p1 = head;

	struct ListNode *p2 = head->next;

	while (p1 != NULL) {

		p1->next = p0;



		p0 = p1;

		p1 = p2;

		if (p2 != NULL) {

			p2 = p2->next;

		}

	}

	return p0;

}

int sum(int x, int y) {

    return x + y;

}

Linux32     55 89 e5 8b 45 0c 03 45 08 c9 c3
Windows  55 89 e5 8b 45 0c 03 45 08 5d c3
Sun           81 c3 e0 08 90 03 00 09

void inplace_swap(int *x, int *y){

    *y = *x ^ *y;

    *x = *x ^ *y;

    *y = *x ^ *y;

}

初始：*x = a    *y = b
第一步：*x = a   *y = a ^ b
第二步：*x = a ^ (a ^ b) = (a ^ a) ^ b = b   *y = a ^ b
第三部：*x = b   *y = b ^ ( a ^ b) = (b ^ b) ^ a = a

o'clock = of the clock.

小端法：在内存中按照从最低有效字节到最高有效字节的顺序存储对象；
大端法：在内存中按照从最高有效字节到最低有效字节的顺序存储对象；一旦选择了特定的操作系统，那么字节顺序也就固定下来。Android和IOS只能够运行于小端模式下。

​#include <stdio.h>

​

typedef unsigned char *byte_pointer;

//typedef char *byte_pointer;

​

void show_bytes(byte_pointer start, size_t len) {

    size_t i;

    for (i = 0; i < len; i++)

        printf("%p\t0x%.2x\n", &start, start);

    printf("\n");

}

​

void show_int(int x) {

    show_bytes((byte_pointer) &x, sizeof(int));

}

​

void show_float(float x) {

    show_bytes((byte_pointer) &x, sizeof(float));

}

​

void show_pointer(void *x) {

    show_bytes((byte_pointer) &x, sizeof(void *));

}

​

public function rules()

{

 return [

  ["!user_od", "required"],

  ["!user_id", "integer"],

  ["!user_od", "unique"],

  // other rules

 ];

}

public function rules()

{

 return [

  ["password", "string", "length" => [8, 16], "on" => ["signup"]], // 仅在signup场景时才被验证

  ["status", "integer", "except" => ["signup"], // 除了signup场景，其他情况都校验

  // other rules

 ];

}

public function scenarios()

{

 return [

  self::SCENARIO_DEFAULT => ["!user_id", "grade", "class", xxxx],

  "update" => ["grade", "class", xxxx],

 ];

}

经济内循环其实就是要过苦日子的另一个代名词。也可以简单理解为好好干活，但不要想着能挣很多钱。在未来很长一段时间里面，物价会相对比较便宜。

package main



import "fmt"



type Printer func(contents string) (n int, err error)



func printToStd(contents string) (bytesNum int, err error) {

  return fmt.Println(contents)

}



func main() {

  var p Printer

  p = printToStd

  p("something")

}

各个参数和结果的名称不能算作函数签名的一部分，对于结果声明，名字也可以没有。且函数的名称也不算函数签名的一部分，只是个标识符而已。

1. 接受其他的函数作为参数传入；
2. 把其他的函数作为结果返回。

if op == nil { 

    return 0, errors.New("invalid operation") 

}

//该编译后的程序可以在32或64位机器上运行

linux> gcc -m32 prog.c

​

//该编译后，只能在64位机器上运行

linux> gcc -m64 prog.c

1.随机性发现的Bad case
2.KPI或者OKR考核
3.业务方诉求

• “搜索PV”：指访问搜索页面的次数；
• “搜索UV”：访问过搜索结果页的用户数；
• “无结果率”：空结果PV/搜索PV，无结果率越低，代表客户搜索需求解决情况越好；
• “TOP5 PV—CTR”：指该query search结果中，排在前五位的item有被点击的搜索PV/该query搜索PV该指标能一定程度反应排序效果；
• “人均搜索PV”：搜索PV/搜索UV；该指标的含义比较复杂，一方面人均pv大的话可能代表用户对搜索比较感兴趣，但另一方面人均pv大也可能代表搜索召回的结果较差，导致用户无法使用较少的点击找到满足需求的结果；
• “有点击搜索PV占比”：有点击搜索PV/搜索PV数；
• “PV-CTR”:搜索结果页item点击数/搜索PV数；
• “UV-CTR”:点击的uv / 曝光的uv；
• “Item-CTR”：搜索结果页item点击数/搜索结果页item总曝光PV数；

无符号编码：基于传统的二进制表示法，表示大于或者等于0的数字；
补码编码：表示有符号整数的最常见方式；
浮点数编码：表示实数的科学计数法的以2为基数的版本；

linux> gcc -std=c11 zkbhj.c

//其他版本参数

//GNU 89 无，-std=gnu89

//ANSI ,ISO C90 -ansi,-std=c89

//ISO C99 -std=c99

//ISO C11 -std=c11

var uselessChan = make(chan<- int, 1)

var uselessChan = make(<-chan int, 1)

//参数定义中就约束 ch只能进行发送操作，不能接收

//可以限制方法函数内对参数的操作行为做限定

func SendInt(ch chan<- int) { 

    ch <- rand.Intn(1000)

}

//这段接口声明中，就约定了所以要实现这个接口的实现类型

//都约定了这些方法的参数类型

type Notifier interface { 

  SendInt(ch chan<- int)

}

select {

case <-intChannels[0]: 

fmt.Println("The first candidate case is selected.")

case <-intChannels[1]: 

fmt.Println("The second candidate case is selected.")

case elem := <-intChannels[2]: fmt.Printf("The third candidate case is selected, the element is %d.\n", elem)

default: fmt.Println("No candidate case is selected!")

}

1、对于每一个case表达式，都至少会包含一个代表发送操作的发送表达式或者一个代表接收操作的接收表达式；
2、select语句包含的候选分支中的case表达式都会在该语句执行开始时先被求值，并且求值的顺序是依从代码编写的顺序从上到下的；
3、对于每一个case表达式，如果其中的发送表达式或者接收表达式在被求值时，相应的操作正处于阻塞状态，那么对该case表达式的求值就是不成功的；
4、仅当select语句中的所有case表达式都被求值完毕后，它才会开始选择候选分支。这时候，它只会挑选满足选择条件的候选分支执行。所有的都不满足，执行default；
5、如果select语句发现同时有多个候选分支满足选择条件，那么它就会用一种伪随机的算法在这些分支中选择一个并执行；

1. ​中国发展仍处于战略机遇期
2. 从持久战角度认识中长期问题
3. 以国内大循环为主题
4. 建立中长期协调机制
5. 牢牢把握扩大内需这个战略基点
6. 确保宏观政策落地见效
7. 保持货币供应量合理增长
8. 毫不放松抓好常态化疫情防控
9. 扩大最终消费
10. 加快新基建
11. 以新型城镇化带动投资和消费
12. 产业链补短板和锻长板
13. 从严打击证券违法活动
14. 住房不炒
15. 缓解疫情对年轻人就业影响

“在泡沫中狂欢的日志不多了，做好潮水退却后的准备，是每个国家，每个人都要面对的现实”

——吴晓灵 前央行副行长

主要思想是：当对系统的某个部分加速时，其对系统整体性能的影响取决于该部分的重要性和加速程度。
主要观点是：想要显著加速整个系统，必须提升全系统中相当大的部分的速度。

一周的早读，完成了《深入理解计算机系统》这本又厚又重的计算机最底层原理书籍第一章的阅读和理解。
好好利用碎片时间，以及找到自己的高效时间段及学习方式很重要。
积少成多，积流成河！
明天开启第二章：程序结构和执行！

1、打开美团APP，点击进入个人中心页面，点击右上角的在线客服，进入客服聊天界面；

2、输入问题：支付宝无法使用；

3、在返回的结果里选择：放弃优惠，恢复支付宝。

Don’t communicate by sharing memory; share memory by communicating. （不要通过共享内存来通信，而应该通过通信来共享内存。）