Programming-Idioms.org

fmt.Println("Hello World")

for i := 0; i < 10; i++ {
	fmt.Println("Hello")
}

fmt.Println(strings.Repeat("Hello\n", 10))

for range 10 {
	fmt.Println("Hello")
}

func finish(name string) {
  fmt.Println("My job here is done. Good bye " + name)
}

finish := func(name string) {
	fmt.Println("My job here is done. Good bye " + name)
}

func square(x int) int {
  return x*x
}

type Point struct {
    x, y float64
}

for _, x := range items {
    doSomething(x)
}

for i, x := range items {
    fmt.Printf("Item %d = %v \n", i, x)
}

x := map[string]int {"one": 1, "two": 2}

type BinTree struct {
	Label       valueType
	Left, Right *BinTree
}

type BinTree[L any] struct {
	Label       L
	Left, Right *BinTree[L]
}

for i := range x {
	j := rand.Intn(i + 1)
	x[i], x[j] = x[j], x[i]
}

y := make([]T, len(x))
perm := rand.Perm(len(x))
for i, v := range perm {
	y[v] = x[i]
}

rand.Shuffle(len(x), func(i, j int) {
	x[i], x[j] = x[j], x[i]
})

for i := len(x) - 1; i > 0; i-- {
	j := rand.Intn(i + 1)
	x[i], x[j] = x[j], x[i]
}

func shuffle[T any](x []T) {
	rand.Shuffle(len(x), func(i, j int) {
		x[i], x[j] = x[j], x[i]
	})
}

x[rand.Intn(len(x))]

func pickT(x []T) T {
	return x[rand.Intn(len(x))]
}

func pick[T any](x []T) T {
	return x[rand.Intn(len(x))]
}

func Contains(list []T, x T) bool {
	for _, item := range list {
		if item == x {
			return true
		}
	}
	return false
}

slices.Contains(list, x)

for k, x := range mymap {
  fmt.Println("Key =", k, ", Value =", x)
}

func pick(a, b  float64)  float64 {
	return a + (rand.Float64() * (b-a))
}

func pick(a,b int) int {
	return a + rand.Intn(b-a+1)
}

func pick(a, b int) int {
	return a + rand.IntN(b-a+1)
}

func (bt *BinTree) Dfs(f func(*BinTree)) {
	if bt == nil {
		return
	}
	bt.Left.Dfs(f)
	f(bt)
	bt.Right.Dfs(f)
}

func (bt *BinTree[L]) Dfs(f func(*BinTree[L])) {
	if bt == nil {
		return
	}
	bt.Left.Dfs(f)
	f(bt)
	bt.Right.Dfs(f)
}

type Tree struct {
	Key keyType
	Deco valueType
	Children []*Tree
}

type Tree[L any] struct {
	Label    L
	Children []*Tree[L]
}

func (t *Tree) Dfs(f func(*Tree)) {
	if t == nil {
		return
	}
	f(t)
	for _, child := range t.Children {
		child.Dfs(f)
	}
}

func (t *Tree[L]) Dfs(f func(*Tree[L])) {
	if t == nil {
		return
	}
	f(t)
	for _, child := range t.Children {
		child.Dfs(f)
	}
}

for i, j := 0, len(x)-1; i < j; i, j = i+1, j-1 {
	x[i], x[j] = x[j], x[i]
}

func reverse[T any](x []T) {
	for i, j := 0, len(x)-1; i < j; i, j = i+1, j-1 {
		x[i], x[j] = x[j], x[i]
	}
}

slices.Reverse(x)

func search(m [][]int, x int) (bool, int, int) {
	for i := range m {
		for j, v := range m[i] {
			if v == x {
				return true, i, j
			}
		}
	}
	return false, 0, 0
}

a, b = b, a

i, err  := strconv.Atoi(s) 

i, err := strconv.ParseInt(s, 10, 0)

s := fmt.Sprintf("%.2f", x)

s := "ネコ"

go func() {
	v := <-ch
	fmt.Printf("Hello, %v\n", v)
}()

ch <- "Alan"

const m, n = 3, 4
var x [m][n]float64

