apt install samba

vim /etc/samba/smb.conf

[global]
  workgroup = SAMBA
  security = user
  passdb backend = tdbsam
  printing = cups 
  printcap name = cups
  load printers = yes
  cups options = raw

[other]
  comment = other
  path = /data/other
  browseable = yes
  writable = yes
  public = yes
  write list = +smbuser1  

smbpasswd -a smbuser1  # 添加用户，设置密码，这个密码是samba的密码

docker network inspect sonarr_default

apt install bridge-utils

vim /etc/netplan/00-installer-config.yaml

network:
  ethernets:
    enp1s0:
      dhcp4: true
    enp2s0:
      dhcp4: no
  bridges:
    br0:
      dhcp4: no
      addresses: [10.0.1.1/24]
      nameservers:
        addresses: [8.8.8.8]
      interfaces: [enp2s0]
  version: 2

netplan apply

brctl show

bridge name	bridge id		STP enabled	interfaces
br0		8000.6aa01d4c1f71	no		enp2s0

 apt install dnsmasq

vim /etc/dnsmasq.conf

interface=br0
dhcp-range=10.0.1.2,10.0.1.254,72h
dhcp-option=6,10.0.1.1
resolv-file=/etc/resolv.dnsmasq.conf
port=1053 # 这里我改成了1053，我其他地方有个dns服务，端口是53，所以这里改成了1053

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 
10154 ubuntu 20 0 1757000 36888 10020 R 362.7 0.1 2:48.41 main 
9046 ubuntu 20 0 2125668 31976 9876 S 346.3 0.1 2:51.78 server

package main

import (
	"fmt"
	"github.com/valyala/fasthttp"
)

// request handler in fasthttp style, i.e. just plain function.
func fastHTTPHandler(ctx *fasthttp.RequestCtx) {
	fmt.Fprintf(ctx, "Hi there! RequestURI is %q", ctx.RequestURI())
}

func main() {
	fasthttp.ListenAndServe(":8087", fastHTTPHandler)
}

class User {
    Name: string;
    Age: number;
}

class Student extends User {
    Grade: number;
}

class Teacher {
    Name: string;
    Class: string;
    Students: Student[];
}

const user1 = new User();
user1.Name = 'John';
user1.Age = 30;


const user2 = new User();
user2.Name = 'Jane';
user2.Age = 25;



const users = [user1, user2];

const teacher = new Teacher();
teacher.Name = 'Bob';
teacher.Class = '1A';

const teacher2 = new Teacher();
teacher2.Name = 'Alice';
teacher2.Class = '1B';

const teachers = [teacher, teacher2];

const userMap = users.reduce((acc, cur) => {
    acc[cur.Name] = cur;
    return acc;
  }, {});

const gradeTeacher = new Array<Teacher>();

teachers.forEach(teacher => {
    const students = new Array<Student>();
    const teacherName = teacher.Name;

    Object.entries(userMap).forEach(([key, value]) => {

        let student = new Student();
        student = userMap[key];
        if (teacherName === 'Bob') {
          student.Grade = 100;
        } else {
            student.Grade = 50;
        }
        students.push(student);

    });
    teacher.Students = students;
    gradeTeacher.push(teacher);
});


for (const teacher of gradeTeacher) {
    console.log(teacher); 
}

Teacher {
  Name: 'Bob',
  Class: '1A',
  Students: [
    User { Name: 'John', Age: 30, Grade: 100 },
    User { Name: 'Jane', Age: 25, Grade: 100 }
  ]
}
Teacher {
  Name: 'Alice',
  Class: '1B',
  Students: [
    User { Name: 'John', Age: 30, Grade: 50 },
    User { Name: 'Jane', Age: 25, Grade: 50 }
  ]
}

Teacher {
  Name: 'Bob',
  Class: '1A',
  Students: [
    User { Name: 'John', Age: 30, Grade: 50 },
    User { Name: 'Jane', Age: 25, Grade: 50 }
  ]
}
Teacher {
  Name: 'Alice',
  Class: '1B',
  Students: [
    User { Name: 'John', Age: 30, Grade: 50 },
    User { Name: 'Jane', Age: 25, Grade: 50 }
  ]
}

func main() {
    matrix := generateMatrix(3)
    printMatrix(matrix)
}

func printMatrix(matrix [][]int) {
    if matrix == nil || len(matrix) == 0 {
        return
    }
    n := len(matrix)
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            fmt.Printf("%d ", matrix[i][j])
        }
        fmt.Println()
    }
}

func generateMatrix(n int) [][]int {
	upper_bound, left_bound := 0, 0
	lower_bound, right_bound := n-1, n-1
    // 反向的话，number是最大值
	number := n*n
	var matrix = make([][]int, n)
	for k := range matrix {
		matrix[k] = make([]int, n)
	}
	for number > 0 {
		if upper_bound <= lower_bound {
			for j := left_bound; j <= right_bound; j++ {
				number--
				matrix[upper_bound][j] = number
			}
			upper_bound++
		}
		if left_bound <= right_bound {
			for j := upper_bound; j <= lower_bound; j++ {
				number00
				matrix[j][right_bound] = number
			}
			right_bound--
		}
		if upper_bound <= lower_bound {
			for j := right_bound; j >= left_bound; j-- {
				number--
				matrix[lower_bound][j] = number
			}
			lower_bound--
		}
		if left_bound <= right_bound {
			for j := lower_bound; j >= upper_bound; j-- {
				number--
				matrix[j][left_bound] = number
			}
			left_bound++
		}

	}
	return matrix

}

var result [][]int

var ch = make(chan *TreeNode, 100)
var sumChan = make(chan int, 100)
var nodes = make(chan []int, 100)

for len(ch) > 0 {
    for i := 0; i < len(ch); i++ {
        //获取当前节点
        cur := <-ch
        //获取父节点的总和
        parentSum := <-sumChan
        //获取父节点的所有路径节点序列
        parents := <-nodes
        //当前节点的总和
        curSum := parentSum + cur.Val
        //当前节点的序列
        curNodes := append(parents, cur.Val)

        if cur.Left == nil && cur.Right == nil {
            if curSum == targetSum {
                // 添加当前节点序列到结果集
                result = append(result, curNodes)
            }
        } else {
            if cur.Left != nil {
                ch <- cur.Left
                sumChan <- cur.Val + parentSum
                nodes <-  curNodes
            }
            if cur.Right != nil {
                ch <- cur.Right
                sumChan <- cur.Val + parentSum
                nodes <- curNodes
            }
        }

    }
}