├── 2d-array ├── main.go └── sample.dat ├── a-very-big-sum ├── main.go └── sample.dat ├── arrays-ds ├── main.go └── sample.dat ├── diagonal-difference ├── main.go └── sample.dat ├── dynamic-array ├── main.go └── sample.dat ├── insertionsort1 ├── main.go ├── sample.dat └── sample2.dat ├── insertionsort2 ├── main.go └── sample.dat ├── plus-minus ├── main.go └── sample.dat ├── quicksort1 ├── main.go └── sample.dat ├── quicksort2 ├── main.go └── sample.dat ├── quicksort3 ├── main.go └── sample.dat ├── simple-array-sum ├── main.go └── sample.dat ├── sparse-arrays ├── main.go └── sample.dat ├── staircase └── main.go └── time-conversion └── main.go /2d-array/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | const MaxInt = int(^uint(0) >> 1) 9 | const MinInt = -(MaxInt - 1) 10 | 11 | type Matrix struct { 12 | Dimension int 13 | Data [][]int 14 | } 15 | 16 | func main() { 17 | matrix := NewMatrix(6) 18 | 19 | err := matrix.Read() 20 | if err != nil { 21 | log.Fatal(err) 22 | } 23 | 24 | fmt.Printf("%d\n", matrix.MaxHourglass()) 25 | } 26 | 27 | func NewMatrix(dim int) *Matrix { 28 | m := new(Matrix) 29 | 30 | m.Dimension = dim 31 | 32 | m.Data = make([][]int, m.Dimension) 33 | 34 | for i := range m.Data { 35 | m.Data[i] = make([]int, m.Dimension) 36 | } 37 | 38 | return m 39 | } 40 | 41 | func (m *Matrix) Read() error { 42 | for y := 0; y < m.Dimension; y++ { 43 | for x := 0; x < m.Dimension; x++ { 44 | _, err := fmt.Scanf("%d", &m.Data[y][x]) 45 | if err != nil { 46 | return err 47 | } 48 | } 49 | } 50 | return nil 51 | } 52 | 53 | func (m *Matrix) Print() { 54 | for y := 0; y < m.Dimension; y++ { 55 | for x := 0; x < m.Dimension; x++ { 56 | fmt.Printf("%d", m.At(x, y)) 57 | 58 | if x != m.Dimension-1 { 59 | fmt.Printf(" ") 60 | } 61 | } 62 | fmt.Printf("\n") 63 | } 64 | } 65 | 66 | func (m *Matrix) At(x, y int) int { 67 | return m.Data[y][x] 68 | } 69 | 70 | func (m *Matrix) HourglassSum(x, y int) int { 71 | sum := 0 72 | sum += m.At(x, y) 73 | sum += m.At(x+1, y) 74 | sum += m.At(x+2, y) 75 | sum += m.At(x+1, y+1) 76 | sum += m.At(x, y+2) 77 | sum += m.At(x+1, y+2) 78 | sum += m.At(x+2, y+2) 79 | return sum 80 | } 81 | 82 | func (m *Matrix) MaxHourglass() int { 83 | max := MinInt 84 | 85 | for y := 0; y < m.Dimension-2; y++ { 86 | for x := 0; x < m.Dimension-2; x++ { 87 | sum := m.HourglassSum(x, y) 88 | if sum > max { 89 | max = sum 90 | } 91 | } 92 | } 93 | 94 | return max 95 | } 96 | -------------------------------------------------------------------------------- /2d-array/sample.dat: -------------------------------------------------------------------------------- 1 | 1 1 1 0 0 0 2 | 0 1 0 0 0 0 3 | 1 1 1 0 0 0 4 | 0 0 2 4 4 0 5 | 0 0 0 2 0 0 6 | 0 0 1 2 4 0 7 | -------------------------------------------------------------------------------- /a-very-big-sum/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | func main() { 9 | data, err := readData() 10 | if err != nil { 11 | log.Fatal(err) 12 | } 13 | 14 | fmt.Printf("%d\n", Sum(data)) 15 | } 16 | 17 | func Sum(list []int64) int64 { 18 | var sum int64 = 0 19 | 20 | for _, v := range list { 21 | sum += v 22 | } 23 | 24 | return sum 25 | } 26 | 27 | func readData() ([]int64, error) { 28 | var length int64 29 | 30 | _, err := fmt.Scanf("%d", &length) 31 | if err != nil { 32 | return nil, err 33 | } 34 | 35 | data := make([]int64, length) 36 | 37 | for i := range data { 38 | _, err := fmt.Scanf("%d", &data[i]) 39 | if err != nil { 40 | return nil, err 41 | } 42 | } 43 | 44 | return data, nil 45 | } 46 | -------------------------------------------------------------------------------- /a-very-big-sum/sample.dat: -------------------------------------------------------------------------------- 1 | 5 2 | 1000000001 1000000002 1000000003 1000000004 1000000005 3 | -------------------------------------------------------------------------------- /arrays-ds/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | func main() { 9 | length, err := readLength() 10 | if err != nil { 11 | log.Fatal(err) 12 | } 13 | 14 | values, err := readValues(length) 15 | if err != nil { 16 | log.Fatal(err) 17 | } 18 | 19 | printReverse(values) 20 | } 21 | 22 | func readLength() (int, error) { 23 | var value int 24 | 25 | _, err := fmt.Scanf("%d", &value) 26 | if err != nil { 27 | return -1, err 28 | } 29 | 30 | return value, err 31 | } 32 | 33 | func readValues(length int) ([]int, error) { 34 | var err error 35 | 36 | values := make([]int, length) 37 | 38 | for i := range values { 39 | _, err = fmt.Scanf("%d", &values[i]) 40 | if err != nil { 41 | return nil, err 42 | } 43 | } 44 | 45 | return values, nil 46 | } 47 | 48 | func printReverse(values []int) { 49 | for i := len(values) - 1; i >= 0; i-- { 50 | fmt.Printf("%d", values[i]) 51 | 52 | if i != 0 { 53 | fmt.Printf(" ") 54 | } 55 | } 56 | fmt.Printf("\n") 57 | } 58 | -------------------------------------------------------------------------------- /arrays-ds/sample.dat: -------------------------------------------------------------------------------- 1 | 4 2 | 1 4 3 2 3 | -------------------------------------------------------------------------------- /diagonal-difference/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "log" 7 | "os" 8 | ) 9 | 10 | func main() { 11 | matrix, err := NewMatrix(os.Stdin) 12 | if err != nil { 13 | log.Fatal(err) 14 | } 15 | 16 | fmt.Printf("%d\n", matrix.AbsoluteDiagonalDifference()) 17 | } 18 | 19 | type Matrix struct { 20 | Dimension int 21 | Data [][]int 22 | } 23 | 24 | func NewMatrix(r io.Reader) (*Matrix, error) { 25 | m := new(Matrix) 26 | 27 | _, err := fmt.Fscanf(r, "%d", &m.Dimension) 28 | if err != nil { 29 | return nil, err 30 | } 31 | 32 | m.Data = make([][]int, m.Dimension) 33 | 34 | for i := range m.Data { 35 | m.Data[i] = make([]int, m.Dimension) 36 | } 37 | 38 | for y := 0; y < m.Dimension; y++ { 39 | for x := 0; x < m.Dimension; x++ { 40 | _, err := fmt.Fscanf(r, "%d", &m.Data[y][x]) 41 | if err != nil { 42 | return nil, err 43 | } 44 | } 45 | } 46 | 47 | return m, nil 48 | } 49 | 50 | func (m *Matrix) Print() { 51 | for y := 0; y < m.Dimension; y++ { 52 | for x := 0; x < m.Dimension; x++ { 53 | fmt.Printf("%d", m.At(x, y)) 54 | 55 | if x != m.Dimension-1 { 56 | fmt.Printf(" ") 57 | } 58 | } 59 | fmt.Printf("\n") 60 | } 61 | } 62 | 63 | func (m *Matrix) At(x, y int) int { 64 | return m.Data[y][x] 65 | } 66 | 67 | func (m *Matrix) Diagonal() int { 68 | sum := 0 69 | for i := 0; i < m.Dimension; i++ { 70 | sum += m.At(i, i) 71 | } 72 | return sum 73 | } 74 | 75 | func (m *Matrix) ReverseDiagonal() int { 76 | sum := 0 77 | for i := 0; i < m.Dimension; i++ { 78 | sum += m.At(m.Dimension-i-1, i) 79 | } 80 | return sum 81 | } 82 | 83 | func (m *Matrix) AbsoluteDiagonalDifference() int { 84 | diff := m.Diagonal() - m.ReverseDiagonal() 85 | if diff < 0 { 86 | return -diff 87 | } else { 88 | return diff 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /diagonal-difference/sample.dat: -------------------------------------------------------------------------------- 1 | 3 2 | 11 2 4 3 | 4 5 6 4 | 10 8 -12 5 | -------------------------------------------------------------------------------- /dynamic-array/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | const Q1 = 1 9 | const Q2 = 2 10 | 11 | type Query struct { 12 | Type int 13 | X int 14 | Y int 15 | } 16 | 17 | type Sequence []int 18 | 19 | type List struct { 20 | Last int 21 | Sequences []Sequence 22 | Queries []Query 23 | } 24 | 25 | func main() { 26 | list, err := ReadList() 27 | if err != nil { 28 | log.Fatal(err) 29 | } 30 | 31 | list.Run() 32 | } 33 | 34 | func ReadList() (*List, error) { 35 | var sequenceCount, queryCount int 36 | 37 | _, err := fmt.Scanf("%d %d", &sequenceCount, &queryCount) 38 | if err != nil { 39 | return nil, err 40 | } 41 | 42 | list := new(List) 43 | 44 | list.Last = 0 45 | 46 | list.Sequences = make([]Sequence, sequenceCount) 47 | for i := range list.Sequences { 48 | list.Sequences[i] = make([]int, 0) 49 | } 50 | 51 | list.Queries = make([]Query, queryCount) 52 | 53 | for i := 0; i < queryCount; i++ { 54 | q := Query{} 55 | _, err := fmt.Scanf("%d %d %d", &q.Type, &q.X, &q.Y) 56 | if err != nil { 57 | return nil, err 58 | } 59 | list.Queries[i] = q 60 | } 61 | 62 | return list, nil 63 | } 64 | 65 | func (list *List) Print() { 66 | fmt.Printf("Queries\n-------\n") 67 | 68 | for _, q := range list.Queries { 69 | fmt.Printf("Type: %d / X: %d / Y: %d\n", q.Type, q.X, q.Y) 70 | } 71 | 72 | fmt.Printf("Sequences\n---------\n") 73 | 74 | for _, s := range list.Sequences { 75 | fmt.Printf("%v\n", s) 76 | } 77 | } 78 | 79 | func (list *List) Run() { 80 | for _, q := range list.Queries { 81 | switch q.Type { 82 | case Q1: 83 | list.Query1(q.X, q.Y) 84 | case Q2: 85 | list.Query2(q.X, q.Y) 86 | } 87 | } 88 | } 89 | 90 | func (list *List) Query1(x, y int) { 91 | index := (x ^ list.Last) % len(list.Sequences) 92 | list.Sequences[index] = append(list.Sequences[index], y) 93 | } 94 | 95 | func (list *List) Query2(x, y int) { 96 | index := (x ^ list.Last) % len(list.Sequences) 97 | list.Last = list.Sequences[index][y%len(list.Sequences[index])] 98 | fmt.Printf("%d\n", list.Last) 99 | } 100 | -------------------------------------------------------------------------------- /dynamic-array/sample.dat: -------------------------------------------------------------------------------- 1 | 2 5 2 | 1 0 5 3 | 1 1 7 4 | 1 0 3 5 | 2 1 0 6 | 2 1 1 7 | -------------------------------------------------------------------------------- /insertionsort1/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | func main() { 9 | list, err := readList() 10 | if err != nil { 11 | log.Fatal(err) 12 | } 13 | 14 | InsertionSort(list) 15 | } 16 | 17 | func readList() ([]int, error) { 18 | var length int 19 | 20 | _, err := fmt.Scanf("%d", &length) 21 | if err != nil { 22 | return nil, err 23 | } 24 | 25 | list := make([]int, length) 26 | 27 | for i := 0; i < len(list); i++ { 28 | _, err := fmt.Scanf("%d", &list[i]) 29 | if err != nil { 30 | return nil, err 31 | } 32 | } 33 | 34 | return list, nil 35 | } 36 | 37 | func InsertionSort(list []int) { 38 | value := list[len(list)-1] 39 | 40 | for i := len(list) - 1; i > 0; i-- { 41 | list[i] = list[i-1] 42 | 43 | if list[i] < value { 44 | list[i] = value 45 | Print(list) 46 | return 47 | } 48 | Print(list) 49 | } 50 | 51 | list[0] = value 52 | Print(list) 53 | } 54 | 55 | func Print(list []int) { 56 | for i := 0; i < len(list); i++ { 57 | if i != 0 { 58 | fmt.Printf(" ") 59 | } 60 | fmt.Printf("%d", list[i]) 61 | } 62 | fmt.Printf("\n") 63 | } 64 | -------------------------------------------------------------------------------- /insertionsort1/sample.dat: -------------------------------------------------------------------------------- 1 | 5 2 | 2 4 6 8 3 3 | -------------------------------------------------------------------------------- /insertionsort1/sample2.dat: -------------------------------------------------------------------------------- 1 | 2 2 | 3 2 3 | -------------------------------------------------------------------------------- /insertionsort2/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | func main() { 9 | list, err := readList() 10 | if err != nil { 11 | log.Fatal(err) 12 | } 13 | 14 | InsertionSort(list) 15 | } 16 | 17 | func readList() ([]int, error) { 18 | var length int 19 | 20 | _, err := fmt.Scanf("%d", &length) 21 | if err != nil { 22 | return nil, err 23 | } 24 | 25 | list := make([]int, length) 26 | 27 | for i := 0; i < len(list); i++ { 28 | _, err := fmt.Scanf("%d", &list[i]) 29 | if err != nil { 30 | return nil, err 31 | } 32 | } 33 | 34 | return list, nil 35 | } 36 | 37 | func InsertionSort(list []int) { 38 | if len(list) <= 1 { 39 | return 40 | } 41 | 42 | for i := 1; i < len(list); i++ { 43 | for j := i; j > 0 && list[j-1] > list[j]; j-- { 44 | list[j], list[j-1] = list[j-1], list[j] 45 | } 46 | Print(list) 47 | } 48 | } 49 | 50 | func Print(list []int) { 51 | for i := 0; i < len(list); i++ { 52 | if i != 0 { 53 | fmt.Printf(" ") 54 | } 55 | fmt.Printf("%d", list[i]) 56 | } 57 | fmt.Printf("\n") 58 | } 59 | -------------------------------------------------------------------------------- /insertionsort2/sample.dat: -------------------------------------------------------------------------------- 1 | 6 2 | 1 4 3 5 6 2 3 | -------------------------------------------------------------------------------- /plus-minus/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | type List []int 9 | 10 | func main() { 11 | list, err := ReadList() 12 | if err != nil { 13 | log.Fatal(err) 14 | } 15 | 16 | plus, minus, zero := list.PlusMinusZero() 17 | 18 | fmt.Printf("%f\n", float64(plus)/float64(len(list))) 19 | fmt.Printf("%f\n", float64(minus)/float64(len(list))) 20 | fmt.Printf("%f\n", float64(zero)/float64(len(list))) 21 | } 22 | 23 | func ReadList() (List, error) { 24 | var length int 25 | 26 | _, err := fmt.Scanf("%d", &length) 27 | if err != nil { 28 | return nil, err 29 | } 30 | 31 | list := make([]int, length) 32 | 33 | for i := 0; i < len(list); i++ { 34 | _, err := fmt.Scanf("%d", &list[i]) 35 | if err != nil { 36 | return nil, err 37 | } 38 | } 39 | 40 | return list, nil 41 | } 42 | 43 | func (l List) PlusMinusZero() (int, int, int) { 44 | plus, minus, zero := 0, 0, 0 45 | 46 | for i := 0; i < len(l); i++ { 47 | switch { 48 | case l[i] > 0: 49 | plus++ 50 | case l[i] < 0: 51 | minus++ 52 | case l[i] == 0: 53 | zero++ 54 | } 55 | } 56 | 57 | return plus, minus, zero 58 | } 59 | -------------------------------------------------------------------------------- /plus-minus/sample.dat: -------------------------------------------------------------------------------- 1 | 6 2 | -4 3 -9 0 4 1 3 | -------------------------------------------------------------------------------- /quicksort1/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | func main() { 9 | list, err := Read() 10 | if err != nil { 11 | log.Fatal(err) 12 | } 13 | 14 | left, empty, right := Divide(list, 0) 15 | 16 | Print(left, empty, right) 17 | } 18 | 19 | func Read() ([]int, error) { 20 | var length int 21 | 22 | _, err := fmt.Scanf("%d", &length) 23 | if err != nil { 24 | return nil, err 25 | } 26 | 27 | list := make([]int, length) 28 | 29 | for i := 0; i < len(list); i++ { 30 | _, err := fmt.Scanf("%d", &list[i]) 31 | if err != nil { 32 | return nil, err 33 | } 34 | } 35 | 36 | return list, nil 37 | } 38 | 39 | func Print(lists ...[]int) { 40 | for i := 0; i < len(lists); i++ { 41 | list := lists[i] 42 | 43 | for j := 0; j < len(list); j++ { 44 | fmt.Printf("%d", list[j]) 45 | 46 | if j == len(list)-1 && i == len(lists)-1 { 47 | fmt.Printf("\n") 48 | } else { 49 | fmt.Printf(" ") 50 | } 51 | } 52 | } 53 | } 54 | 55 | func Divide(list []int, pivot int) ([]int, []int, []int) { 56 | left, equal, right := make([]int, 0), make([]int, 0), make([]int, 0) 57 | 58 | for i := 0; i < len(list); i++ { 59 | switch { 60 | case list[i] == list[pivot]: 61 | equal = append(equal, list[i]) 62 | case list[i] < list[pivot]: 63 | left = append(left, list[i]) 64 | case list[i] > list[pivot]: 65 | right = append(right, list[i]) 66 | } 67 | } 68 | 69 | return left, equal, right 70 | } 71 | -------------------------------------------------------------------------------- /quicksort1/sample.dat: -------------------------------------------------------------------------------- 1 | 5 2 | 4 5 3 7 2 3 | -------------------------------------------------------------------------------- /quicksort2/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | func main() { 9 | list, err := Read() 10 | if err != nil { 11 | log.Fatal(err) 12 | } 13 | 14 | partition(list) 15 | } 16 | 17 | func Read() ([]int, error) { 18 | var length int 19 | 20 | _, err := fmt.Scanf("%d", &length) 21 | if err != nil { 22 | return nil, err 23 | } 24 | 25 | list := make([]int, length) 26 | 27 | for i := 0; i < len(list); i++ { 28 | _, err := fmt.Scanf("%d", &list[i]) 29 | if err != nil { 30 | return nil, err 31 | } 32 | } 33 | 34 | return list, nil 35 | } 36 | 37 | func Print(lists ...[]int) { 38 | for i := 0; i < len(lists); i++ { 39 | list := lists[i] 40 | 41 | for j := 0; j < len(list); j++ { 42 | fmt.Printf("%d", list[j]) 43 | 44 | if j == len(list)-1 && i == len(lists)-1 { 45 | fmt.Printf("\n") 46 | } else { 47 | fmt.Printf(" ") 48 | } 49 | } 50 | } 51 | } 52 | 53 | func partition(list []int) []int { 54 | if len(list) <= 1 { 55 | return list 56 | } 57 | 58 | pivot := list[0] 59 | left := make([]int, 0) 60 | right := make([]int, 0) 61 | 62 | for i := 1; i < len(list); i++ { 63 | if list[i] <= pivot { 64 | left = append(left, list[i]) 65 | } else { 66 | right = append(right, list[i]) 67 | } 68 | } 69 | 70 | sorted := append(append(partition(left), pivot), partition(right)...) 71 | 72 | Print(sorted) 73 | 74 | return sorted 75 | } 76 | 77 | func Divide(list []int, pivot int) ([]int, []int, []int) { 78 | left, equal, right := make([]int, 0), make([]int, 0), make([]int, 0) 79 | 80 | for i := 0; i < len(list); i++ { 81 | switch { 82 | case list[i] == list[pivot]: 83 | equal = append(equal, list[i]) 84 | case list[i] < list[pivot]: 85 | left = append(left, list[i]) 86 | case list[i] > list[pivot]: 87 | right = append(right, list[i]) 88 | } 89 | } 90 | 91 | return left, equal, right 92 | } 93 | -------------------------------------------------------------------------------- /quicksort2/sample.dat: -------------------------------------------------------------------------------- 1 | 7 2 | 5 8 1 3 7 9 2 3 | -------------------------------------------------------------------------------- /quicksort3/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | func main() { 9 | list, err := Read() 10 | if err != nil { 11 | log.Fatal(err) 12 | } 13 | 14 | Quicksort(list) 15 | } 16 | 17 | func Read() ([]int, error) { 18 | var length int 19 | 20 | _, err := fmt.Scanf("%d", &length) 21 | if err != nil { 22 | return nil, err 23 | } 24 | 25 | list := make([]int, length) 26 | 27 | for i := 0; i < len(list); i++ { 28 | _, err := fmt.Scanf("%d", &list[i]) 29 | if err != nil { 30 | return nil, err 31 | } 32 | } 33 | 34 | return list, nil 35 | } 36 | 37 | func Print(lists ...[]int) { 38 | for i := 0; i < len(lists); i++ { 39 | list := lists[i] 40 | 41 | for j := 0; j < len(list); j++ { 42 | fmt.Printf("%d", list[j]) 43 | 44 | if j == len(list)-1 && i == len(lists)-1 { 45 | fmt.Printf("\n") 46 | } else { 47 | fmt.Printf(" ") 48 | } 49 | } 50 | } 51 | } 52 | 53 | func Quicksort(list []int) { 54 | quicksort(list, 0, len(list)-1) 55 | } 56 | 57 | func quicksort(list []int, low, high int) { 58 | if low < high { 59 | pivot := partition(list, low, high) 60 | 61 | Print(list) 62 | 63 | quicksort(list, low, pivot-1) 64 | quicksort(list, pivot+1, high) 65 | } 66 | } 67 | 68 | func partition(list []int, low, high int) int { 69 | pivot := list[high] 70 | index := low 71 | 72 | for i := low; i < high; i++ { 73 | if list[i] <= pivot { 74 | list[i], list[index] = list[index], list[i] 75 | index++ 76 | } 77 | } 78 | 79 | list[index], list[high] = list[high], list[index] 80 | 81 | return index 82 | } 83 | -------------------------------------------------------------------------------- /quicksort3/sample.dat: -------------------------------------------------------------------------------- 1 | 7 2 | 1 3 9 8 2 7 5 3 | -------------------------------------------------------------------------------- /simple-array-sum/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | func main() { 9 | data, err := readData() 10 | if err != nil { 11 | log.Fatal(err) 12 | } 13 | 14 | fmt.Printf("%d\n", Sum(data)) 15 | } 16 | 17 | func Sum(list []int) int { 18 | sum := 0 19 | 20 | for _, v := range list { 21 | sum += v 22 | } 23 | 24 | return sum 25 | } 26 | 27 | func readData() ([]int, error) { 28 | var length int 29 | 30 | _, err := fmt.Scanf("%d", &length) 31 | if err != nil { 32 | return nil, err 33 | } 34 | 35 | data := make([]int, length) 36 | 37 | for i := range data { 38 | _, err := fmt.Scanf("%d", &data[i]) 39 | if err != nil { 40 | return nil, err 41 | } 42 | } 43 | 44 | return data, nil 45 | } 46 | -------------------------------------------------------------------------------- /simple-array-sum/sample.dat: -------------------------------------------------------------------------------- 1 | 6 2 | 1 2 3 4 10 11 3 | -------------------------------------------------------------------------------- /sparse-arrays/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | ) 7 | 8 | type StringList []string 9 | 10 | func main() { 11 | data, queries, err := ReadData() 12 | if err != nil { 13 | log.Fatal(err) 14 | } 15 | 16 | for _, query := range queries { 17 | fmt.Printf("%d\n", Occurrences(data, query)) 18 | } 19 | } 20 | 21 | func ReadData() ([]string, []string, error) { 22 | var dataLength, queriesLength int 23 | 24 | _, err := fmt.Scanf("%d", &dataLength) 25 | if err != nil { 26 | return nil, nil, err 27 | } 28 | 29 | data := make([]string, dataLength) 30 | 31 | for i := 0; i < len(data); i++ { 32 | _, err := fmt.Scanf("%s", &data[i]) 33 | if err != nil { 34 | return nil, nil, err 35 | } 36 | } 37 | 38 | _, err = fmt.Scanf("%d", &queriesLength) 39 | if err != nil { 40 | return nil, nil, err 41 | } 42 | 43 | queries := make([]string, queriesLength) 44 | 45 | for i := 0; i < len(queries); i++ { 46 | _, err := fmt.Scanf("%s", &queries[i]) 47 | if err != nil { 48 | return nil, nil, err 49 | } 50 | } 51 | 52 | return data, queries, nil 53 | } 54 | 55 | func Occurrences(data []string, query string) int { 56 | count := 0 57 | 58 | for _, str := range data { 59 | if str == query { 60 | count++ 61 | } 62 | } 63 | 64 | return count 65 | } 66 | -------------------------------------------------------------------------------- /sparse-arrays/sample.dat: -------------------------------------------------------------------------------- 1 | 4 2 | aba 3 | baba 4 | aba 5 | xzxb 6 | 3 7 | aba 8 | xzxb 9 | ab 10 | -------------------------------------------------------------------------------- /staircase/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | "strings" 7 | ) 8 | 9 | func main() { 10 | var height int 11 | 12 | _, err := fmt.Scanf("%d", &height) 13 | if err != nil { 14 | log.Fatal(err) 15 | } 16 | 17 | PrintStaircase(height) 18 | } 19 | 20 | func PrintStaircase(height int) { 21 | for i := 1; i <= height; i++ { 22 | fmt.Printf("%s%s\n", 23 | strings.Repeat(" ", height-i), 24 | strings.Repeat("#", i)) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /time-conversion/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | "time" 7 | ) 8 | 9 | const inputLayout = "03:04:05PM" 10 | const outputLayout = "15:04:05" 11 | 12 | func main() { 13 | var str string 14 | 15 | _, err := fmt.Scanln(&str) 16 | if err != nil { 17 | log.Fatal(err) 18 | } 19 | 20 | t, err := time.Parse(inputLayout, str) 21 | if err != nil { 22 | log.Fatal(err) 23 | } 24 | 25 | fmt.Println(t.Format(outputLayout)) 26 | } 27 | --------------------------------------------------------------------------------