func make2D(m, n int) [][]float64 {
	buf := make([]float64, m*n)

	x := make([][]float64, m)
	for i := range x {
		x[i] = buf[:n:n]
		buf = buf[n:]
	}
	return x
}

func make2D[T any](m, n int) [][]T {
	buf := make([]T, m*n)

	x := make([][]T, m)
	for i := range x {
		x[i] = buf[:n:n]
		buf = buf[n:]
	}
	return x
}

const m, n, p = 2, 2, 3
var x [m][n][p]float64

func make3D(m, n, p int) [][][]float64 {
	buf := make([]float64, m*n*p)

	x := make([][][]float64, m)
	for i := range x {
		x[i] = make([][]float64, n)
		for j := range x[i] {
			x[i][j] = buf[:p:p]
			buf = buf[p:]
		}
	}
	return x
}

func make3D[T any](m, n, p int) [][][]T {
	buf := make([]T, m*n*p)

	x := make([][][]T, m)
	for i := range x {
		x[i] = make([][]T, n)
		for j := range x[i] {
			x[i][j] = buf[:p:p]
			buf = buf[p:]
		}
	}
	return x
}

type ItemPSorter []Item
func (s ItemPSorter) Len() int{ return len(s) }
func (s ItemPSorter) Less(i,j int) bool{ return s[i].p<s[j].p }
func (s ItemPSorter) Swap(i,j int) { s[i],s[j] = s[j],s[i] }

func sortItems(items []Item){
	sorter := ItemPSorter(items)
	sort.Sort(sorter)
}

less := func(i, j int) bool {
	return items[i].p < items[j].p
}
sort.Slice(items, less)

compare := func(a, b Item) int {
	return cmp.Compare(a.p, b.p)
}
slices.SortFunc(items, compare)

items = append(items[:i], items[i+1:]...)

copy(items[i:], items[i+1:])
items[len(items)-1] = nil
items = items[:len(items)-1]

items = slices.Delete(items, i, i+1)

wg := sync.WaitGroup{}
wg.Add(1000)
for i := 1; i <= 1000; i++ {
	go func(j int) {
          f(j)
          wg.Done()
        }(i)
}
wg.Wait()

func f(i int) int {
  if i == 0 {
    return 1
  }
  return i * f(i-1)
}

func exp(x, n int) int {
	switch {
	case n == 0:
		return 1
	case n == 1:
		return x
	case n%2 == 0:
		return exp(x*x, n/2)
	default:
		return x * exp(x*x, (n-1)/2)
	}
}

var lock sync.Mutex

lock.Lock()
x = f(x)
lock.Unlock()

x := make(map[T]bool)

x := make(map[T]struct{})

func compose(f func(A) B, g func(B) C) func(A) C {
	return func(x A) C {
		return g(f(x))
	}
}

func composeIntFuncs(f func(int) int, g func(int) int) func(int) int {
	return func(x int) int {
		return g(f(x))
	}
}

func compose[T, U, V any](f func(T) U, g func(U) V) func(T) V {
	return func(x T) V {
		return g(f(x))
	}
}

type PayFactory func(Company, *Employee, *Employee) Payroll

type CustomPayFactory func(*Employee) Payroll

func CurryPayFactory(pf PayFactory,company Company, boss *Employee) CustomPayFactory {
	return func(e *Employee) Payroll {
		return pf(company, boss, e)
	}
}

t := string([]rune(s)[i:j])

ok := strings.Contains(s, word)

type Vertex struct{
	Id int
	Label string
	Neighbours map[*Vertex]bool
}

type Graph []*Vertex

type Graph[L any] []*Vertex[L]

type Vertex[L any] struct {
	Label      L
	Neighbours map[*Vertex[L]]bool
}

runes := []rune(s)
for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
   runes[i], runes[j] = runes[j], runes[i]
}
t := string(runes)

func reverse(s string) string {
	if len(s) <= 1 {
		return s
	}
	var b strings.Builder
	b.Grow(len(s))
	for len(s) > 0 {
		r, l := utf8.DecodeLastRuneInString(s)
		s = s[:len(s)-l]
		b.WriteRune(r)
	}
	return b.String()
}

runes := []rune(s)
slices.Reverse(runes)
t := string(runes)

