DATABASES = {
    'default': {
        'ENGINE': 'django_fake_database_backends.backends.mysql',
    }
}

use mysql;
alter user 'root'@'localhost' identified with mysql_native_password by 'yourpassword';
flush privileges;

#include<stdio.h>

int succ, ans;

void sol(int cp, int lp, int rp) {
    if (cp == succ) {
        ++ans;
        return;
    }
    int p = succ & (~(cp | lp | rp));
    while (p) {
        int bit = p & (-p);
        sol(cp | bit, (lp | bit) << 1, (rp | bit) >> 1);
        p &= (p - 1);
    }
}

int totalNQueens(int n){
    ans = 0;
    succ = (1 << n) - 1;
    sol(0, 0 ,0);
    return ans;
}

int main(){
    int ans;
    ans = totalNQueens(4);
    printf("%d\n", ans);
}

sol(depth, pos) { // depth 是当前要处理第几行, pos 是前面已经安放好的位置, 也就是上面 depth-1 行的数据

	 // 如果 N 排数据都已经安置好了, ans 加1
	if depth == N+1 {
		ans++
	}

	p = 根据 pos 计算当前行可以放的所有位置

	while ( p 中还有位置可以尝试 ) {
		next = 取当前行的下一个位置
		sol(depth+1, pos.update(next))
		update(p)
	}
}

package main

import "sync"

var wg sync.WaitGroup

func work() {
	for {
		wg.Add(1)
		// ... work here
		// time.Sleep(time.Second)
		wg.Done()
	}
}

func main() {
	go work()
	defer wg.Wait()
}

If a WaitGroup is reused to wait for several independent sets of events, new Add calls must happen after all previous Wait calls have returned.

OUTPUT
======
i: 9	printi(): 9	func(): 10

i: 8	printi(): 8	func(): 10

i: 7	printi(): 7	func(): 10

i: 6	printi(): 6	func(): 10

i: 5	printi(): 5	func(): 10

i: 4	printi(): 4	func(): 10
i: 3	printi(): 3	func(): 10
i: 2	printi(): 2	func(): 10

i: 1	printi(): 1	func(): 10

i: 0	printi(): 0	func(): 10

The metadata stored in ZooKeeper for the Kafka cluster is world-readable, but can only be modified by the brokers.
The rationale behind this decision is that the data stored in ZooKeeper is not sensitive, but inappropriate manipulation of that data can cause cluster disruption.
We also recommend limiting the access to ZooKeeper via network segmentation (only brokers and some admin tools need access to ZooKeeper).

quorum.auth.enableSasl=true
quorum.auth.learnerRequireSasl=true
quorum.auth.serverRequireSasl=true
quorum.auth.learner.loginContext=QuorumLearner
quorum.auth.server.loginContext=QuorumServer
#quorum.auth.kerberos.servicePrincipal=servicename/_HOST
quorum.cnxn.threads.size=20

SERVER_JVMFLAGS="-Djava.security.auth.login.config=/path/to/server/jaas/file.conf"

Server {
    org.apache.zookeeper.server.auth.DigestLoginModule required
	    user_super="123456"
		user_kafka="123456"
		user_someoneelse="123456";

};

QuorumServer {
       org.apache.zookeeper.server.auth.DigestLoginModule required
       user_zookeeper="123456";
};

QuorumLearner {
       org.apache.zookeeper.server.auth.DigestLoginModule required
       username="zookeeper"
       password="123456";
};

requireClientAuthScheme=sasl
authProvider.<IdOfBroker1>=org.apache.zookeeper.server.auth.SASLAuthenticationProvider
authProvider.<IdOfBroker2>=org.apache.zookeeper.server.auth.SASLAuthenticationProvider
authProvider.<IdOfBroker3>=org.apache.zookeeper.server.auth.SASLAuthenticationProvider

zookeeper.set.acl=true

KAFKA_OPTS="-Djava.security.auth.login.config=./config/jaas.conf"

Client {
    org.apache.kafka.common.security.plain.PlainLoginModule required
	username="kafka"
	password="123456";

};

