go学习 草稿

package main

import (
"crypto/md5"
"fmt"
"log"
"math"
"math/bits"
"math/rand"
"os"
"reflect"
"runtime"
"sort"
"strconv"
"strings"
"sync"
"te"
"time"
"unsafe"
//"hash"
"encoding/hex"
fstate "fsm"
"io"
"regexp"
)

var c bool
var age int
var score float32
var tree, tree2 uint16
var list []uint

func main() {
// _, txt := addStr(1, "new")
// fmt.Println("Google" + "Runoob", txt)
// var man male
// fu := man.change(6,5)
// fmt.Println("===>>", fu())
//main1()
//te.When()
randseed = time.Now().UnixNano()
main6()
}

const (
Unknown = "1123swerwe"
Female = len(Unknown)
Male = unsafe.Sizeof(Unknown)
Today = iota
Nice
)

func addStr(num int, str string) (a, b int) {
age = 1
newd := 1
body, newd := age, 1
age += body
arr := []int{1, 23, 34, 3, 63}
slice1 := make([]int, 5)
fmt.Println(Unknown, Female, Male, unsafe.Sizeof(arr), Today, Nice)
bload(arr)
for k, v := range slice1 {
fmt.Println(k, v)
}
const Length int = 1
return age, newd
}

func bload(arr []int) {
arr[len(arr)-1] = 999
}

type male struct {
body float32
}

func (c male) change(a, b int) func() int {
NCC:
if a >= b {
fmt.Println(a, "big")
a = a - 1
goto NCC
} else {
fmt.Println(a, "small")
}
return func() int {
a++
return a
}
}

// 定义一个 DivideError 结构
type DivideError struct {
dividee int
divider int
}

func (obj *DivideError) Div() {
obj.dividee = 10
obj.divider = 9
}

func (obj DivideError) Div1() {
obj.dividee = 100
obj.divider = 90
}

// 实现 error 接口
func (de *DivideError) Error() string {
strFormat := Cannot proceed, the divider is zero. dividee: %d divider: 0

return fmt.Sprintf(strFormat, de.dividee)

}

// 定义 int 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
if varDivider == 0 {
dData := DivideError{
dividee: varDividee,
divider: varDivider,
}
errorMsg = dData.Error()
return
} else {
return varDividee / varDivider, ""
}

}

func main1() {

if result, errorMsg := Divide(100, 10); errorMsg == "" {
	fmt.Println("100/10 = ", result)
}
// 当除数为零的时候会返回错误信息
if _, errorMsg := Divide(100, 0); errorMsg != "" {
	fmt.Println("errorMsg is: ", errorMsg)
}
chans()
maps()

var di DivideError
di.Div()
//fmt.Println("====>>>>", di.dividee, di.divider)

}

func worker(id int, c chan int) {
for {
fmt.Printf("worker %d run %c ", id, <-c)
}
}

func chans() {
// var channels [10]chan int
// for i:=0;i<2;i++{
// channels[i]=make(chan int)
// go worker(i,channels[i])
// }
// for i:=0;i<10;i++{
// channels[0] <- 'a'+i
// }

// fmt.Println("=======>>>")
// for i:=0;i<10;i++{
//     channels[1] <- 'A'+i
// }

}

func maps() {
var contryMap map[string]string = make(map[string]string)
contryMap["nis"] = "nik"
contryMap["nid"] = "nikw"
contryMap["ni"] = "nikd"
for k, v := range contryMap {
fmt.Println(k, v)
}
fmt.Println("dd", contryMap["ni"+"s"])
fun(callback).call(2)
mains()
}

func mains() {
fmt.Printf(">>>>%T ", 123)

type cat struct {
	Name string
	Type int `json:"type" id:"100"`
}
typeOfCat := reflect.TypeOf(cat{})
if catType, ok := typeOfCat.FieldByName("Type"); ok {
	fmt.Println(catType.Tag.Get("json"))
	fmt.Println(catType.Tag.Get("id"))
}
//main2()

main3()

}

//需要传递函数
func callback(i int) {
d := &i
fmt.Println("i am callBack", reflect.TypeOf(d))
fmt.Println(i)
}

//定义的type函数
type fun func(int)