mainloop:
	for _, v := range a {
		for _, w := range b {
			if v == w {
				continue mainloop
			}
		}
		fmt.Println(v)
	}

mainloop:
	for i, line := range m {
		for _, v := range line {
			if v < 0 {
				fmt.Println(v)
				break mainloop
			}
		}
	}

s = append(s, 0)
copy(s[i+1:], s[i:])
s[i] = x

s = slices.Insert(s, i, x)

time.Sleep(5 * time.Second)

t := s
r := []rune(s)
if len(r) > 5 {
	t = string(r[:5])
}

i := 0
count := 0
for i = range s {
	if count >= 5 {
		break
	}
	count++
}
t := s
if count >= 5 {
	t = s[:i]
}

t := s
r := []rune(s)
if len(r) > 5 {
	t = string(r[len(r)-5:])
}

i := len(s)
for j := 0; i > 0 && j < 5; j++ {
	_, size := utf8.DecodeLastRuneInString(s[0:i])
	i -= size
}
t := s[i:]

s := `Huey
Dewey
Louie`

chunks := strings.Split(s, " ")

chunks := strings.Fields(s)

for {
	// Do something
}

_, ok := m[k]

func containsValue(m map[K]T, v T) bool {
	for _, x := range m {
		if x == v {
			return true
		}
	}
	return false
}

func containsValue[M ~map[K]V, K, V comparable](m M, v V) bool {
	for _, x := range m {
		if x == v {
			return true
		}
	}
	return false
}

y := strings.Join(x, ", ")

s := 0
for _, v := range x {
	s += v
}

s := strconv.Itoa(i)

s := strconv.FormatInt(i, 10)

s := fmt.Sprintf("%d", i)

var wg sync.WaitGroup
wg.Add(1000)
for i := 1; i <= 1000; i++ {
	go func(i int) {
		f(i)
		wg.Done()
	}(i)
}
wg.Wait()
fmt.Println("Finished")

y := make([]T, 0, len(x))
for _, v := range x{
	if p(v){
		y = append(y, v)
	}
}

n := 0
for _, v := range x {
	if p(v) {
		n++
	}
}
y := make([]T, 0, n)
for _, v := range x {
	if p(v) {
		y = append(y, v)
	}
}

func filter[S ~[]T, T any](x S, p func(T) bool) S {
	var y S
	for _, v := range x {
		if p(v) {
			y = append(y, v)
		}
	}
	return y
}

del := func(t *T) bool { return !p(t) }

y := slices.DeleteFunc(slices.Clone(x), del)

b, err := os.ReadFile(f)
if err != nil {
	// Handle error...
}
lines := string(b)

fmt.Fprintln(os.Stderr, x, "is negative")

x := os.Args[1]

d := time.Now()

i := strings.Index(x, y)

x2 := strings.Replace(x, y, z, -1)

x2 := strings.ReplaceAll(x, y, z)

x := new(big.Int)
x.Exp(big.NewInt(3), big.NewInt(247), nil)

s := fmt.Sprintf("%.1f%%", 100.0*x)

nb := big.NewInt(int64(n))
var z big.Int
z.Exp(x, nb, nil)

z := new(big.Int)
z.Binomial(n, k)

var x *big.Int = new(big.Int)

x := make([]bool, n)

x := make([]uint64, (n+63)/64)

r := rand.New(rand.NewSource(s))

r := rand.New(rand.NewPCG(s, s))

r := rand.New(rand.NewSource(time.Now().UnixNano()))

func main() {
    fmt.Println(strings.Join(os.Args[1:], " "))
}

type ParentFactory func(string) Parent

var fact ParentFactory = func(str string) Parent {
	return Parent{
		name: str,
	}
}

x.GCD(nil, nil, a, b)

gcd.GCD(nil, nil, a, b)
x.Div(a, gcd).Mul(x, b)

s := strconv.FormatInt(x, 2)

s := fmt.Sprintf("%b", x)

x := 3i - 2
x *= 1i

for{
   someThing()
   someOtherThing()
   if !c {
     break
   }
}

for done := false; !done; {
	someThing()
	someOtherThing()
	done = !c()
}

y := float64(x)

y := int(x)