package main

import (
	"fmt"
	"math"
	"math/rand"
	"strings"
	"time"
)

func maxHeapify(A []int, i int) {
	var (
		size  = len(A)
		left  int
		right int
		max   int
	)

	for {
		left = 2*i + 1
		right = 2*i + 2
		max = i

		if left < size && A[i] < A[left] {
			max = left
		}
		if right < size && A[max] < A[right] {
			max = right
		}

		if max == i {
			return
		}
		A[i], A[max] = A[max], A[i]
		i = max
	}
}

func buildMaxHeap(A []int) {
	length := len(A)
	for i := length/2 - 1; i >= 0; i-- {
		maxHeapify(A, i)
	}
}

func GA(N int) (A []int) {
	A = make([]int, 10)
	for i := 0; i < N; i++ {
		A[i] = N - i
	}
	A[0] = 0
	return
}
func RGA(N int) (A []int) {
	rand.Seed(time.Now().UnixNano())

	A = make([]int, 10)
	for i := 0; i < N; i++ {
		A[i] = rand.Intn(N * N)
	}
	return
}

func isHeap(A []int) bool {
	size := len(A)
	for i := 0; i < size; i++ {
		left := 2*i + 1
		right := 2*i + 1
		if left < size && A[left] > A[i] {
			return false
		}
		if right < size && A[right] > A[i] {
			return false
		}
	}
	return true
}

func printTree(A []int) {
	var (
		currentHeight      = 0
		startOfCurrentLine = 0
		height             = int(math.Ceil(math.Log2(float64(len(A)) + 0.5)))
	)
	for i := 0; i < len(A); i++ {
		if i == startOfCurrentLine {
			jstring := make([]string, height-currentHeight)
			for j := 0; j < height-currentHeight; j++ {
				jstring[j] = " "
			}
			currentHeight++
			fmt.Printf("\n%s", strings.Join(jstring, ""))
			startOfCurrentLine = 2*startOfCurrentLine + 1
		}
		fmt.Printf("%d ", A[i])
	}
	fmt.Println("\n")
}

func main() {
	count := 100
	for i := 0; i < count; i++ {
		A := RGA(10)
		//printTree(A)
		buildMaxHeap(A)
		fmt.Println(isHeap(A))
		//printTree(A)
	}
}

func maxHeapify(A []int, i int) {
	var (
		size  = len(A)
		left  int
		right int
		max   int
	)

	for {
		left = 2*i + 1
		right = 2*i + 2
		max = i

		if left < size && A[i] < A[left] {
			max = left
		}
		if right < size && A[max] < A[right] {
			max = right
		}

		if max == i {
			return
		}
		A[i], A[max] = A[max], A[i]
		i = max
	}
}

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func shuffle(array []int) {
	rand.Seed(time.Now().UnixNano())

	var (
		tmp   int
		index int
		n     = len(array)
	)

	for i := 0; i < n; i++ {
		index = rand.Intn(n-i) + i
		tmp = array[index]
		array[index] = array[i]
		array[i] = tmp
	}
}

func generate_array(n int) []int {
	array := make([]int, n)
	for i := 0; i < n; i++ {
		array[i] = i
	}
	return array
}

func main() {
	var (
		loop = 6000
		N    = 3
	)

	for i := 0; i < loop; i++ {
		array := generate_array(N)
		shuffle(array)
		fmt.Printf("%v\n", array)
	}
}

% go run 5.3.1.go | sort | uniq -c
 990 [0 1 2]
1038 [0 2 1]
 965 [1 0 2]
 991 [1 2 0]
1002 [2 0 1]
1014 [2 1 0]

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func shuffle(array []int) {
	rand.Seed(time.Now().UnixNano())

	var (
		tmp   int
		index int
		n     = len(array)
	)

	for i := 0; i < n-1; i++ {
		index = rand.Intn(n-i-1) + i + 1
		tmp = array[index]
		array[index] = array[i]
		array[i] = tmp
	}
}