//fun实现的Call接口的call()函数
func (f fun) call(i int) {
f(i)
}

//接口
// type Call interface {
// call(int)
// }

// 崩溃时需要传递的上下文信息
type panicContext struct {
functionss string // 所在函数
function int // 所在函数
}

// 保护方式允许一个函数
func ProtectRun(entry func()) {
//延迟处理的函数
defer func() {
// 发生宕机时，获取panic传递的上下文并打印
err := recover()
switch err.(type) {
case runtime.Error: // 运行时错误
fmt.Println("runtime error:", err)
default: // 非运行时错误
fmt.Println("error:", err)
}
}()
entry()
}
func main2() {
fmt.Println("运行前")
// 允许一段手动触发的错误
ProtectRun(func() {
fmt.Println("手动宕机前")
// 使用panic传递上下文
panic(&panicContext{
"手动触发panic",
555,
})
fmt.Println("手动宕机后")
})
// 故意造成空指针访问错误
ProtectRun(func() {
fmt.Println("赋值宕机前")
var a *int
*a = 1
fmt.Println("赋值宕机后")
})
fmt.Println("运行后")
}

type coder interface {
code()
debug()
}

type Gopher struct {
num int
language string
}

func (p Gopher) code() {
p.num++
fmt.Printf("I am coding %s language, num is %d ", p.language, p.num)
}

func (p *Gopher) debug() {
p.num++
fmt.Printf("I am debuging %s language, num is %d ", p.language, p.num)
}

func maintest() {
// var take coder
// take = &Gopher{100, "doing"}
// take.code()
// take.debug()
// take.code()

lsInt := make(chan int)
fmt.Println("6666666", time.Second)
count := 0
var lock sync.Mutex
go func() {
	for i := 0; i < 26; i++ {
		lock.Lock()
		count = count + 1
		fmt.Println("go<<<", i, count)
		lock.Unlock()
		lsInt <- i
	}

}()
go func() {
	for i := 0; i < 16; i++ {
		m := <-lsInt
		lock.Lock()
		count = count + 1
		fmt.Println("go>>>", m, count)
		lock.Unlock()
	}
}()
m := <-lsInt
lock.Lock()
count = count + 1
fmt.Println("main>>>", m, count)
lock.Unlock()
fmt.Println("zzzzz", count)

}

func mainos() {
// 预定义变量, 保存命令行参数
fmt.Println(os.Args)

// 获取host name
fmt.Println(os.Hostname())
fmt.Println(os.Getpid())

// 获取全部环境变量
// env := os.Environ()
// for k, v := range env {
// 	fmt.Println(k, v)
// }

// 终止程序
// os.Exit(1)

// 获取一条环境变量
//fmt.Println(os.Getenv("PATH"))

// 获取当前目录
dir, err := os.Getwd()
fmt.Println(dir, err)

// 创建目录
err = os.Mkdir(dir+"/new_file", 0755)
fmt.Println(err)

// 创建目录
err = os.MkdirAll(dir+"/new", 0755)
fmt.Println(err)

// 删除目录
err = os.Remove(dir + "/new_file")
err = os.Remove(dir + "/new")
fmt.Println(err)

// 创建临时目录
tmp_dir := os.TempDir()
fmt.Println(tmp_dir)

}

func findRoad(r *int) {
log.Println("road:", *r)
}
func entry() {
rd := int(999)
r := &rd
runtime.SetFinalizer(r, findRoad)
}

func main3() {
// entry()
// for i := 0; i < 3; i++ {
// time.Sleep(time.Second)
// runtime.GC()
// }
var x float64 = 3.4
//data := reflect.TypeOf(x)
value := reflect.ValueOf(x)
// floatData := value.Float()
// floatData = 1.3
over := value.Interface()
fmt.Println(reflect.TypeOf(over), reflect.TypeOf(over.(float64)), over, interface{}(interface{}(over)).(float64), interface{}(x).(float64))

return

}

func KeyPrefix(str interface{}) (prefix string) {
t := reflect.TypeOf(str).Elem()
prefix = fmt.Sprintf("%s_%s_", "india_game", t.String())
return
}

type pick struct {
str string
co int
}

type Person05 struct {
name string
sex string
age int
}