y := int(math.Floor(x + 0.5))

x := strings.Count(s, t)

r := regexp.MustCompile("htt+p")

func PopCountUInt64(i uint64) (c int) {
	i -= (i >> 1) & 0x5555555555555555
	i = (i>>2)&0x3333333333333333 + i&0x3333333333333333
	i += i >> 4
	i &= 0x0f0f0f0f0f0f0f0f
	i *= 0x0101010101010101
	return int(i >> 56)
}

func PopCountUInt32(i uint32) (n int) {
	i -= (i >> 1) & 0x55555555
	i = (i>>2)&0x33333333 + i&0x33333333
	i += i >> 4
	i &= 0x0f0f0f0f
	i *= 0x01010101
	return int(i >> 24)
}

c := bits.OnesCount(i)

func addingWillOverflow(x int, y int) bool {
	if x > 0 {
		return y > math.MaxInt-x
	}
	return y < math.MinInt-x
}

func multiplyWillOverflow(x, y uint64) bool {
   if x <= 1 || y <= 1 {
     return false
   }
   d := x * y
   return d/y != x
}

os.Exit(0)

buf := make([]byte, 1_000_000)

return nil, fmt.Errorf("invalid value for x: %v", x)

type Foo struct {
	x int
}

func (f *Foo) X() int {
	return f.x
}

buffer, err := os.ReadFile("data.json")
if err != nil {
	return err
}
err = json.Unmarshal(buffer, &x)
if err != nil {
	return err
}

r, err := os.Open(filename)
if err != nil {
	return err
}
decoder := json.NewDecoder(r)
err = decoder.Decode(&x)
if err != nil {
	return err
}

buffer, err := json.MarshalIndent(x, "", "  ")
if err != nil {
	return err
}
err = os.WriteFile("data.json", buffer, 0644)

func control(f func()) {
	f()
}

fmt.Println(reflect.TypeOf(x))

fmt.Printf("%T", x)

info, err := os.Stat(path)
if err != nil {
	return err
}
x := info.Size()

b := strings.HasPrefix(s, prefix)

b := strings.HasSuffix(s, suffix)

d := time.Unix(ts, 0)

x := d.Format("2006-01-02")

type ItemCSorter []Item
func (s ItemCSorter) Len() int           { return len(s) }
func (s ItemCSorter) Less(i, j int) bool { return c(s[i], s[j]) }
func (s ItemCSorter) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func sortItems(items []Item) {
	sorter := ItemCSorter(items)
	sort.Sort(sorter)
}

type ItemsSorter struct {
	items []Item
	c     func(x, y Item) bool
}

func (s ItemsSorter) Len() int           { return len(s.items) }
func (s ItemsSorter) Less(i, j int) bool { return s.c(s.items[i], s.items[j]) }
func (s ItemsSorter) Swap(i, j int)      { s.items[i], s.items[j] = s.items[j], s.items[i] }

func sortItems(items []Item, c func(x, y Item) bool) {
	sorter := ItemsSorter{
		items,
		c,
	}
	sort.Sort(sorter)
}

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

slices.SortFunc(items, c)

res, err := http.Get(u)
if err != nil {
	return err
}
buffer, err := io.ReadAll(res.Body)
res.Body.Close()
if err != nil {
	return err
}
s := string(buffer)

out, err := os.Create("result.txt")
if err != nil {
	return err
}
defer out.Close()

resp, err := http.Get(u)
if err != nil {
	return err
}
defer func() {
	io.Copy(io.Discard, resp.Body)
	resp.Body.Close()
}()
if resp.StatusCode != 200 {
	return fmt.Errorf("Status: %v", resp.Status)
}

_, err = io.Copy(out, resp.Body)
if err != nil {
	return err
}

buffer, err := os.ReadFile("data.xml")
if err != nil {
	return err
}
err = xml.Unmarshal(buffer, &x)
if err != nil {
	return err
}

buffer, err := xml.MarshalIndent(x, "", "  ")
if err != nil {
	return err
}
err = os.WriteFile("data.xml", buffer, 0644)

path := os.Args[0]
s = filepath.Base(path)

path, err := os.Executable()
if err != nil {
  panic(err)
}
s = filepath.Base(path)

