Time：2020-10-18

# ARTS

Arts is an activity launched by Chen Hao in the geek time column. The aim is to keep learning through sharing.

Each person writes arts once a week: algorithm is an algorithm problem, review is to read an English article, technique / tips is to share a small technology, share is to share a point of view.

## This week’s content

This week’s arts you’ll see:

1. The longest palindrome subsequence of leetcode 516
2. Golang programming specification from Uber

## Algorithm

This week’s algorithm is leetcode 516. Longest palindromic subsequence, the longest palindromic subsequence

The biggest difference between palindrome sequences and interrogative strings is that`sequence`It can be discontinuous, but`strand`It must be continuous

So the difference between the longest palindrome string in question 5 and this one is more extensive

``````//Yes, I copied the answer https://leetcode-cn.com/problems/longest-palindromic-subsequence/solution/zi-xu-lie-wen-ti-tong-yong-si-lu-zui-chang-hui-wen/
//DP [i] [J] represents the length of palindrome subsequence in the range from I to J
//Base case: DP [i] [i] means that a character must be a palindrome subsequence
func longestPalindromeSubseq(s string) int {
l := len(s)
dp := make([][]int, l)
for i := range dp {
dp[i] = make([]int, l)
}
for i := 0; i < l; i++ {
dp[i][i] = 1
}

for i := l - 1; i >= 0; i-- {
for j := i + 1; j < l; j++ {
if s[i] == s[j] {
dp[i][j] = dp[i+1][j-1] + 2
} else {
dp[i][j] = max(dp[i+1][j], dp[i][j-1])
}
}
}

return dp[0][l-1]
}

func max(a, b int) int {
if a > b {
return a
}
return b
}``````

## Review article recommendation

The recommended English article this week is Uber’s internal golang programming specification

This specification includes some programming skills and conventions of golang, as well as some more superficial specifications such as code format. Here are some points I think are more important

1. use`golint`and`go vet`Command
2. The implementation type of interface is judged by the compiler
3. Pay attention to the type and encapsulation of errors
4. If you use atomic operation but feel that the official package is too leaky, you can try Uber’s encapsulation of atomic operation
5. Use less global variables
6. Use less anonymous composition, because anonymous composition has to expose the encapsulation details of anonymous properties
7. Try to use init () less to do initialization work
8. Using strconv instead of sprintf to do string type conversion
9. Less type conversion from string to byte
10. When using make to create slices and maps, it is best to specify capacity
11. Specify package in lowercase and singular
12. It is better to use underscores for global variables in packages that are not exposed to the public_ start.
13. use`if len(s) == 0`instead of`if s == nil`To determine whether slice is empty
14. Less use of bare parameters (literal parameters?)
15. Use the original string wrapped with anti single quotation marks to escape special symbols
16. Use the way of printing table to build unit test data
17. Use a variable length function array as an optional parameter for the configuration type

## Tip programming skills

There is no technique this week

## Share flash

There was no light this week

## Reading list of the week

• Design and implementation of 6.5 scheduler in go language

1. Three roles of go Ctrip scheduling GMP
The G structure contains stack related information, as well as stackguard0, defer and – Panic linked list related to preemptive scheduling. It also includes the threads occupied by the current g, sched and goal related data of the scheduler.
The more important fields contained in M are G0 and currg, where G0 represents the G holding the scheduling stack, and he will deeply participate in the scheduling of the coroutine. Curg is the user g running on the current thread, These are the only two goroutines that the operating system threads are concerned with. In addition, there are processor P running code, processor nextp temporarily stored, and processor oldp that uses threads before executing system calls
The number of P is set by gomaxprocs. At most, only gomaxprocs active operating system threads can run normally. P is the middle layer between threads and goroutine, and it is also responsible for scheduling waiting queues on threads. It can switch in time when goroutine performs some I / O operations, so as to improve the utilization of threads`_Pidle`Represents that the G queue on P is empty,`_Prunning`Represents that the user code is being executed,`_Pgcstop`P is stopped by GC, etc