func (p Person05) printInfo() {
fmt.Printf("55>>名称：%s, 性别：%s, 年龄：%d ", p.name, p.sex, p.age)
}

type inter interface {
printInfo()
}

type Person04 struct {
Person05
sex bool
name string
age int
}

func (p Person04) printInfo() {
fmt.Printf("44>>名称：%s, 性别：%s, 年龄：%d ", p.name, p.sex, p.age)
}

type Student struct {
Person05
id int
}

func Float64bits(f float64) uint64 { return (uint64)(unsafe.Pointer(&f)) }

//func Float64bits(f, m float64){ return (uint64)(unsafe.Pointer(&f)) }

func init() {

}

func init() {

}

func main61() {
// str := "zzzzzz"
// m := KeyPrefix(&str)
// fmt.Println(m)
// picks := pick{}
// fmt.Println(&picks, &picks.co,&(picks.co), (&picks).co)

// user := pick{"go", 3}
// fmt.Printf("%v %v
", user, &user)
// fmt.Printf("%+v %+v
", user, &user)
// fmt.Printf("%#v %#v
", user, &user)

// done := make(chan int, 1) // 带缓存通道
// go func() {
// 	fmt.Println(">>>>>1")
// 	<-done
// 	fmt.Println(">>>>>2")
// }()
// fmt.Println(">>>>>3")
// done <- 1
// fic.When(2)
// //fic2.When(3)

//fic.When(2)
// //fic2.When(3)
// fic2.Put()

// oldList := []int {1,2,3,4,5,6}
// i := 3
// fmt.Println(oldList[:1], oldList[i+1:])
// oldList = append(oldList[:i], oldList[i+1:]...)
// fmt.Println(oldList)

// x := []int {1,2,3}
// //注意下面这两个区别
// fmt.Println(append(x,4,5,6), x)
// if(fic.When == nil){
// 	fmt.Println("kkkkkkkk")
// }

// 	u := uint32(32)
// 	i := int32(1)
// 	fmt.Println(&u, &i)
// 	p := &i
// 	fmt.Println(">>",unsafe.Pointer(&u))
// 	p = (*int32)(unsafe.Pointer(&u))
// 	fmt.Println(*p)
// flo := 3.5
// fmt.Println(Float64bits(flo))

p := Person04{Person05{}, true, "putty", 10}

fmt.Println(p)
fmt.Println("SIZE", &(p), &(p.sex), &(p.name), &(p.age))
lang := (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&p)) + 24))
*lang = 20
fmt.Println(p)

// var x struct {
// 	a bool
// 	b string
// 	c bool
// 	b1 bool
// 	c1 bool
// 	d int32
// 	e []int
// }
// fmt.Println("SIZE", &(x),&(x.a),&(x.b),&(x.c),&(x.b1),&(x.c1),&(x.d),&(x.e))
// //Alignof 返回 m，m 是指当类型进行内存对齐时，它分配到的内存地址能整除 m。
// //fmt.Println("ALIGN",unsafe.Alignof(x),unsafe.Alignof(x.a),unsafe.Alignof(x.b),unsafe.Alignof(x.c))
// fmt.Println("OFFSET",0, unsafe.Offsetof(x.a), unsafe.Offsetof(x.b), unsafe.Offsetof(x.c))

// recover()
// a := make([]func(), 3 )
// i := 0
// for ; i < 3; i++ {
//     a[i]= func( ){
//         fmt.Println(i)
// 	}

// }
// defer func(){ fmt.Println("Zzz")}()
// defer func(){ }()
// defer func(){ fmt.Println("Zzz2")}()
// panic("zjjj")

//i = 6
// for _, s := range a {
//     s()
// }

}