dir, err := os.Getwd()

programPath := os.Args[0]
absolutePath, err := filepath.Abs(programPath)
if err != nil {
	return err
}
dir := filepath.Dir(absolutePath)

var t T
tType := reflect.TypeOf(t)
n := tType.Size()

blank := strings.TrimSpace(s) == ""

err := exec.Command("x", "a", "b").Run()

keys := make([]string, 0, len(mymap))
for k := range mymap {
	keys = append(keys, k)
}
sort.Strings(keys)

for _, k := range keys {
	x := mymap[k]
	fmt.Println("Key =", k, ", Value =", x)
}

keys := maps.Keys(mymap)
slices.Sort(keys)

for _, k := range keys {
	x := mymap[k]
	fmt.Println("Key =", k, ", Value =", x)
}

keys := maps.Keys(mymap)
slices.SortFunc(keys, compare)

for _, k := range keys {
	x := mymap[k]
	fmt.Println("Key =", k, ", Value =", x)
}

type entry struct {
	key   string
	value int
}

type entries []entry
func (list entries) Len() int { return len(list) }
func (list entries) Less(i, j int) bool { return list[i].value < list[j].value }
func (list entries) Swap(i, j int) { list[i], list[j] = list[j], list[i] }

entries := make(entries, 0, len(mymap))
for k, x := range mymap {
	entries = append(entries, entry{key: k, values: x})
}
sort.Sort(entries)

for _, e := range entries {
	fmt.Println("Key =", e.key, ", Value =", e.value)
}

type entry struct {
	key   string
	value int
}

entries := make([]entry, 0, len(mymap))
for k, x := range mymap {
	entries = append(entries, entry{key: k, value: x})
}
sort.Slice(entries, func(i, j int) bool {
	return entries[i].value < entries[j].value
})

for _, e := range entries {
	fmt.Println("Key =", e.key, ", Value =", e.value)
}

b := reflect.DeepEqual(x, y)

b := d1.Before(d2)

s2 := strings.Replace(s1, w, "", -1)

s2 := strings.ReplaceAll(s1, w, "")

n := len(x)

y := make(map[T]struct{}, len(x))
for _, v := range x {
	y[v] = struct{}{}
}

func sliceToSet[T comparable](x []T) map[T]struct{} {
	y := make(map[T]struct{}, len(x))
	for _, v := range x {
		y[v] = struct{}{}
	}
	return y
}

y := make(map[T]struct{}, len(x))
for _, v := range x {
	y[v] = struct{}{}
}
x2 := make([]T, 0, len(y))
for _, v := range x {
	if _, ok := y[v]; ok {
		x2 = append(x2, v)
		delete(y, v)
	}
}
x = x2

seen := make(map[T]bool)
j := 0
for _, v := range x {
	if !seen[v] {
		x[j] = v
		j++
		seen[v] = true
	}
}
x = x[:j]

seen := make(map[T]bool)
j := 0
for _, v := range x {
	if !seen[v] {
		x[j] = v
		j++
		seen[v] = true
	}
}
for i := j; i < len(x); i++ {
	x[i] = nil
}
x = x[:j]

func deduplicate[S ~[]T, T comparable](x S) S {
	seen := make(map[T]bool)
	j := 0
	for _, v := range x {
		if !seen[v] {
			x[j] = v
			j++
			seen[v] = true
		}
	}
	var zero T
	for i := j; i < len(x); i++ {
		// Avoid memory leak
		x[i] = zero
	}
	return x[:j]
}

slices.Sort(x)
x = slices.Compact(x)

_, err := fmt.Scan(&n)

_, err := fmt.Scanf("%d", &n)

ServerAddr,err := net.ResolveUDPAddr("udp",p)
if err != nil {
	return err
}
ServerConn, err := net.ListenUDP("udp", ServerAddr)
if err != nil {
	return err
}
defer ServerConn.Close()
n,addr,err := ServerConn.ReadFromUDP(b[:1024])
if err != nil {
	return err
}
if n<1024 {
	return fmt.Errorf("Only %d bytes could be read.", n)
}

type Suit int

const (
  Spades Suit = iota
  Hearts
  Diamonds
  Clubs
)

