func isUniqueString(s string) bool {
	if len(s) > 256 {
		return false
	}

	unique := make(map[int32]bool)

	for _, v := range s {
		if v > 256 {
			return false
		}
		if _, ok := unique[v]; ok {
			return false
		} else {
			unique[v] = true
		}
	}
	return true
}

var value int32

func SetValue(delta int32) {
	for {
		v := value
		if atomic.CompareAndSwapInt32(&value, v, (v+delta)) {
			break
		}
	}
}

package main

import (
	"fmt"
	"runtime"
	"sync"
)

const N = 28

func main() {
	runtime.GOMAXPROCS(1)
	wg := &sync.WaitGroup{}
	wg.Add(N)
	for i := 0; i < N; i++ {
		go func(m int) {
			defer wg.Done()
			fmt.Printf(`%d%d`,m+1,m+2)
			runtime.Gosched()
		}(i)
		go func(m int) {
			defer wg.Done()
			if m == 26 {
				runtime.Goexit()
			}
			fmt.Printf(`%c%c`, 'A'+m, 'A'+m+1)
		}(i)
		i = i + 1
	}
	wg.Wait()
}

	letter,number := make(chan bool),make(chan bool)
	wait := sync.WaitGroup{}

	go func() {
		i := 1
		for {
			select {
			case <-number:
				fmt.Print(i)
				i++
				fmt.Print(i)
				i++
				letter <- true
				break
			default:
				break
			}
		}
	}()
	wait.Add(1)
	go func(wait *sync.WaitGroup) {
		str := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

		i := 0
		for{
			select {
			case <-letter:
				if i >= strings.Count(str,"")-1 {
					wait.Done()
					return
				}

				fmt.Print(str[i:i+1])
				i++
				if i >= strings.Count(str,"") {
					i = 0
				}
				fmt.Print(str[i:i+1])
				i++
				number <- true
				break
			default:
				break
			}

		}
	}(&wait)
	number<-true
	wait.Wait()

package main

import (
	"fmt"
	"time"
	"sync"
)

type sp interface {
	Out(key string, val interface{})  //存入key /val，如果该key读取的goroutine挂起，则唤醒。此方法不会阻塞，时刻都可以立即执行并返回
	Rd(key string, timeout time.Duration) interface{}  //读取一个key，如果key不存在阻塞，等待key存在或者超时
}


type Item2 struct {
	value interface{}
	ch    chan struct{}
	exist bool
}
type ConcurrentMap struct {
	mapval map[string]*Item2
	rwmutex  *sync.RWMutex
}

func NewConcurrentMap() *ConcurrentMap {
	return &ConcurrentMap{
		mapval: make(map[string]*Item2, 0),
		rwmutex:  new(sync.RWMutex),
	}
}

func (c *ConcurrentMap) Out(key string, val interface{}) {
	c.rwmutex.Lock()
	defer c.rwmutex.Unlock()

	item, ok := c.mapval[key]
	if !ok {
		c.mapval[key] = &Item2{
			value: val,
			exist: true,
		}
		return
	}

	item.value = val
	if !item.exist {
		if item.ch != nil {
			close(item.ch)
			item.ch = nil
		}
	}

	return
}

