package main

import "fmt"

func main() {
    // Initializing a slice.
    s := make([]string, 3)
    fmt.Println("emp:", s)

    // Setting and getting values by index.
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

    // len returns the length of the slice as expected.
    fmt.Println("len:", len(s))

    // Adding elements to the end of the slice.
    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

    // Copying slices.
    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

    // Slices support a "slice" operator with the syntax slice[low:high]
    l := s[2:5]
    fmt.Println("sl1:", l)

    l = s[:5]
    fmt.Println("sl2:", l)

    l = s[2:]
    fmt.Println("sl3:", l)

    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

    // Slices can be composed into multi-dimensional data structures.
    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

package main

import (
    "fmt"
)

func main() {
    // Create a nil slice.
    var a []int
    fmt.Println(a)

    // Create slice literal.
    b := []int{1, 2, 3}
    fmt.Println(b)

    // Create slice using make.
    c := make([]int, 5)
    fmt.Println(c)

    // Create slice from nil.
    d := append([]int(nil), 1, 2, 3)
    fmt.Println(d)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}

    // Method #1
    dest := make([]int, len(s))
    copy(dest, s)
    fmt.Println(dest)

    // Method #2
    dest2 := append([]int(nil), s...)
    fmt.Println(dest2)

    // Method #3
    dest3 := append(s[:0:0], s...)
    fmt.Println(dest3)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}

    insertAtIdx := 2
    s = append(s[:insertAtIdx], append([]int{999}, s[insertAtIdx:]...)...)
    fmt.Println(s)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}
    s = append([]int{-99}, s...)
    fmt.Println(s)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}
    s = append(s, 6)
    fmt.Println(s)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}
    s2 := []int{6, 7, 8, 9, 10}

    insertIdx := 3
    s = append(s[:insertIdx], append(s2, s[insertIdx:]...)...)
    fmt.Println(s)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}
    s2 := []int{6, 7, 8, 9, 10}

    s = append(s2, s...)
    fmt.Println(s)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}
    s2 := []int{6, 7, 8, 9, 10}

    s = append(s, s2...)
    fmt.Println(s)
}

package main

import (
    "fmt"
)

func main() {

    var a []int

    // In Go, the length of a nil slice is 0
    fmt.Println(len(a))

    a = append(a, 1, 2, 3)
    fmt.Println(len(a))
}

package main

import (
    "fmt"
)

func main() {

    list := []string{"a", "b", "c"}
    fmt.Println(list[1])
}

package main

import (
    "fmt"
)

func main() {

    list := []string{"a", "b", "c"}
    fmt.Println(list[0])
}

package main

import (
    "fmt"
)

func main() {

    list := []string{"a", "b", "c"}
    fmt.Println(list[len(list)-1])
}

package main

import (
    "fmt"
)

func main() {
    a := []int{1, 2, 3, 4, 5, 6, 7}
    sublist := a[0:5]
    fmt.Println(sublist)
}

package main

import (
    "fmt"
)

func main() {
    a := []int{1, 2, 3, 4, 5, 6, 7}
    sublist := a[2:4]
    fmt.Println(sublist)
}

package main

import (
    "fmt"
)

func main() {
    a := []int{1, 2, 3, 4, 5, 6, 7}
    sublist := a[3:len(a)]
    fmt.Println(sublist)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}
    s[2] = 999
    fmt.Println(s)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}
    s[0] = 999
    fmt.Println(s)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}
    s[len(s)-1] = 999
    fmt.Println(s)
}

package main

import "fmt"

func main() {
  
  s := []int{1, 2, 3, 4, 5}
  fmt.Println(s)
  
  removeIdx := 3
  s = append(s[:removeIdx], s[removeIdx+1:]...)
  fmt.Println(s)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}
    s = s[1:]
    fmt.Println(s)
}

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}
    s = s[:len(s)-1]
    fmt.Println(s)
}

package main

import (
    "fmt"
    "sort"
)

func main() {

    fruit := []string{"Apple", "Banana", "Mango", "Orange"}

    // Custom sort based on the second letter of the word.
    sort.Slice(fruit, func(i, j int) bool {
        return fruit[i][1] < fruit[j][1]
    })

    fmt.Println(fruit)
}

package main

import (
    "fmt"
)

func main() {
    a := []int{1, 2, 3, 4, 5}
    for i := len(a)/2 - 1; i >= 0; i-- {
        opp := len(a) - 1 - i
        a[i], a[opp] = a[opp], a[i]
    }
    fmt.Println(a)
}

package main

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