if !isConsistent() {
	panic("State consistency violated")
}

func binarySearch(a []T, x T) int {
	imin, imax := 0, len(a)-1
	for imin <= imax {
		imid := imin + (imax-imin) / 2
		switch {
		case a[imid] == x:
			return imid
		case a[imid] < x:
			imin = imid + 1
		default:
			imax = imid - 1
		}
	}
	return -1
}

func binarySearch(a []int, x int) int {
	i := sort.SearchInts(a, x)
	if i < len(a) && a[i] == x {
		return i
	}
	return -1
}

func binarySearch(a []T, x T) int {
	f := func(i int) bool { return a[i] >= x }
	i := sort.Search(len(a), f)
	if i < len(a) && a[i] == x {
		return i
	}
	return -1
}

func binarySearch(a []T, x T) int {
	if i, ok := slices.BinarySearch(a, x); ok {
		return i
	} else {
		return -1
	}
}

t1 := time.Now()
foo()
t := time.Since(t1)
ns := int64(t / time.Nanosecond)
fmt.Printf("%dns\n", ns)

t1 := time.Now()
foo()
t := time.Since(t1)
ns := t.Nanoseconds()
fmt.Printf("%dns\n", ns)

func foo() (string, bool) {
	return "Too good to be", true
}

//go:embed foobody.txt
var s string

func (root *Tree) Bfs(f func(*Tree)) {
	if root == nil {
		return
	}
	queue := []*Tree{root}
	for len(queue) > 0 {
		t := queue[0]
		queue = queue[1:]
		f(t)
		queue = append(queue, t.Children...)
	}
}

func (start *Vertex) Bfs(f func(*Vertex)) {
	queue := []*Vertex{start}
	seen := map[*Vertex]bool{start: true}
	for len(queue) > 0 {
		v := queue[0]
		queue = queue[1:]
		f(v)
		for next, isEdge := range v.Neighbours {
			if isEdge && !seen[next] {
				queue = append(queue, next)
				seen[next] = true
			}
		}
	}
}

func (v *Vertex) Dfs(f func(*Vertex), seen map[*Vertex]bool) {
	seen[v] = true
	f(v)
	for next, isEdge := range v.Neighbours {
		if isEdge && !seen[next] {
			next.Dfs(f, seen)
		}
	}
}

func (v *Vertex[L]) Dfs(f func(*Vertex[L]), seen map[*Vertex[L]]bool) {
	seen[v] = true
	f(v)
	for next, isEdge := range v.Neighbours {
		if isEdge && !seen[next] {
			next.Dfs(f, seen)
		}
	}
}

switch {
case c1:
	f1()
case c2:
	f2()
case c3:
	f3()
}

func clock(f func()) time.Duration {
	t := time.Now()
	f()
	return time.Since(t)
}

lowerS, lowerWord := strings.ToLower(s), strings.ToLower(word)
ok := strings.Contains(lowerS, lowerWord)

items := []T{a, b, c}

for i, y := range items {
	if y == x {
		items = append(items[:i], items[i+1:]...)
		break
	}
}

for i, y := range items {
	if y == x {
		copy(items[i:], items[i+1:])
		items[len(items)-1] = nil
		items = items[:len(items)-1]
		break
	}
}

func removeFirstByValue[S ~[]T, T comparable](items *S, x T) {
	for i, y := range *items {
		if y == x {
			*items = slices.Delete(*items, i, i+1)
			return
		}
	}
}

func removeFirstByValue[S ~[]T, T comparable](items *S, x T) {
	if i := slices.Index(*items, x); i != -1 {
		*items = slices.Delete(*items, i, i+1)
	}
}

items2 := make([]T, 0, len(items))
for _, v := range items {
	if v != x {
		items2 = append(items2, v)
	}
}

j := 0
for i, v := range items {
	if v != x {
		items[j] = items[i]
		j++
	}
}
items = items[:j]

j := 0
for i, v := range items {
	if v != x {
		items[j] = items[i]
		j++
	}
}
for k := j; k < len(items); k++ {
	items[k] = nil
}
items = items[:j]