func generate_array(n int) []int {
	array := make([]int, n)
	for i := 0; i < n; i++ {
		array[i] = i
	}
	return array
}

func main() {
	var (
		loop = 6000
		N    = 3
	)

	for i := 0; i < loop; i++ {
		array := generate_array(N)
		shuffle(array)
		fmt.Printf("%v\n", array)
	}
}

% go run 5.3.2.go | sort | uniq -c
2951 [1 2 0]
3049 [2 0 1]

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func shuffle(array []int) {
	rand.Seed(time.Now().UnixNano())

	var (
		tmp   int
		index int
		n     = len(array)
	)

	for i := 0; i < n-1; i++ {
		index = rand.Intn(n)
		tmp = array[index]
		array[index] = array[i]
		array[i] = tmp
	}
}

func generate_array(n int) []int {
	array := make([]int, n)
	for i := 0; i < n; i++ {
		array[i] = i
	}
	return array
}

func main() {
	var (
		loop = 6000
		N    = 3
	)

	for i := 0; i < loop; i++ {
		array := generate_array(N)
		shuffle(array)
		fmt.Printf("%v\n", array)
	}
}

% go run 5.3.3.go | sort | uniq -c | sort -k2
 892 [0 1 2]
1157 [0 2 1]
1073 [1 0 2]
1123 [1 2 0]
 864 [2 0 1]
 891 [2 1 0]

package main

import (
	"fmt"
	"math/rand"
	"sort"
	"time"
)

func permute_by_sorting(array []int) []int {
	rand.Seed(time.Now().UnixNano())

	var (
		n                     = len(array)
		N                     = n * n * n
		priority_array        = make([]int, n)
		sorted_priority_array = make([]int, n) // sort priority_array to sorted_priority_array
		shuffled_array        = make([]int, n)

		existed = map[int]bool{}
	)
	for i := 0; i < n; i++ {
		r := rand.Intn(N)
		for {
			if _, ok := existed[r]; !ok {
				break
			}
			r = rand.Intn(N)
		}
		existed[r] = true
		priority_array[i] = r
		sorted_priority_array[i] = priority_array[i]
	}

	sort.Slice(sorted_priority_array, func(i, j int) bool { return sorted_priority_array[i] < sorted_priority_array[j] })

	idx_map := make(map[int]int)
	for i := 0; i < n; i++ {
		if _, ok := idx_map[sorted_priority_array[i]]; !ok {
			idx_map[sorted_priority_array[i]] = i
		}
	}

	for i := 0; i < n; i++ {
		shuffled_array[i] = -1
	}

	for i := 0; i < n; i++ {
		e := priority_array[i]
		new_idx := idx_map[e]
		for shuffled_array[new_idx] != -1 {
			new_idx++
		}
		shuffled_array[new_idx] = array[i]
	}

	return shuffled_array
}

func main() {
	var (
		N    = 2
		loop = 6000
	)

	array := make([]int, N)
	for i := 0; i < N; i++ {
		array[i] = i
	}

	for i := 0; i < loop; i++ {
		shuffled_array := permute_by_sorting(array)
		fmt.Println(shuffled_array)
	}
}

package main

import (
	"fmt"
	"math/rand"
	"sort"
	"time"
)

func random_sample(n []int, m int) []int {
	if m == 0 {
		return []int{}
	}

	length := len(n)
	//fmt.Println(length)
	s := random_sample(n[:length-1], m-1)
	i := n[rand.Intn(length)]

	var in_s = false
	for _, j := range s {
		if j == i {
			in_s = true
			break
		}
	}

	if in_s {
		s = append(s, n[length-1])
	} else {
		s = append(s, i)
	}
	return s
}

func main() {
	rand.Seed(time.Now().UnixNano())

	var (
		loop = 10000
		N    = 5
		m    = 3
	)

	array := make([]int, N)
	for i := 0; i < N; i++ {
		array[i] = i
	}

	for i := 0; i < loop; i++ {
		s := random_sample(array, m)
		sort.Slice(s, func(i, j int) bool { return s[i] <= s[j] })
		fmt.Println(s)
	}
}