func main() {
    rand.Seed(time.Now().UnixNano())
    a := []int{1, 2, 3, 4, 5}
    for i := len(a) - 1; i > 0; i-- {
        j := rand.Intn(i + 1)
        a[i], a[j] = a[j], a[i]
    }
    fmt.Println(a)

    // You can also use rand.Shuffle
    b := []int{6, 7, 8, 9, 10}
    rand.Shuffle(len(b), func(i, j int) {
        b[i], b[j] = b[j], b[i]
    })
    fmt.Println(b)
}

package main

import "fmt"

func main() {

    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)

    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }

    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

package main

import (
    "fmt"
)

func Equal(a, b []int) bool {
    if len(a) != len(b) {
        return false
    }
    for i, v := range a {
        if v != b[i] {
            return false
        }
    }
    return true
}

func main() {
    a := []int{1, 2, 3}
    b := []int{1, 2, 3, 4}
    c := []int{1, 2, 3}
    fmt.Println(Equal(a, b))
    fmt.Println(Equal(a, c))
}

package main

import (
    "fmt"
    "strings"
)

func FindStr(list []string, pred func(s string) bool) string {
    for _, s := range list {
        if pred(s) {
            return s
        }
    }
    return ""
}

func main() {

    list := []string{"slice", "of", "strings"}
    res := FindStr(list, func(s string) bool {
        return strings.HasPrefix(s, "o")
    })
    fmt.Println(res)
}

package main

import (
    "fmt"
    "strings"
)

func FindStrIdx(list []string, pred func(s string) bool) int {
    for i, s := range list {
        if pred(s) {
            return i
        }
    }
    return -1
}

func main() {

    list := []string{"slice", "of", "strings"}
    res := FindStrIdx(list, func(s string) bool {
        return strings.HasPrefix(s, "o")
    })
    fmt.Println(res)
}

package main

import (
    "fmt"
    "strings"
)

func Filter(vs []string, f func(string) bool) []string {
    vsf := make([]string, 0)
    for _, v := range vs {
        if f(v) {
            vsf = append(vsf, v)
        }
    }
    return vsf
}

func main() {

    var strs = []string{"peach", "apple", "pear", "plum"}

    fmt.Println(Filter(strs, func(v string) bool {
        return strings.Contains(v, "e")
    }))
}

console.log([1, 2, 3].includes(2));
console.log([1, 2, 3].includes(4));

console.log(['some', 'simple', 'words'].includes(123));
console.log(['some', 'simple', 'words'].includes('words'));

package main

import (
    "fmt"
)

func Index(vs []string, t string) int {
    for i, v := range vs {
        if v == t {
            return i
        }
    }
    return -1
}

func main() {

    var strs = []string{"peach", "apple", "pear", "plum"}
    fmt.Println(Index(strs, "pear"))
}

package main

import (
    "fmt"
    "strings"
)

func Any(vs []string, f func(string) bool) bool {
    for _, v := range vs {
        if f(v) {
            return true
        }
    }
    return false
}

func main() {

    var strs = []string{"peach", "apple", "pear", "plum"}

    fmt.Println(Any(strs, func(v string) bool {
        return strings.HasPrefix(v, "p")
    }))
}

package main

import (
    "fmt"
    "strings"
)

func All(vs []string, f func(string) bool) bool {
    for _, v := range vs {
        if !f(v) {
            return false
        }
    }
    return true
}

func main() {

    var strs = []string{"peach", "apple", "pear", "plum"}

    fmt.Println(All(strs, func(v string) bool {
        return strings.HasPrefix(v, "p")
    }))
}

package main

import (
    "fmt"
    "strings"
)

func Map(vs []string, f func(string) string) []string {
    vsm := make([]string, len(vs))
    for i, v := range vs {
        vsm[i] = f(v)
    }
    return vsm
}

func main() {

    var strs = []string{"peach", "apple", "pear", "plum"}

    fmt.Println(Map(strs, strings.ToUpper))
}

package main

import (
    "fmt"
)

func main() {
    a := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    // Here, we know how many paritions we need for grouping by even/odd numbers.
    partitions := make([][]int, 2)
    for _, n := range a {
        idx := n % 2
        partitions[idx] = append(partitions[idx], n)
    }
    fmt.Println(partitions)

    // Next we try grouping by first letter of a word.
    // Here, we use a map to access buckets by a key.
    b := []string{"orange", "apple", "grapefruit", "avocados"}
    partitions2 := map[string][]string{}
    for _, str := range b {
        key := string(str[0])
        partitions2[key] = append(partitions2[key], str)
    }
    fmt.Println(partitions2)
}

package main

import (
    "fmt"
)

func main() {

    actions := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    batchSize := 3
    batches := make([][]int, 0, (len(actions)+batchSize-1)/batchSize)

    for batchSize < len(actions) {
        actions, batches = actions[batchSize:], append(batches, actions[0:batchSize:batchSize])
    }
    batches = append(batches, actions)
    fmt.Println(batches)
}