func removeAll[S ~[]T, T comparable](items *S, x T) {
	j := 0
	for i, v := range *items {
		if v != x {
			(*items)[j] = (*items)[i]
			j++
		}
	}
	var zero T
	for k := j; k < len(*items); k++ {
		(*items)[k] = zero
	}
	*items = (*items)[:j]
}

items = slices.DeleteFunc(items, func(e T) bool {
	return e == x
})

b := true
for _, c := range s {
	if c < '0' || c > '9' {
		b = false
		break
	}
}

isNotDigit := func(c rune) bool { return c < '0' || c > '9' }
b := strings.ContainsFunc(s, isNotDigit) 

tmpfile, err := os.CreateTemp("", "")

dir, err := os.MkdirTemp("", "")

delete(m, k)

for _, v := range items1 {
	fmt.Println(v)
}
for _, v := range items2 {
	fmt.Println(v)
}

s := strconv.FormatInt(x, 16)

s := fmt.Sprintf("%x", x)

for i := 0; i < len(items1) || i < len(items2); i++ {
	if i < len(items1) {
		fmt.Println(items1[i])
	}
	if i < len(items2) {
		fmt.Println(items2[i])
	}
}

for i := range min(len(items1), len(items2)) {
	fmt.Println(items1[i])
	fmt.Println(items2[i])

}

_, err := os.Stat(fp)
b := !os.IsNotExist(err)

log.Println(msg)

f, err := strconv.ParseFloat(s, 64)

re := regexp.MustCompile("[[:^ascii:]]")
t := re.ReplaceAllLiteralString(s, "")

t := strings.Map(func(r rune) rune {
	if r > unicode.MaxASCII {
		return -1
	}
	return r
}, s)

var ints []int
s := bufio.NewScanner(os.Stdin)
s.Split(bufio.ScanWords)
for s.Scan() {
	i, err := strconv.Atoi(s.Text())
	if err == nil {
		ints = append(ints, i)
	}
}
if err := s.Err(); err != nil {
	return err
}

p = strings.TrimSuffix(p, "/")

sep := fmt.Sprintf("%c", os.PathSeparator)
p = strings.TrimSuffix(p, sep)

sep := fmt.Sprintf("%c", filepath.Separator)
p = strings.TrimSuffix(p, sep)

s := fmt.Sprintf("%c", c)

t := fmt.Sprintf("%s%d", s, i)

t := s + strconv.Itoa(i)

r1, _ := strconv.ParseInt(c1[1:3], 16, 0)
r2, _ := strconv.ParseInt(c2[1:3], 16, 0)
r := (r1 + r2) / 2

g1, _ := strconv.ParseInt(c1[3:5], 16, 0)
g2, _ := strconv.ParseInt(c2[3:5], 16, 0)
g := (g1 + g2) / 2

b1, _ := strconv.ParseInt(c1[5:7], 16, 0)
b2, _ := strconv.ParseInt(c2[5:7], 16, 0)
b := (b1 + b2) / 2

c := fmt.Sprintf("#%02X%02X%02X", r, g, b)

var buf [7]byte
buf[0] = '#'
for i := 0; i < 3; i++ {
	sub1 := c1[1+2*i : 3+2*i]
	sub2 := c2[1+2*i : 3+2*i]
	v1, _ := strconv.ParseInt(sub1, 16, 0)
	v2, _ := strconv.ParseInt(sub2, 16, 0)
	v := (v1 + v2) / 2
	sub := fmt.Sprintf("%02X", v)
	copy(buf[1+2*i:3+2*i], sub)
}
c := string(buf[:])

err := os.Remove(filepath)

s := fmt.Sprintf("%03d", i)

const planet = "Earth"

y := make([]T, k)
perm := rand.Perm(len(x))
for i, v := range perm[:k] {
	y[i] = x[v]
}

type Trie struct {
	c        rune
	children map[rune]*Trie
	isEntry  bool
	value    V
}

if strconv.IntSize==32 {
	f32()
}
if strconv.IntSize==64 {
	f64()
}

for i := range elements {
	elements[i] *= c
}

var b = flag.Bool("b", false, "Do bat")
var f = flag.Bool("f", false, "Do fox")

func main() {
	flag.Parse()
	if *b {
		bar()
	}
	if *f {
		fox()
	}
}