func main66() {
// defer func() {

//         fmt.Println(recover())
//         fmt.Printf(">>>%T", recover())
// }()

// fmt.Println(1, nil)
// a := []int{123}
// a[0] = 2

// maps := map[string]interface{}{}

// maps["student4"] = Person04
// maps["student5"] = student5

// fmt.Println("struct to string")
num := Person04{Person05{}, true, "putty", 10}

// if abs, ok := interface{}(num.name).(string); ok {
// 	fmt.Println("zzzzz", abs)
// }
num.printInfo()
v2 := reflect.ValueOf(num)
fmt.Println(">>", v2.Type())

// go func() {
// 	for {
// 	  fmt.Println("goroutine1_print")
// 	}
//   }()

//   // 协程B
//   go func() {
// 	time.Sleep(1 * time.Second)
// 	panic("goroutine2_panic")
//   }()

//   time.Sleep(20 * time.Second)

str := "LUCKY SPIN is wai@ting for YOU! Our players has won more than 1 Lakh totally in LUCKY SPIN today!Your city's player has won 2 Lakh in Poker today, come to WIN BIGGER!"
GetRandomStr(str)
// for i := 1; i< 80; i++ {
// 	fmt.Println(RandInt(3))
// }

x := 11
y := (1 << 0) | (1 << 3) //保证 z 中的第 0 位和第 3 位为 0
z := x &^ y
fmt.Printf("x = %b
", x)
fmt.Println("	&^")
fmt.Printf("y = %b
", y)
fmt.Println("————————")
fmt.Printf("z = %04b
", z)

}

func RandInt(max int) int {
if max <= 1 {
return 1
}
rr := rand.New(rand.NewSource(time.Now().UnixNano() * rand.Int63n(9999)))
return rr.Intn(max) + 1
}

//分隔符@
func GetRandomStr(str string) {
strLs := strings.Split(str, "@")
for k, str := range strLs {
fmt.Println(k, str)
}
fmt.Println(strLs[RandInt(len(strLs))-1])
}

const m0 = 0x5555555555555555 // 01010101 ...
const m1 = 0x3333333333333333 // 00110011 ...
const m2 = 0x0f0f0f0f0f0f0f0f // 00001111 ...
const m3 = 0x00ff00ff00ff00ff // etc.
const m4 = 0x0000ffff0000ffff

func P64(x uint64) {
str := ""
for i := 0; i < 64; i++ {
str = fmt.Sprint(x>>i&1, str)
}
fmt.Println(x, ">>>", str)
}

func P32(x uint64) {
str := ""
for i := 0; i < 32; i++ {
str = fmt.Sprint(x>>i&1, str)
}
fmt.Println(x, ">>>", str)
}

func P16(x uint64) {
str := ""
for i := 0; i < 16; i++ {
str = fmt.Sprint(x>>i&1, str)
}
fmt.Println(x, ">>>", str)
}

func onecnt(x uint64) int {
count := 0
for ; x > 0; x = x & (x - 1) {
count++
}
return count
}

func onetest(x uint64) {
const m = 1<<64 - 1
fmt.Println(x, x&m)

//var s te.StateStr

}

// func (x *StateStr)take() {

// }

func OnesCount64(x uint64) int {
const m = 1<<64 - 1
x = x>>1&(m0&m) + x&(m0&m)
x = x>>2&(m1&m) + x&(m1&m)

x = (x>>4 + x) & (m2 & m)
x += x >> 8
x += x >> 16
x += x >> 32
fmt.Println("==>", m0&m)

return int(x) & (1<<7 - 1)

}

func Abs(n float64) float64 {
return float64bits(bittofloat(n) &^ (1 << 63))
}

func float64bits(n uint64) float64 {
return (float64)(unsafe.Pointer(&n))
}

func bittofloat(n float64) uint64 {
return (uint64)(unsafe.Pointer(&n))
}

func GetFunctionName(i interface{}, seps ...rune) string {
// 获取函数名称
fmt.Println("**>>>>", runtime.FuncForPC(reflect.ValueOf(i).Pointer()))
fn := runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
// 用 seps 进行分割
fields := strings.FieldsFunc(fn, func(sep rune) bool {
for _, s := range seps {
if sep == s {
return true
}
}
return false
})

fmt.Println(fields)
if size := len(fields); size > 0 {
	return fields[size-1]
}
return ""

}

func Println(v uint64) {
P16(v)
}

func getlog(v uint32) uint32 {
v--
v |= v >> 1
v |= v >> 2
v |= v >> 4
v |= v >> 8
v |= v >> 16
v++
v = tab32[(v*0x077CB531)>>27]
return v
}

const digits = "0123456789abcdefghijklmnopqrstuvwxyz"

var tab32 = [32]uint32{
0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9}

func main106() {
uintSize := 32 << (^int64(0) >> 32 & 1)
b := 1e20
fmt.Println(^uint(0), ^uint(0)>>32, (^uint(0) >> 32 & 1), uintSize)

const m = 1<<64 - 1
fmt.Println(b, m>>1&(^int64(0)), OnesCount64(4095), onecnt(4096))
onetest(409)
P16(123)
P16(123 &^ 6)

fmt.Println("name:", GetFunctionName(P16))
// P64(bittofloat(-0.1251234))
// P64(bittofloat(-1))
var pi te.StateStr
pi.Fill()
curT := time.Now()
const sun = iota
fmt.Println(">>>", curT.Nanosecond(), sun, time.Now().UTC())

// 	const char g_math_32[] ={0,1,23,2,29,24,14,3,30,27,25,18,20,15,10,4,31,22,28,13,26,17,19,9,21,12,16,8,11,7,6,5};
// #define LOG2(v) g_math_32[(uint32_t)((v) * 0x7dcd629) >> 27]
fmt.Println(strconv.FormatInt(127, 2))
var un uint64 = 88
un = -un
string_number := 869702343
result := fmt.Sprint(string_number)
fmt.Println(result)
x := 0x077CB531
fmt.Println((x & -x))
fmt.Printf("%T
", result)
fmt.Println("===", digits[1:2], un, bits.TrailingZeros(2), getlog(120), bits.LeadingZeros(1<<60+4641213))

slice := make([]byte, 0)
slice1 := strconv.AppendBool(slice, false)                 // []byte中添加bool类型 （bool-->[]byte）
fmt.Println(string(slice1))                                // false
slice2 := strconv.AppendInt(slice, 123, 2)                 // 2:二进制
fmt.Println(string(slice2))                                // 1111011
slice3 := strconv.AppendFloat(slice, 3.141592, 'f', 4, 64) // 4:保留4位。 64:float64
fmt.Println(string(slice3))                                // 3.1416
slice4 := strconv.AppendQuote(slice, "hello")
fmt.Println(string(slice4), reflect.ValueOf(slice3).Len()) // "hello" (包含双引号)
for k, v := range slice {
	fmt.Println(k, v)
}

}

func requiresQuotes(u string) bool {
// When type URL contains any characters except [0-9A-Za-z./-]*, it must be quoted.
for , ch := range u {
switch {
case ch == '.' || ch == '/' || ch == '':
continue
case '0' <= ch && ch <= '9':
continue
case 'A' <= ch && ch <= 'Z':
continue
case 'a' <= ch && ch <= 'z':
continue
default:
return true
}
}
return false
}

func RandIntervalN(b1, b2 int32, n uint32) []int32 {

if b1 == b2 {
	return []int32{b1}
}

min, max := int64(b1), int64(b2)
if min > max {
	min, max = max, min
}
l := max - min + 1
if int64(n) > l {
	n = uint32(l)
}

r := make([]int32, n)
m := make(map[int32]int32)
for i := uint32(0); i < n; i++ {
	v := int32(rand.Int63n(l) + min)
	//v := int32(Getrand(min, max))
	if mv, ok := m[v]; ok {
		r[i] = mv
	} else {
		r[i] = v
	}

	lv := int32(l - 1 + min)
	if v != lv {
		if mv, ok := m[lv]; ok {
			m[v] = mv
		} else {
			m[v] = lv
		}
	}
	l--
}
return r

}

func RandGroup(p ...uint32) int {
if p == nil {
panic("args not found")
}

r := make([]uint32, len(p))
for i := 0; i < len(p); i++ {
	if i == 0 {
		r[0] = p[0]
	} else {
		r[i] = r[i-1] + p[i]
	}
}

rl := r[len(r)-1]
if rl == 0 {
	return 0
}

rn := uint32(rand.Int63n(int64(rl)))
for i := 0; i < len(r); i++ {
	if rn < r[i] {
		return i
	}
}

panic("bug")

}

func deepCopy(dst, src reflect.Value) {
switch src.Kind() {
case reflect.Interface:
value := src.Elem()
if !value.IsValid() {
return
}
newValue := reflect.New(value.Type()).Elem()
deepCopy(newValue, value)
dst.Set(newValue)
case reflect.Ptr:
value := src.Elem()
if !value.IsValid() {
return
}
dst.Set(reflect.New(value.Type()))
deepCopy(dst.Elem(), value)
case reflect.Map:
dst.Set(reflect.MakeMap(src.Type()))
keys := src.MapKeys()
for _, key := range keys {
value := src.MapIndex(key)
newValue := reflect.New(value.Type()).Elem()
deepCopy(newValue, value)
dst.SetMapIndex(key, newValue)
}
case reflect.Slice:
dst.Set(reflect.MakeSlice(src.Type(), src.Len(), src.Cap()))
for i := 0; i < src.Len(); i++ {
deepCopy(dst.Index(i), src.Index(i))
}
case reflect.Struct:
typeSrc := src.Type()
for i := 0; i < src.NumField(); i++ {
value := src.Field(i)
tag := typeSrc.Field(i).Tag
if value.CanSet() && tag.Get("deepcopy") != "-" {
deepCopy(dst.Field(i), value)
}
}
default:
dst.Set(src)
}
}

func DeepCopy(dst, src interface{}) {
typeDst := reflect.TypeOf(dst)
typeSrc := reflect.TypeOf(src)
if typeDst != typeSrc {
panic("DeepCopy: " + typeDst.String() + " != " + typeSrc.String())
}
if typeSrc.Kind() != reflect.Ptr {
panic("DeepCopy: pass arguments by address")
}

valueDst := reflect.ValueOf(dst).Elem()
valueSrc := reflect.ValueOf(src).Elem()
if !valueDst.IsValid() || !valueSrc.IsValid() {
	panic("DeepCopy: invalid arguments")
}

deepCopy(valueDst, valueSrc)

}

func DeepClone(v interface{}) interface{} {
dst := reflect.New(reflect.TypeOf(v)).Elem()
deepCopy(dst, reflect.ValueOf(v))
return dst.Interface()
}

func Perm(n int) []int {
m := make([]int, n)
for i := 0; i < n; i++ {
j := rand.Intn(i + 1)
m[i] = m[j]
m[j] = i
fmt.Println(i, m[i], ">>", j, m[j])
}
return m
}

func C(sum, lec int) int {
ret := 1
low := 1
for i := 0; i < lec; i++ {
ret *= sum - i
low *= lec - i
}
// str := fmt.Sprint("C(", sum , ",", lec ,")" , ret/low)
// fmt.Println(str)
return ret / low
}

func Clist(para ...int) int {
all := 1
for i := 0; i < len(para); i += 2 {
all *= C(para[i], para[i+1])
}
return all
}

func Csum(para ...[]int) int {
all := 0
for i := 0; i < len(para); i++ {
all += Clist(para[i]...)
}
return all
}

var randseed int64 = 456213

func Getrand(min, max int64) int64 {
randseed = randseed >> 32 << 32
randseed := (1103515245*randseed + 1) % (2<<31 - 1)
fmt.Println(randseed)
if randseed < 0 {
randseed = -randseed
}
return randseed%(max-min+1) + min
}

func checkflo(flo map[int]int) bool {
for k := range flo {
if flo[k+1] > 0 && flo[k+2] > 0 && flo[k+3] > 0 && flo[k+4] > 0 {
return true
}
}
return false
}

func countdz() {
cards := make([]int, 0)
for i := 1; i < 14; i++ {
cards = append(cards, i)
cards = append(cards, i)
cards = append(cards, i)
cards = append(cards, i)
}
allcount := 1000000
count := make(map[string]int)
flocount := 0
for allcount > 0 {
allcount--
rand.Seed(int64(allcount))
selects := RandIntervalN(0, 51, 7)
static := make(map[int]int)
for i := 0; i < len(selects); i++ {
if v, ok := static[cards[selects[i]]]; ok {
static[cards[selects[i]]] = v + 1
} else {
static[cards[selects[i]]] = 1
}
}

	if checkflo(static) {
		flocount++
	}

	chipList := make([]int, 0)
	for _, v := range static {
		chipList = append(chipList, v)
	}
	sort.Ints(chipList)
	arrStr := ""
	for i := 0; i < len(chipList); i++ {
		arrStr += strconv.Itoa(chipList[i])
	}

	if _, ok := count[arrStr]; ok {
		count[arrStr]++
	} else {
		count[arrStr] = 1
	}
}
fmt.Println(">>", count, flocount)

}

type special int32

func main6f() {
// strconv.ParseInt(...) fastest
// strconv.Atoi(...) still very fast
// fmt.Sscanf(...) not terribly fast but most flexible
// pstr := new(Person05)
// pstr.printInfo()
num := -1 << 63
num = num | (1<<63 - 1)
//newnum := (uint64)(unsafe.Pointer(&num))
//P64(newnum)
if requiresQuotes("sadfa32423") {
fmt.Println(">>>>#$%^&(")
}
nums := 3
find:
for {
switch {
case nums > 1:
fmt.Println("gjk")
nums--
case 2 > 1:
fmt.Println("999")
break find
}
}

// int32list := RandIntervalN(1, 10, 10)
// fmt.Println(int32list)

// fmt.Println(RandGroup(1,0,3))
// fmt.Println(Perm(10))
// fmt.Println(1<<0)
// v := Person04{}
// dst := reflect.New(reflect.TypeOf(v)).Elem()
// var picks special = 3
// var picks2 special = 2
// mk := picks + picks2
// fmt.Println(v, dst, mk)
//133784560
for i := 0; i < 100; i++ {
	fmt.Println(Getrand(1, 10))

}
C(13, 7)
C(12, 5)
var arr [][]int = [][]int{
	{52, 7},
	{13, 7}, //1
	{13, 1, 12, 5}, {13, 2, 11, 3}, {13, 3, 10, 1},
	{13, 1, 12, 4}, {13, 2, 11, 1},
	{13, 1, 12, 3},

	{13, 2, 2, 1, 11, 2}, //3+2
	{13, 2, 2, 1, 11, 1},
	{13, 3, 3, 1},
	{13, 2, 2, 1},
	{13, 3, 3, 1},

	{13, 5, 47, 2},
}
fmt.Println(Csum(arr...))
for k, v := range arr {
	fmt.Println(k, ">>", float32(Clist(v...)))
}
fmt.Println("................")

absd := Person05{name: "fdafd"}
fmt.Println(absd.name, 133784560*21014559, math.Abs(1))
dict := make(map[int]int)
fmt.Println("ok0", dict[0])
if _, ok := dict[0]; ok {
	fmt.Println("ok1", dict[0])
}
dict[0] = 0

if _, ok := dict[0]; ok {
	fmt.Println("ok2", dict[0])
}
fmt.Println(dict[0], len(dict))

//countdz()
var s byte = 0

var x interface{} // x 为零值 nil,静态类型为 interface{}
x = 42            //x declared but not used         // x 的值为 42,动态类型为int, 静态类型为interface{}
fmt.Println(x, s)
//var v *T           // v 为零值 nil, 静态类型为 *T
//x = v              // x 的值为 (*T)(nil)， 动态类型为 *T, 静态类型为 *T
arrs := []int{1, 2, 3, 4}
fmt.Println(&arrs[0], &arrs[2])
slice := arrs[0:2]

fmt.Println(slice, &arrs[0], &slice[0], &arrs[2])
slice = append(slice, 8)
slice = append(slice, 9)
slice[0] = 11
slice = append(slice, 7)
slice[0] = 16
fmt.Println(slice, &arrs[0], &slice[0], &slice[2], ">>>", arrs[0], &arrs[2], "====", len(slice), cap(slice))

// bytes := hash.Sum([]byte{1,2,3,5})
// fmt.Println(CreateRandomStr("tomorrow"), hex.EncodeToString([]byte{255,16,16,16}), )

test(func() {
	Exponent(3, 5)
})
test(func() {
	math.Pow(3, 5)
})

tmp := [10]byte{9}
fmt.Println(tmp)

apple := -1
fmt.Println(">>>", apple<<5, maxDepth(128))

}

func maxDepth(n int) int {
var depth int
for i := n; i > 0; i >>= 1 {
depth++
}
return depth * 2
}

func GetSec() int64 {
return time.Now().UnixNano() / 10000000
}

func test(fn func()) {
tnum := GetSec()
for i := 0; i < 10000000; i++ {
fn()
}
fmt.Println(">>>", GetSec()-tnum)
}

func Exponent(a, n int64) int64 {
result := int64(1)
for i := n; i > 0; i >>= 1 {
if i&1 != 0 {
result *= a
}
a *= a
}
return result
}

//生成随机字符串//
func CreateRandomStr(seedStr string) string {
h := md5.New()
seedStr = seedStr + strconv.FormatInt(time.Now().UnixNano(), 10)
fmt.Println(seedStr)
io.WriteString(h, seedStr)
cipherStr := h.Sum(nil)
fmt.Println(cipherStr)
payNum := hex.EncodeToString(cipherStr)
return payNum
}

func saferoutine(c chan bool) {
for i := 0; i < 10; i++ {
fmt.Println("Count:", i)
time.Sleep(1 * time.Second)
}
c <- true
}

func panicgoroutine(c chan bool) {
time.Sleep(5 * time.Second)
panic("Panic, omg ...")
c <- true
}

const MaxRune = 'U0010FFFF'
const RuneError = 'uFFFD'

func TestCancelBeforeGenericEvent() {
fsm := fstate.NewFSM(
"start",
fstate.Events{
{Name: "run", Src: []string{"start"}, Dst: "end"},
},
fstate.Callbacks{
"before_event": func(e *fstate.Event) {
fmt.Println(">>>>")
e.Cancel()
},
},
)
fsm.Event("run")
if fsm.Current() != "start" {
fmt.Println("expected state to be 'start'")
}
}

type Interface interface {
// Len is the number of elements in the collection.
Len() int
// Less reports whether the element with
// index i should sort before the element with index j.
Less(i, j int) bool
// Swap swaps the elements with indexes i and j.
Swap(i, j int)
}

type interf []int

func swapRange(data interf, a, b, n int) {
for i := 0; i < n; i++ {
ab := data[a+i]
data[a+i] = data[b+i]
data[b+i] = ab
}
fmt.Println(a, b, n, ">>>", data)

}

func rotate(data interf, a, m, b int) {
i := m - a
j := b - m

for i != j {
	if i > j {
		swapRange(data, m-i, m, j)
		i -= j
	} else {
		swapRange(data, m-i, m+j-i, i)
		j -= i
	}
}

swapRange(data, m-i, m, i)

}

func Copy(re *Person04) *Person04 {
re2 := *re
return &re2
}

func outs(obj interface{}){

}

func main6() {
// c := make(chan bool, 2)
// go saferoutine(c)
// go panicgoroutine(c)
// for i := 0; i < 2; i++ {
// <-c
// }
// fmt.Println(reflect.TypeOf(MaxRune), RuneError)
// TestCancelBeforeGenericEvent()
// list := make([]int, 8)
// for i:=0 ;i< 8;i++ {
// list[i] = i
// }
// rotate(list, 0, 3, 8)
// fmt.Println(list)

reg1 := regexp.MustCompile("a.c")

buf := "abc azc a7c aac 888 a9c  tac"
result1 := reg1.FindAllStringSubmatch(buf, -1)
fmt.Println("result1 = ", result1)


//目标字符串
searchIn := "John: 2578.34 William: 4567.23 Steve: 5632.18"
pat := "[0-9]+.[0-9]+"          //正则
f := func(s string) string{
    v, _ := strconv.ParseFloat(s, 32)
    return strconv.FormatFloat(v * 2, 'f', 2, 32)
}
if ok, _ := regexp.Match(pat, []byte(searchIn)); ok {
    fmt.Println("Match Found!")
}
re, _ := regexp.Compile(pat)
//将匹配到的部分替换为 "##.#"
str := re.ReplaceAllString(searchIn, "##.#")
fmt.Println(str)
//参数为函数时
str2 := re.ReplaceAllStringFunc(searchIn, f)
fmt.Println(str2)
s := regexp.MustCompile("a{2}").Split("baabaccadaaae", -1)
fmt.Println(s, len(s))
// s: ["", "b", "b", "c", "cadaaae"]

pat = `(((abc.)def.)ghi)`
src := `abc-def-ghi abc+def+ghi`

fmt.Println(regexp.MatchString(pat, src))
// true <nil>

fmt.Println(regexp.QuoteMeta(pat), re.String(),re.SubexpNames())
// (((abc.)def.)ghi)

}