func (c *ConcurrentMap) Rd(key string, timeout time.Duration) interface{} {
	c.rwmutex.Lock()
	defer c.rwmutex.Unlock()

	item, ok := c.mapval[key]
	if !ok {
		item = &Item2{
			exist: false,
			ch: make(chan struct{}, 1),
		}
		c.mapval[key] = item
	}

	if item.exist {
		return item.value
	}

	select {
	case <-time.After(timeout):
		return nil
	item, _ = c.mapval[key]
	return item.value
}


func main() {
	mapval := NewConcurrentMap()
	mapval.Out("yanglei", "xx")
	mapval.Out("yanglei", "yy")

	fmt.Printf("%v\n", mapval.Rd("yanglei2", 5 * time.Second))
}

  if haystack == needle {
	  return 0
  }

  originIndex := 0
  aimIndex := 0
  nextIndex := 0

  for aimIndex < len(needle) {
	  if originIndex > len(haystack)-1 {
		  return -1
	  }

	  if haystack[originIndex] == needle[aimIndex] {
		  originIndex++
		  aimIndex++
	  } else {
		  nextIndex = originIndex - aimIndex + len(needle)
		  if nextIndex < len(haystack) {
			  offset := strings.LastIndex(needle, string(haystack[nextIndex]))
			  if offset == -1 {
				  originIndex = nextIndex + 1
			  } else {
				  originIndex = nextIndex - offset
			  }

			  aimIndex = 0
		  } else {
			  return -1
		  }
	  }
  }

  return originIndex - aimIndex

func strStrSunday(haystack, needle string) int {
	if haystack == "" {
		return -1
	}
	if needle == "" {
		return 0
	}

	haystackLen := len(haystack)
	needleLen := len(needle)
	i := 0
	for {
		// 先判断剩余字符串的长度是否足够
		if i+needleLen > haystackLen {
			return -1
		}
		// 匹配上之后，直接返回index
		if haystack[i:i+needleLen] == needle {
			return i
		}
		// 判断needle所在位置的下一个占位是否包含在haystack中
		// needle所在位置的下一个占位可能超出haystack的长度
		if i+needleLen == haystackLen {
			return -1
		}
		//lastIdx := strings.LastIndex(needle, string(haystack[i+needleLen]))
		lastIdx := -1
		for j := needleLen - 1; j >= 0; j-- {
			if haystack[i+needleLen] == needle[j] {
				lastIdx = j
				break
			}
		}
		// 根据lastIdx结果进行不同的移位
		if lastIdx >= 0 {
			i += needleLen - lastIdx
		} else {
			i += needleLen + 1
		}
	}
}

func bubbleSort(arr []int) []int {
	if len(arr) == 0 {
		return arr
	}
	n := len(arr)
	for i := 0; i < n-1; i++ {
		for j := 0; j < n-1-i; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
	}
	return arr
}

  for i := 0; i < len(nums); i++ {
	  l := i+1
	  r := len(nums) - 1
	  for l < r {
		  current := nums[i] + nums[l] + nums[r]
		  if math.Abs(float64(sum - target)) > math.Abs(float64(target - current)) {
			  sum = current
		  }
		  if current < target {
			  l++
		  } else if current == target {
			  return target
		  } else {
			  r--
		  }
	  }
  }
  return sum

func isUniqueString2(s string) bool {
	if strings.Count(s,"") > 3000{
		return  false
	}
	for i, v := range s {
		if v > 127 {
			return false
		}
		if i != strings.LastIndex(s,string(v)) {
			return false
		}
	}
	return true
}

item, ok := c.mapval[key]
if !ok {
	c.mapval[key] = &Item2{
		value: val,
		exist: true,
	}
	return
}

item.value = val
if !item.exist {
	if item.ch != nil {
		close(item.ch)
		item.ch = nil
	}
}

return

item, ok := c.mapval[key]
if !ok {
	item = &Item2{
		exist: false,
		ch: make(chan struct{}, 1),
	}
	c.mapval[key] = item
}

if item.exist {
	return item.value
}

select {
case <-time.After(timeout):
	return nil
case <-item.ch:
}

item, _ = c.mapval[key]
return item.value

func reverseString(s string) (string, bool) {
  str := []rune(s)
  l := len(str)
  if l > 5000 {
    return "", false
  }
  for i := 0 ; i < l/2; i++ {
    str[i] = str[l-i-1] - str[i]
	str[l-i-1] = str[l-i-1] - str[i]
	str[i] = str[i] + str[l-i-1]
  }
  return string(str), true
}

func (m *Map) Rd(key string, timeout time.Duration) interface{} {
	e, ok := m.c[key]
	if !ok {
		// create channel
		m.c[key] = &entry{
			isExist: false,
			ch:      make(chan struct{}),
		}
	}
	// 阻塞
	e, _ = m.c[key]
	if e.ch != nil {
		select {
		case <-e.ch:
		case <-time.After(timeout):
		}
	}
	return m.c[key].value
}