for i := 0; i+1 < len(list); i += 2 {
	fmt.Println(list[i], list[i+1])
}

b := open.Start(s) == nil

var err error
switch runtime.GOOS {
case "linux":
	err = exec.Command("xdg-open", s).Start()
case "windows":
	err = exec.Command("rundll32", "url.dll,FileProtocolHandler", s).Start()
case "darwin":
	err = exec.Command("open", s).Start()
default:
	err = fmt.Errorf("unsupported platform")
}
b := err == nil

x := items[len(items)-1]

ab := append(a, b...)

var ab []T
ab = append(append(ab, a...), b...)

ab := make([]T, len(a)+len(b))
copy(ab, a)
copy(ab[len(a):], b)

t := strings.TrimPrefix(s, p)

t := strings.TrimSuffix(s, w)

n := utf8.RuneCountInString(s)

n := len(mymap)

s = append(s, x)

m[k] = v

p := message.NewPrinter(language.English)
s := p.Sprintf("%d\n", 1000)

response, err := http.Post(u, contentType, body)

response, err := http.PostForm(u, formValues)

s := hex.EncodeToString(a)

s := fmt.Sprintf("%x", a)

a, err := hex.DecodeString(s)
if err != nil {
	log.Fatal(err)
}

L := []string{}
err := filepath.Walk(D, func(path string, info os.FileInfo, err error) error {
	if err != nil {
		fmt.Printf("failure accessing a path %q: %v\n", path, err)
		return err
	}
	for _, ext := range []string{".jpg", ".jpeg", ".png"} {
		if strings.HasSuffix(path, ext) {
			L = append(L, path)
			break
		}
	}
	return nil
})

p := image.Pt(x, y)
r := image.Rect(x1, y1, x2, y2)
b := p.In(r)

c := image.Pt((x1+x2)/2, (y1+y2)/2)

x, err := os.ReadDir(d)

package main

import "fmt"

func main() {
	fmt.Printf("%s%c%s%c\n", s, 0x60, s, 0x60)
}

var s = `package main

import "fmt"

func main() {
	fmt.Printf("%s%c%s%c\n", s, 0x60, s, 0x60)
}

var s = `

req, err := http.NewRequest("PUT", u, body)
if err != nil {
	return err
}
req.Header.Set("Content-Type", contentType)
req.ContentLength = contentLength
response, err := http.DefaultClient.Do(req)

t := time.Now().Add(24 * time.Hour).Format("2006-01-02")

timer := time.AfterFunc(
	30*time.Second,
	func() {
		f(42)
	})

go func() {
	time.Sleep(30 * time.Second)
	f(42)
}()

os.Exit(0)

defer os.Exit(0)

c := new(mat.Dense)
c.Mul(a, b)

var y []Result
for _, e := range x {
	if P(e) {
		y = append(y, T(e))
	}
}

// void foo(double *a, int n);
// double a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
import "C"

C.foo(C.a, 10)

for _, v := range a {
	if v > x {
		f()
		break
	}
}

if slices.ContainsFunc(a, func(i int) bool {
	return i > x
}) {
	f()
}

a, _, err := big.ParseFloat("123456789.123456789123465789", 10, 200, big.ToZero)

func foo(a [][]int) {
	fmt.Println("array is ", len(a)[0], " x ", len(a))
	x := 0
	for i, v1 := range a {
		for j, v2 := range v1 {
			x += v2*(i+1)*(j+1)
		}
	}
	fmt.Println("result: ", x)
}

func readLines(path string) ([]string, error) {
	b, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}
	lines := strings.Split(string(b), "\n")
	return lines, nil
}

func readLines(path string) ([][]byte, error) {
	b, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}
	lines := bytes.Split(b, []byte{'\n'})
	return lines, nil
}

os.Exit(x)

err := os.Truncate(F, position)

h := math.Hypot(x, y)

func Euclidean(data []float64) float64 {
	n := 0.0
	for _, val := range data {
		n += val * val
	}
	return math.Sqrt(n)

var s float64
for _, d := range data {
	s += math.Pow(d, 2)
}

m, s := stat.MeanStdDev(data, nil)