├── .gitignore ├── .travis.yml ├── README.md ├── a_very_big_sum ├── a_very_big_sum.go └── a_very_big_sum_test.go ├── acm_icpc_team ├── acm_icpc_team.go └── acm_icpc_team_test.go ├── angry_professor ├── angry_professor.go └── angry_professor_test.go ├── append_and_delete ├── append_and_delete.go └── append_and_delete_test.go ├── apple_and_orange ├── apple_and_orange.go └── apple_and_orange_test.go ├── beautiful_days_at_the_movies ├── beautiful_days_at_the_movies.go └── beautiful_days_at_the_movies_test.go ├── beautiful_pairs ├── beautiful_pairs.go └── beautiful_pairs_test.go ├── beautiful_triplets ├── beautiful_triplets.go └── beautiful_triplets_test.go ├── between_two_sets ├── between_two_sets.go └── between_two_sets_test.go ├── big_sorting ├── big_sorting.go └── big_sorting_test.go ├── bigger_is_greater ├── bigger_is_greater.go └── bigger_is_greater_test.go ├── birthday_cake_candles ├── birthday_cake_candles.go └── birthday_cake_candles_test.go ├── birthday_chocolate ├── birthday_chocolate.go └── birthday_chocolate_test.go ├── bon_appetit ├── bon_appetit.go └── bon_appetit_test.go ├── breaking_best_and_worst_records ├── breaking_best_and_worst_records.go └── breaking_best_and_worst_records_test.go ├── breaking_the_records ├── breaking_the_records.go └── breaking_the_records_test.go ├── caesar_cipher ├── caesar_cipher.go └── caesar_cipher_test.go ├── camel_case ├── camel_case.go └── camel_case_test.go ├── cats_and_a_mouse ├── cats_and_a_mouse.go └── cats_and_a_mouse_test.go ├── circular_array_rotation ├── circular_array_rotation.go └── circular_array_rotation_test.go ├── climbing_the_leaderboard ├── climbing_the_leaderboard.go └── climbing_the_leaderboard_test.go ├── compare_the_triplets ├── compare_the_triplets.go └── compare_the_triplets_test.go ├── counting_valleys ├── counting_valleys.go └── counting_valleys_test.go ├── cut_the_sticks ├── cut_the_sticks.go └── cut_the_sticks_test.go ├── day_of_the_programmer ├── day_of_the_programmer.go └── day_of_the_programmer_test.go ├── designer_pdf_viewer ├── designer_pdf_viewer.go └── designer_pdf_viewer_test.go ├── diagonal_difference ├── diagonal_difference.go └── diagonal_difference_test.go ├── divisible_sum_pairs ├── divisible_sum_pairs.go └── divisible_sum_pairs_test.go ├── drawing_book ├── drawing_book.go └── drawing_book_test.go ├── electronics_shop ├── electronics_shop.go └── electronics_shop_test.go ├── encryption ├── encryption.go └── encryption_test.go ├── equalize_the_array ├── equalize_the_array.go └── equalize_the_array_test.go ├── extra_long_factorials ├── extra_long_factorials.go └── extra_long_factorials_test.go ├── find_digits ├── find_digits.go └── find_digits_test.go ├── forming_a_magic_square ├── forming_a_magic_square.go └── forming_a_magic_square_test.go ├── fraudulent_activity_notifications ├── fraudulent_activity_notifications.go └── fraudulent_activity_notifications_test.go ├── grading_students ├── grading_students.go └── grading_students_test.go ├── hackerland_radio_transmitters ├── hackerland_radio_transmitters.go └── hackerland_radio_transmitters_test.go ├── hackerrank_in_a_string ├── hackerrank_in_a_string.go └── hackerrank_in_a_string_test.go ├── jumping_on_the_clouds ├── jumping_on_the_clouds.go └── jumping_on_the_clouds_test.go ├── jumping_on_the_clouds_revisited ├── jumping_on_the_clouds_revisited.go └── jumping_on_the_clouds_revisited_test.go ├── kangaroo ├── kangaroo.go └── kangaroo_test.go ├── library_fine ├── library_fine.go └── library_fine_test.go ├── marcs_cakewalk ├── marcs_cakewalk.go └── marcs_cakewalk_test.go ├── migratory_birds ├── migratory_birds.go └── migratory_birds_test.go ├── mini_max_sum ├── mini_max_sum.go └── mini_max_sum_test.go ├── minimum_absolute_difference_in_an_array ├── minimum_absolute_difference_in_an_array.go └── minimum_absolute_difference_in_an_array_test.go ├── modified_kaprekar_numbers ├── modified_kaprekar_numbers.go └── modified_kaprekar_numbers_test.go ├── non_divisible_subset ├── non_divisible_subset.go └── non_divisible_subset_test.go ├── organizing_containers_of_balls ├── organizing_containers_of_balls.go └── organizing_containers_of_balls_test.go ├── picking_numbers ├── picking_numbers.go └── picking_numbers_test.go ├── plus_minus ├── plus_minus.go └── plus_minus_test.go ├── queens_attack2 ├── queens_attack2.go └── queens_attack2_test.go ├── recursive_digit_sum ├── recursive_digit_sum.go └── recursive_digit_sum_test.go ├── repeated_string ├── repeated_string.go └── repeated_string_test.go ├── save_the_prisoner ├── save_the_prisoner.go └── save_the_prisoner_test.go ├── separate_the_numbers ├── separate_the_numbers.go └── separate_the_numbers_test.go ├── sequence_equation ├── sequence_equation.go └── sequence_equation_test.go ├── sherlock_and_squares ├── sherlock_and_squares.go └── sherlock_and_squares_test.go ├── simple_array_sum ├── simple_array_sum.go └── simple_array_sum_test.go ├── sock_merchant ├── sock_merchant.go └── sock_merchant_test.go ├── staircase ├── staircase.go └── staircase_test.go ├── taum_and_bday ├── taum_and_bday.go └── taum_and_bday_test.go ├── the_hurdle_race ├── the_hurdle_race.go └── the_hurdle_race_test.go ├── the_power_sum ├── the_power_sum.go └── the_power_sum_test.go ├── time_conversion ├── time_conversion.go └── time_conversion_test.go ├── utopian_tree ├── utopian_tree.go └── utopian_tree_test.go ├── viral_advertising ├── viral_advertising.go └── viral_advertising_test.go └── weighted_uniform_strings ├── weighted_uniform_strings.go └── weighted_uniform_strings_test.go /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | *.test 24 | *.prof 25 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 3 | - master 4 | before_install: 5 | - go get github.com/mattn/goveralls 6 | script: 7 | - go test -cover -v -race ./... 8 | - go test -bench=. -v -race ./... 9 | - $GOPATH/bin/goveralls -service=travis-ci 10 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![Build Status](https://travis-ci.org/vaskoz/hackerrank-go.svg?branch=master)](https://travis-ci.org/vaskoz/hackerrank-go) 2 | [![Coverage Status](https://coveralls.io/repos/github/vaskoz/hackerrank-go/badge.svg?branch=master)](https://coveralls.io/github/vaskoz/hackerrank-go?branch=master) 3 | [![Go Report Card](https://goreportcard.com/badge/github.com/vaskoz/hackerrank-go)](https://goreportcard.com/report/github.com/vaskoz/hackerrank-go) 4 | [![GoDoc](https://godoc.org/github.com/vaskoz/hackerrank-go?status.svg)](https://godoc.org/github.com/vaskoz/hackerrank-go) 5 | [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE.txt) 6 | 7 | # No Pull Requests accepted. This is just a personal playground. 8 | 9 | # Usage 10 | ``` 11 | go get github.com/vaskoz/hackerrank-go/{name of challenge} 12 | ``` 13 | -------------------------------------------------------------------------------- /a_very_big_sum/a_very_big_sum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var n int 14 | fmt.Fscanf(stdin, "%d", &n) 15 | sum := uint64(0) 16 | for i := 0; i < n; i++ { 17 | var x uint64 18 | fmt.Fscanf(stdin, "%d", &x) 19 | sum += x 20 | } 21 | fmt.Fprintln(stdout, sum) 22 | } 23 | -------------------------------------------------------------------------------- /a_very_big_sum/a_very_big_sum_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"5 1000000001 1000000002 1000000003 1000000004 1000000005", "5000000015\n"}, 13 | } 14 | 15 | func TestAVeryBigSum(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkAVeryBigSum(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /acm_icpc_team/acm_icpc_team.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, m int 15 | fmt.Fscanf(stdin, "%d %d", &n, &m) 16 | input := make([][]rune, n) 17 | for i := 0; i < n; i++ { 18 | var s string 19 | fmt.Fscanf(stdin, "%s", &s) 20 | input[i] = []rune(s) 21 | } 22 | var topics, teams int 23 | for i := 0; i < n-1; i++ { 24 | for j := i + 1; j < n; j++ { 25 | count := 0 26 | for k := 0; k < m; k++ { 27 | if input[i][k] == '1' || input[j][k] == '1' { 28 | count++ 29 | } 30 | } 31 | if count > topics { 32 | topics = count 33 | teams = 1 34 | } else if count == topics { 35 | teams++ 36 | } 37 | } 38 | } 39 | fmt.Fprintln(stdout, topics) 40 | fmt.Fprintln(stdout, teams) 41 | } 42 | -------------------------------------------------------------------------------- /acm_icpc_team/acm_icpc_team_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"4 5 10101 11100 11010 00101", "5\n2\n"}, 13 | } 14 | 15 | func TestAcmIcpcTeam(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkAcmIcpcTeam(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /angry_professor/angry_professor.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var tests int 15 | fmt.Fscanf(stdin, "%d", &tests) 16 | for t := 0; t < tests; t++ { 17 | var n, k, count, x int 18 | fmt.Fscanf(stdin, "%d %d", &n, &k) 19 | for i := 0; i < n; i++ { 20 | fmt.Fscanf(stdin, "%d", &x) 21 | if x <= 0 { 22 | count++ 23 | } 24 | } 25 | if count < k { 26 | fmt.Fprintln(stdout, "YES") 27 | } else { 28 | fmt.Fprintln(stdout, "NO") 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /angry_professor/angry_professor_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"2 4 3 -1 -3 4 2 4 2 0 -1 2 1", "YES\nNO\n"}, 13 | } 14 | 15 | func TestAngryProfessor(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkAngryProfessor(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /append_and_delete/append_and_delete.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var s, t string 15 | var k int 16 | fmt.Fscanf(stdin, "%s", &s) 17 | fmt.Fscanf(stdin, "%s", &t) 18 | fmt.Fscanf(stdin, "%d", &k) 19 | 20 | index := 0 21 | for i := 0; i < len(s) && i < len(t); i++ { 22 | if s[i] != t[i] { 23 | break 24 | } else { 25 | index++ 26 | } 27 | } 28 | if combined := len(s) + len(t); combined-2*index > k { 29 | fmt.Fprintln(stdout, "No") 30 | } else if (combined-2*index)%2 == k%2 { 31 | fmt.Fprintln(stdout, "Yes") 32 | } else if combined-k < 0 { 33 | fmt.Fprintln(stdout, "Yes") 34 | } else { 35 | fmt.Fprintln(stdout, "No") 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /append_and_delete/append_and_delete_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"hackerhappy hackerrank 9", "Yes\n"}, 13 | {"aba aba 7", "Yes\n"}, 14 | {"ab ac 3", "No\n"}, 15 | {"ab ac 1", "No\n"}, 16 | {"ab ac 2", "Yes\n"}, 17 | {"qwerasdf qwerbsdf 6", "No\n"}, 18 | {"asdfqwertyuighjkzxcvasdfqwertyuighjkzxcvasdfqwertyuighjkzxcvasdfqwertyuighjkzxcvasdfqwertyuighjkzxcv bsdfqwertyuighjkzxcvasdfqwertyuighjkzxcvasdfqwertyuighjkzxcvasdfqwertyuighjkzxcvasdfqwertyuighjkzxcv 100", "No\n"}, 19 | } 20 | 21 | func TestAppendAndDelete(t *testing.T) { 22 | t.Parallel() 23 | for _, c := range testcases { 24 | stdin = strings.NewReader(c.in) 25 | buff := new(bytes.Buffer) 26 | stdout = buff 27 | main() 28 | out := buff.String() 29 | if out != c.out { 30 | t.Errorf("%v does not equal %v", out, c.out) 31 | } 32 | } 33 | } 34 | 35 | func BenchmarkAppendAndDelete(b *testing.B) { 36 | for i := 0; i < b.N; i++ { 37 | for _, c := range testcases { 38 | stdin = strings.NewReader(c.in) 39 | buff := new(bytes.Buffer) 40 | stdout = buff 41 | main() 42 | } 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /apple_and_orange/apple_and_orange.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var s, t, a, b, m, n, appleHits, orangeHits, pos int 15 | fmt.Fscanf(stdin, "%d %d", &s, &t) 16 | fmt.Fscanf(stdin, "%d %d", &a, &b) 17 | fmt.Fscanf(stdin, "%d %d", &m, &n) 18 | for i := 0; i < m; i++ { 19 | fmt.Fscanf(stdin, "%d", &pos) 20 | if a+pos >= s && a+pos <= t { 21 | appleHits++ 22 | } 23 | } 24 | for i := 0; i < n; i++ { 25 | fmt.Fscanf(stdin, "%d", &pos) 26 | if b+pos >= s && b+pos <= t { 27 | orangeHits++ 28 | } 29 | } 30 | fmt.Fprintf(stdout, "%d\n%d\n", appleHits, orangeHits) 31 | } 32 | -------------------------------------------------------------------------------- /apple_and_orange/apple_and_orange_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"7 11 5 15 3 2 -2 2 1 5 -6", "1\n1\n"}, 13 | } 14 | 15 | func TestAppleAndOrange(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkAppleAndOrange(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /beautiful_days_at_the_movies/beautiful_days_at_the_movies.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "strconv" 8 | "strings" 9 | ) 10 | 11 | var stdin io.Reader = os.Stdin 12 | var stdout io.Writer = os.Stdout 13 | var stderr io.Writer = os.Stderr 14 | 15 | func main() { 16 | var i, j, k, counter int 17 | fmt.Fscanf(stdin, "%d %d %d", &i, &j, &k) 18 | for x := i; x <= j; x++ { 19 | r := Reverse(x) 20 | v := x - r 21 | if v%k == 0 { 22 | counter++ 23 | } 24 | } 25 | fmt.Fprintln(stdout, counter) 26 | } 27 | 28 | func Reverse(x int) int { 29 | return ReverseUsingInt(x) 30 | //return ReverseUsingString(x) 31 | } 32 | 33 | func ReverseUsingString(x int) int { 34 | s := strconv.Itoa(x) 35 | letters := strings.Split(s, "") 36 | for i := 0; i < len(letters)/2; i++ { 37 | letters[i], letters[len(letters)-i-1] = letters[len(letters)-i-1], letters[i] 38 | } 39 | s = strings.Join(letters, "") 40 | result, _ := strconv.Atoi(s) 41 | return result 42 | } 43 | 44 | func ReverseUsingInt(x int) int { 45 | result := 0 46 | for x/10 != 0 { 47 | if x%10 != 0 { 48 | result += (x % 10) 49 | } 50 | result *= 10 51 | x /= 10 52 | } 53 | result += x 54 | return result 55 | } 56 | -------------------------------------------------------------------------------- /beautiful_days_at_the_movies/beautiful_days_at_the_movies_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"20 23 6", "2\n"}, 13 | } 14 | 15 | func TestBeautifulDaysAtTheMovies(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkBeautifulDaysAtTheMovies(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | 40 | var reverseTestcases = []struct { 41 | in, out int 42 | }{ 43 | {1234, 4321}, 44 | {42341234, 43214324}, 45 | {10, 1}, 46 | {9, 9}, 47 | } 48 | 49 | func TestReverseUsingInt(t *testing.T) { 50 | for _, c := range reverseTestcases { 51 | if out := ReverseUsingInt(c.in); out != c.out { 52 | t.Errorf("Expected %v, but got %v", c.out, out) 53 | } 54 | } 55 | } 56 | 57 | func TestReverseUsingString(t *testing.T) { 58 | for _, c := range reverseTestcases { 59 | if out := ReverseUsingString(c.in); out != c.out { 60 | t.Errorf("Expected %v, but got %v", c.out, out) 61 | } 62 | } 63 | } 64 | 65 | func BenchmarkReverseUsingInt(b *testing.B) { 66 | for i := 0; i < b.N; i++ { 67 | for _, c := range reverseTestcases { 68 | ReverseUsingInt(c.in) 69 | } 70 | } 71 | } 72 | 73 | func BenchmarkReverseUsingString(b *testing.B) { 74 | for i := 0; i < b.N; i++ { 75 | for _, c := range reverseTestcases { 76 | ReverseUsingString(c.in) 77 | } 78 | } 79 | } 80 | -------------------------------------------------------------------------------- /beautiful_pairs/beautiful_pairs.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var n int 14 | fmt.Fscanf(stdin, "%d", &n) 15 | mapA := make(map[int]int, n) 16 | for i := 0; i < n; i++ { 17 | var x int 18 | fmt.Fscanf(stdin, "%d", &x) 19 | mapA[x]++ 20 | } 21 | result := 0 22 | for i := 0; i < n; i++ { 23 | var x int 24 | fmt.Fscanf(stdin, "%d", &x) 25 | if count, found := mapA[x]; found { 26 | result++ 27 | if count == 1 { 28 | delete(mapA, x) 29 | } else { 30 | mapA[x]-- 31 | } 32 | } 33 | } 34 | if result != n { 35 | fmt.Fprintln(stdout, result+1) 36 | } else { 37 | fmt.Fprintln(stdout, result-1) 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /beautiful_pairs/beautiful_pairs_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"3 1 2 2 1 2 3", "3\n"}, 13 | {"3 1 2 3 1 2 3", "2\n"}, 14 | } 15 | 16 | func TestBeautifulPairs(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkBeautifulPairs(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /beautiful_triplets/beautiful_triplets.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, d, result int 15 | fmt.Fscanf(stdin, "%d %d", &n, &d) 16 | a := make([]int, n) 17 | lookup := make(map[int]int, n) 18 | for i := 0; i < n; i++ { 19 | fmt.Fscanf(stdin, "%d", &a[i]) 20 | lookup[a[i]] = i 21 | } 22 | for i := 0; i < n-2; i++ { 23 | aj := d + a[i] 24 | if j, found := lookup[aj]; found && i < j { 25 | ak := d + a[j] 26 | if k, found := lookup[ak]; found && j < k { 27 | result++ 28 | } 29 | } 30 | } 31 | fmt.Fprintln(stdout, result) 32 | } 33 | -------------------------------------------------------------------------------- /beautiful_triplets/beautiful_triplets_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"7 3 1 2 4 5 7 8 10", "3\n"}, 13 | } 14 | 15 | func TestBeautifulTriplets(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkBeautifulTriplets(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /between_two_sets/between_two_sets.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func gcd(a, b int) int { 14 | for b > 0 { 15 | a, b = b, a%b 16 | } 17 | return a 18 | } 19 | 20 | func lcm(a, b int) int { 21 | return a * (b / gcd(a, b)) 22 | } 23 | 24 | func main() { 25 | var n, m int 26 | fmt.Fscanf(stdin, "%d %d", &n, &m) 27 | var f int 28 | fmt.Fscanf(stdin, "%d", &f) 29 | for i := 1; i < n; i++ { 30 | var x int 31 | fmt.Fscanf(stdin, "%d", &x) 32 | f = lcm(f, x) 33 | } 34 | 35 | var l int 36 | fmt.Fscanf(stdin, "%d", &l) 37 | for i := 1; i < m; i++ { 38 | var x int 39 | fmt.Fscanf(stdin, "%d", &x) 40 | l = gcd(l, x) 41 | } 42 | 43 | count := 0 44 | for i, j := f, 2; i <= l; i, j = f*j, j+1 { 45 | if l%i == 0 { 46 | count++ 47 | } 48 | } 49 | fmt.Fprintln(stdout, count) 50 | } 51 | -------------------------------------------------------------------------------- /between_two_sets/between_two_sets_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"2 3 2 4 16 32 96", "3\n"}, 13 | } 14 | 15 | func TestBetweenTwoSets(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkBetweenTwoSets(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /big_sorting/big_sorting.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "sort" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | 13 | func main() { 14 | var n int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | a := make([]string, n) 17 | for i := 0; i < n; i++ { 18 | fmt.Fscanf(stdin, "%s", &a[i]) 19 | } 20 | sort.Slice(a, func(i, j int) bool { 21 | if al, bl := len(a[i]), len(a[j]); al < bl { 22 | return true 23 | } else if al == bl { 24 | return a[i] < a[j] 25 | } else { 26 | return false 27 | } 28 | }) 29 | for i := 0; i < n; i++ { 30 | fmt.Fprintln(stdout, a[i]) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /big_sorting/big_sorting_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"6 31415926535897932384626433832795 1 3 10 3 5", "1\n3\n3\n5\n10\n31415926535897932384626433832795\n"}, 13 | } 14 | 15 | func TestBigSorting(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkBigSorting(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /bigger_is_greater/bigger_is_greater.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var tests int 15 | fmt.Fscanf(stdin, "%d", &tests) 16 | var line string 17 | for i := 0; i < tests; i++ { 18 | fmt.Fscanf(stdin, "%s", &line) 19 | if len(line) < 2 { 20 | fmt.Fprintln(stdout, "no answer") 21 | continue 22 | } 23 | runes := []rune(line) 24 | pivotIndex := -1 25 | for j := len(runes) - 1; j > 0; j-- { 26 | if runes[j] > runes[j-1] { 27 | pivotIndex = j - 1 28 | break 29 | } 30 | } 31 | if pivotIndex == -1 { 32 | fmt.Fprintln(stdout, "no answer") 33 | continue 34 | } 35 | nextIndex := -1 36 | for j := len(runes) - 1; j > pivotIndex; j-- { 37 | if runes[j] > runes[pivotIndex] { 38 | nextIndex = j 39 | break 40 | } 41 | } 42 | runes[pivotIndex], runes[nextIndex] = runes[nextIndex], runes[pivotIndex] 43 | for x, y := pivotIndex+1, len(runes)-1; x < y; x, y = x+1, y-1 { 44 | runes[x], runes[y] = runes[y], runes[x] 45 | } 46 | fmt.Fprintln(stdout, string(runes)) 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /bigger_is_greater/bigger_is_greater_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"5 ab bb hefg dhck dkhc", "ba\nno answer\nhegf\ndhkc\nhcdk\n"}, 13 | {"1 a", "no answer\n"}, 14 | } 15 | 16 | func TestBiggerIsGreater(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkBiggerIsGreater(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /birthday_cake_candles/birthday_cake_candles.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, tallest, count int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | for i := 0; i < n; i++ { 17 | var x int 18 | fmt.Fscanf(stdin, "%d", &x) 19 | if x > tallest { 20 | tallest = x 21 | count = 1 22 | } else if x == tallest { 23 | count++ 24 | } 25 | } 26 | fmt.Fprintln(stdout, count) 27 | } 28 | -------------------------------------------------------------------------------- /birthday_cake_candles/birthday_cake_candles_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"4 3 2 1 3", "2\n"}, 13 | } 14 | 15 | func TestBirthdayCakeCandles(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkBirthdayCakeCandles(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /birthday_chocolate/birthday_chocolate.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var n int 14 | fmt.Fscanf(stdin, "%d", &n) 15 | s := make([]int, n) 16 | for i := 0; i < n; i++ { 17 | fmt.Fscanf(stdin, "%d", &s[i]) 18 | } 19 | var d, m, result int 20 | fmt.Fscanf(stdin, "%d %d", &d, &m) 21 | for i := 0; i <= n-m; i++ { 22 | sum := 0 23 | for j := i; j < i+m; j++ { 24 | sum += s[j] 25 | } 26 | if sum == d { 27 | result++ 28 | } 29 | } 30 | fmt.Fprintln(stdout, result) 31 | } 32 | -------------------------------------------------------------------------------- /birthday_chocolate/birthday_chocolate_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"5 1 2 1 3 2 3 2", "2\n"}, 13 | {"6 1 1 1 1 1 1 3 2", "0\n"}, 14 | {"1 4 4 1", "1\n"}, 15 | } 16 | 17 | func TestBirthdayChocolate(t *testing.T) { 18 | t.Parallel() 19 | for _, c := range testcases { 20 | stdin = strings.NewReader(c.in) 21 | buff := new(bytes.Buffer) 22 | stdout = buff 23 | main() 24 | out := buff.String() 25 | if out != c.out { 26 | t.Errorf("%v does not equal %v", out, c.out) 27 | } 28 | } 29 | } 30 | 31 | func BenchmarkBirthdayChocolate(b *testing.B) { 32 | for i := 0; i < b.N; i++ { 33 | for _, c := range testcases { 34 | stdin = strings.NewReader(c.in) 35 | buff := new(bytes.Buffer) 36 | stdout = buff 37 | main() 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /bon_appetit/bon_appetit.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, k, expected, charged int 15 | fmt.Fscanf(stdin, "%d %d", &n, &k) 16 | for i := 0; i < n; i++ { 17 | var x int 18 | fmt.Fscanf(stdin, "%d", &x) 19 | if i != k { 20 | expected += x 21 | } 22 | } 23 | fmt.Fscanf(stdin, "%d", &charged) 24 | if charged*2 == expected { 25 | fmt.Fprintln(stdout, "Bon Appetit") 26 | } else { 27 | fmt.Fprintln(stdout, charged-expected/2) 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /bon_appetit/bon_appetit_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"4 1 3 10 2 9 12", "5\n"}, 13 | {"4 1 3 10 2 9 7", "Bon Appetit\n"}, 14 | } 15 | 16 | func TestBonAppetit(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkBonAppetit(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /breaking_best_and_worst_records/breaking_best_and_worst_records.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var games int 14 | fmt.Fscanf(stdin, "%d", &games) 15 | var best, worst int 16 | fmt.Fscanf(stdin, "%d", &best) 17 | worst = best 18 | var worstBroken, bestBroken int 19 | for i := 0; i < games-1; i++ { 20 | var score int 21 | fmt.Fscanf(stdin, "%d", &score) 22 | if score < worst { 23 | worstBroken++ 24 | worst = score 25 | } else if score > best { 26 | bestBroken++ 27 | best = score 28 | } 29 | } 30 | fmt.Fprintln(stdout, bestBroken, worstBroken) 31 | } 32 | -------------------------------------------------------------------------------- /breaking_best_and_worst_records/breaking_best_and_worst_records_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in string 11 | out string 12 | }{ 13 | {"4 1 2 3 4", "3 0\n"}, 14 | {"10 3 4 21 36 10 28 35 5 24 42", "4 0\n"}, 15 | {"9 10 5 20 20 4 5 2 25 1", "2 4\n"}, 16 | {"4 4 3 2 1", "0 3\n"}, 17 | } 18 | 19 | func TestBestWorst(t *testing.T) { 20 | t.Parallel() 21 | for _, c := range testcases { 22 | stdin = strings.NewReader(c.in) 23 | buff := new(bytes.Buffer) 24 | stdout = buff 25 | main() 26 | out := buff.String() 27 | if out != c.out { 28 | t.Errorf("%v does not equal %v", out, c.out) 29 | } 30 | } 31 | } 32 | 33 | func BenchmarkBestWorst(b *testing.B) { 34 | for i := 0; i < b.N; i++ { 35 | for _, c := range testcases { 36 | stdin = strings.NewReader(c.in) 37 | buff := new(bytes.Buffer) 38 | stdout = buff 39 | main() 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /breaking_the_records/breaking_the_records.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var games, best, worst, worstBroken, bestBroken int 15 | fmt.Fscanf(stdin, "%d", &games) 16 | fmt.Fscanf(stdin, "%d", &best) 17 | worst = best 18 | for i := 0; i < games-1; i++ { 19 | var score int 20 | fmt.Fscanf(stdin, "%d", &score) 21 | if score < worst { 22 | worstBroken++ 23 | worst = score 24 | } else if score > best { 25 | bestBroken++ 26 | best = score 27 | } 28 | } 29 | fmt.Fprintln(stdout, bestBroken, worstBroken) 30 | } 31 | -------------------------------------------------------------------------------- /breaking_the_records/breaking_the_records_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"9 10 5 20 20 4 5 2 25 1", "2 4\n"}, 13 | {"10 3 4 21 36 10 28 35 5 24 42", "4 0\n"}, 14 | } 15 | 16 | func TestBreakingTheRecords(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkBreakingTheRecords(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /caesar_cipher/caesar_cipher.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var k int 14 | var unencrypted, encrypted string 15 | fmt.Fscanf(stdin, "%d", &k) // throw away length don't need it 16 | fmt.Fscanf(stdin, "%s", &unencrypted) 17 | fmt.Fscanf(stdin, "%d", &k) 18 | for _, r := range unencrypted { 19 | if r >= 'A' && r <= 'Z' { 20 | r += rune(k % 26) 21 | if r > 'Z' { 22 | r -= rune(26) 23 | } 24 | } else if r >= 'a' && r <= 'z' { 25 | r += rune(k % 26) 26 | if r > 'z' { 27 | r -= rune(26) 28 | } 29 | } 30 | encrypted += string(r) 31 | } 32 | fmt.Fprintln(stdout, encrypted) 33 | } 34 | -------------------------------------------------------------------------------- /caesar_cipher/caesar_cipher_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"11 middle-Outz 2", "okffng-Qwvb\n"}, 13 | {"11 middle-Outz 80", "okffng-Qwvb\n"}, 14 | {"11 middle-Outz 100", "iezzha-Kqpv\n"}, 15 | } 16 | 17 | func TestCaesarCipher(t *testing.T) { 18 | t.Parallel() 19 | for _, c := range testcases { 20 | stdin = strings.NewReader(c.in) 21 | buff := new(bytes.Buffer) 22 | stdout = buff 23 | main() 24 | out := buff.String() 25 | if out != c.out { 26 | t.Errorf("%v does not equal %v", out, c.out) 27 | } 28 | } 29 | } 30 | 31 | func BenchmarkCaesarCipher(b *testing.B) { 32 | for i := 0; i < b.N; i++ { 33 | for _, c := range testcases { 34 | stdin = strings.NewReader(c.in) 35 | buff := new(bytes.Buffer) 36 | stdout = buff 37 | main() 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /camel_case/camel_case.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "unicode" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | 13 | func main() { 14 | var input string 15 | fmt.Fscanf(stdin, "%s", &input) 16 | result := 1 17 | for _, r := range input { 18 | if unicode.IsUpper(r) { 19 | result++ 20 | } 21 | } 22 | fmt.Fprintln(stdout, result) 23 | } 24 | -------------------------------------------------------------------------------- /camel_case/camel_case_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"saveChangesInTheEditor", "5\n"}, 13 | {"save", "1\n"}, 14 | {"hackerRank", "2\n"}, 15 | {"weWishYouAMerryChristmas", "6\n"}, 16 | } 17 | 18 | func TestCamelCase(t *testing.T) { 19 | t.Parallel() 20 | for _, c := range testcases { 21 | stdin = strings.NewReader(c.in) 22 | buff := new(bytes.Buffer) 23 | stdout = buff 24 | main() 25 | out := buff.String() 26 | if out != c.out { 27 | t.Errorf("%v does not equal %v", out, c.out) 28 | } 29 | } 30 | } 31 | 32 | func BenchmarkCamelCase(b *testing.B) { 33 | for i := 0; i < b.N; i++ { 34 | for _, c := range testcases { 35 | stdin = strings.NewReader(c.in) 36 | buff := new(bytes.Buffer) 37 | stdout = buff 38 | main() 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /cats_and_a_mouse/cats_and_a_mouse.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var q int 14 | fmt.Fscanf(stdin, "%d", &q) 15 | for i := 0; i < q; i++ { 16 | var x, y, z int 17 | fmt.Fscanf(stdin, "%d %d %d", &x, &y, &z) 18 | da := z - x 19 | db := z - y 20 | if da < 0 { 21 | da = -da 22 | } 23 | if db < 0 { 24 | db = -db 25 | } 26 | if da < db { 27 | fmt.Fprintln(stdout, "Cat A") 28 | } else if db < da { 29 | fmt.Fprintln(stdout, "Cat B") 30 | } else { 31 | fmt.Fprintln(stdout, "Mouse C") 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /cats_and_a_mouse/cats_and_a_mouse_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"3 1 2 3 1 3 2 2 1 3", "Cat B\nMouse C\nCat A\n"}, 13 | {"1 4 1 3", "Cat A\n"}, 14 | } 15 | 16 | func TestCatsAndAMouse(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkCatsAndAMouse(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /circular_array_rotation/circular_array_rotation.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, k, q int 15 | fmt.Fscanf(stdin, "%d %d %d", &n, &k, &q) 16 | input := make([]int, n) 17 | for i := 0; i < n; i++ { 18 | fmt.Fscanf(stdin, "%d", &input[i]) 19 | } 20 | var query int 21 | rotation := k % n 22 | for i := 0; i < q; i++ { 23 | fmt.Fscanf(stdin, "%d", &query) 24 | fmt.Fprintln(stdout, input[(n-rotation+query)%n]) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /circular_array_rotation/circular_array_rotation_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"3 2 3 1 2 3 0 1 2", "2\n3\n1\n"}, 13 | } 14 | 15 | func TestCircularArrayRotation(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkCircularArrayRotation(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /climbing_the_leaderboard/climbing_the_leaderboard.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "sort" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | 13 | func main() { 14 | var n int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | var scores []int 17 | for i := 0; i < n; i++ { 18 | var s int 19 | fmt.Fscanf(stdin, "%d", &s) 20 | if scores == nil || scores[len(scores)-1] != s { 21 | scores = append(scores, s) 22 | } 23 | } 24 | var m int 25 | fmt.Fscanf(stdin, "%d", &m) 26 | for i := 0; i < m; i++ { 27 | var alice int 28 | fmt.Fscanf(stdin, "%d", &alice) 29 | index := sort.Search(len(scores), func(i int) bool { 30 | return scores[i] <= alice 31 | }) 32 | fmt.Fprintln(stdout, index+1) 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /climbing_the_leaderboard/climbing_the_leaderboard_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"7 100 100 50 40 40 20 10 4 5 25 50 120", "6\n4\n2\n1\n"}, 13 | } 14 | 15 | func TestClimbingTheLeaderboard(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkClimbingTheLeaderboard(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /compare_the_triplets/compare_the_triplets.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | a := make([]int, 3) 14 | b := make([]int, 3) 15 | for i := range a { 16 | fmt.Fscanf(stdin, "%d", &a[i]) 17 | } 18 | for i := range b { 19 | fmt.Fscanf(stdin, "%d", &b[i]) 20 | } 21 | aliceScore, bobScore := 0, 0 22 | for i := range a { 23 | if a[i] > b[i] { 24 | aliceScore++ 25 | } else if a[i] < b[i] { 26 | bobScore++ 27 | } 28 | } 29 | fmt.Fprintln(stdout, aliceScore, bobScore) 30 | } 31 | -------------------------------------------------------------------------------- /compare_the_triplets/compare_the_triplets_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"5 6 7 3 6 10", "1 1\n"}, 13 | } 14 | 15 | func TestCompareTheTriplets(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkCompareTheTriplets(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /counting_valleys/counting_valleys.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var n int 14 | fmt.Fscanf(stdin, "%d", &n) 15 | var s string 16 | fmt.Fscanf(stdin, "%s", &s) 17 | inValley := false 18 | result := 0 19 | pos := 0 20 | for _, r := range s { 21 | if r == 'D' { 22 | pos-- 23 | } else if r == 'U' { 24 | pos++ 25 | } 26 | if inValley && pos == 0 { 27 | inValley = false 28 | result++ 29 | } else if !inValley && pos < 0 { 30 | inValley = true 31 | } 32 | } 33 | fmt.Fprintln(stdout, result) 34 | } 35 | -------------------------------------------------------------------------------- /counting_valleys/counting_valleys_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"8 UDDDUDUU", "1\n"}, 13 | {"8 DUDUDUDU", "4\n"}, 14 | } 15 | 16 | func TestCountingValleys(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkCountingValleys(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /cut_the_sticks/cut_the_sticks.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "sort" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | var stderr io.Writer = os.Stderr 13 | 14 | func main() { 15 | var n int 16 | fmt.Fscanf(stdin, "%d", &n) 17 | sticks := make([]int, n) 18 | for i := 0; i < n; i++ { 19 | fmt.Fscanf(stdin, "%d", &sticks[i]) 20 | } 21 | sort.Ints(sticks) // O(N*log(N)) 22 | last := 0 23 | for i, s := range sticks { // O(N) 24 | if s != last { 25 | last = s 26 | fmt.Fprintln(stdout, len(sticks)-i) 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /cut_the_sticks/cut_the_sticks_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"6 5 4 4 2 2 8", "6\n4\n2\n1\n"}, 13 | {"8 1 2 3 4 3 3 2 1", "8\n6\n4\n1\n"}, 14 | } 15 | 16 | func TestCutTheSticks(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkCutTheSticks(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /day_of_the_programmer/day_of_the_programmer.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var year int 14 | fmt.Fscanf(stdin, "%d", &year) 15 | month := 9 16 | days := 13 17 | if year > 1918 { 18 | if year%400 == 0 || (year%4 == 0 && year%100 != 0) { 19 | days-- 20 | } 21 | } else if year == 1918 { 22 | days = 26 23 | } else { 24 | if year%4 == 0 { 25 | days-- 26 | } 27 | } 28 | fmt.Fprintf(stdout, "%02d.%02d.%4d\n", days, month, year) 29 | } 30 | -------------------------------------------------------------------------------- /day_of_the_programmer/day_of_the_programmer_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"2017", "13.09.2017\n"}, 13 | {"2016", "12.09.2016\n"}, 14 | {"2025", "13.09.2025\n"}, 15 | {"1918", "26.09.1918\n"}, 16 | {"1912", "12.09.1912\n"}, 17 | {"1911", "13.09.1911\n"}, 18 | } 19 | 20 | func TestDayOfTheProgrammer(t *testing.T) { 21 | t.Parallel() 22 | for _, c := range testcases { 23 | stdin = strings.NewReader(c.in) 24 | buff := new(bytes.Buffer) 25 | stdout = buff 26 | main() 27 | out := buff.String() 28 | if out != c.out { 29 | t.Errorf("%v does not equal %v", out, c.out) 30 | } 31 | } 32 | } 33 | 34 | func BenchmarkDayOfTheProgrammer(b *testing.B) { 35 | for i := 0; i < b.N; i++ { 36 | for _, c := range testcases { 37 | stdin = strings.NewReader(c.in) 38 | buff := new(bytes.Buffer) 39 | stdout = buff 40 | main() 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /designer_pdf_viewer/designer_pdf_viewer.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | a := make([]int, 26) 15 | for i := 0; i < len(a); i++ { 16 | fmt.Fscanf(stdin, "%d", &a[i]) 17 | } 18 | var word string 19 | fmt.Fscanf(stdin, "%s", &word) 20 | height := 0 21 | for _, c := range word { 22 | if a[c-'a'] > height { 23 | height = a[c-'a'] 24 | } 25 | } 26 | fmt.Fprintln(stdout, len(word)*height) 27 | } 28 | -------------------------------------------------------------------------------- /designer_pdf_viewer/designer_pdf_viewer_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"1 3 1 3 1 4 1 3 2 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 abc", "9\n"}, 13 | } 14 | 15 | func TestDesignerPdfViewer(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkDesignerPdfViewer(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /diagonal_difference/diagonal_difference.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var n int 14 | fmt.Fscanf(stdin, "%d", &n) 15 | sum := 0 16 | sumpos, negpos := -1, -1 17 | for i := 0; i < n*n; i++ { 18 | var x int 19 | fmt.Fscanf(stdin, "%d", &x) 20 | if i%n == 0 { 21 | sumpos++ 22 | negpos++ 23 | } 24 | if i%n == sumpos { 25 | sum += x 26 | } 27 | if i%n == n-negpos-1 { 28 | sum -= x 29 | } 30 | } 31 | if sum < 0 { 32 | sum = -sum 33 | } 34 | fmt.Fprintln(stdout, sum) 35 | } 36 | -------------------------------------------------------------------------------- /diagonal_difference/diagonal_difference_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"3 11 2 4 4 5 6 10 8 -12", "15\n"}, 13 | } 14 | 15 | func TestDiagonalDifference(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkDiagonalDifference(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /divisible_sum_pairs/divisible_sum_pairs.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, k, count int 15 | fmt.Fscanf(stdin, "%d %d", &n, &k) 16 | data := make([]int, n) 17 | for i := 0; i < n; i++ { 18 | fmt.Fscanf(stdin, "%d", &data[i]) 19 | } 20 | for i := 0; i < n-1; i++ { 21 | for j := i + 1; j < n; j++ { 22 | if pair := data[i] + data[j]; pair/k > 0 && pair%k == 0 { 23 | count++ 24 | } 25 | } 26 | } 27 | fmt.Fprintln(stdout, count) 28 | } 29 | -------------------------------------------------------------------------------- /divisible_sum_pairs/divisible_sum_pairs_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"6 3 1 3 2 6 1 2", "5\n"}, 13 | } 14 | 15 | func TestDivisibleSumPairs(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkDivisibleSumPairs(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /drawing_book/drawing_book.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, p int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | fmt.Fscanf(stdin, "%d", &p) 17 | forward := p / 2 18 | var backward int 19 | if n%2 == 0 { 20 | backward = (n - p + 1) / 2 21 | } else { 22 | backward = (n - p) / 2 23 | } 24 | if backward < forward { 25 | fmt.Fprintln(stdout, backward) 26 | } else { 27 | fmt.Fprintln(stdout, forward) 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /drawing_book/drawing_book_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"6 2", "1\n"}, 13 | {"5 4", "0\n"}, 14 | } 15 | 16 | func TestDrawingBook(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkDrawingBook(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /electronics_shop/electronics_shop.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "sort" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | 13 | func main() { 14 | var s, n, m int 15 | fmt.Fscanf(stdin, "%d %d %d", &s, &n, &m) 16 | keyboards := make([]int, n) 17 | for i := 0; i < n; i++ { 18 | fmt.Fscanf(stdin, "%d", &keyboards[i]) 19 | } 20 | usbs := make([]int, m) 21 | for i := 0; i < m; i++ { 22 | fmt.Fscanf(stdin, "%d", &usbs[i]) 23 | } 24 | sort.Ints(keyboards) 25 | sort.Ints(usbs) 26 | if keyboards[0]+usbs[0] > s { 27 | fmt.Fprintln(stdout, -1) 28 | return 29 | } 30 | kimax := sort.Search(len(keyboards), func(i int) bool { 31 | return keyboards[i] >= s 32 | }) 33 | uimax := sort.Search(len(usbs), func(i int) bool { 34 | return usbs[i] >= s 35 | }) 36 | max := 0 37 | for i := 0; i < kimax; i++ { 38 | for j := 0; j < uimax; j++ { 39 | if total := keyboards[i] + usbs[j]; total <= s && total > max { 40 | max = total 41 | } 42 | } 43 | } 44 | fmt.Fprintln(stdout, max) 45 | } 46 | -------------------------------------------------------------------------------- /electronics_shop/electronics_shop_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"10 2 3 3 1 5 2 8", "9\n"}, 13 | {"5 1 1 4 5", "-1\n"}, 14 | } 15 | 16 | func TestElectronicsShop(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkElectronicsShop(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /encryption/encryption.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "math" 7 | "os" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | var stderr io.Writer = os.Stderr 13 | 14 | func main() { 15 | var msg string 16 | fmt.Fscanf(stdin, "%s", &msg) 17 | L := len(msg) 18 | row := int(math.Sqrt(float64(L))) 19 | col := row 20 | for row*col < L { 21 | if col > row { 22 | row++ 23 | } else if row == col { 24 | col++ 25 | } 26 | } 27 | for i := 0; i < col; i++ { 28 | for j := 0; j < row; j++ { 29 | p := col*j + i 30 | if p < L { 31 | fmt.Fprintf(stdout, "%s", string(msg[p])) 32 | } 33 | } 34 | fmt.Fprint(stdout, " ") 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /encryption/encryption_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"haveaniceday", "hae and via ecy "}, 13 | {"feedthedog", "fto ehg ee dd "}, 14 | {"chillout", "clu hlt io "}, 15 | } 16 | 17 | func TestEncryption(t *testing.T) { 18 | t.Parallel() 19 | for _, c := range testcases { 20 | stdin = strings.NewReader(c.in) 21 | buff := new(bytes.Buffer) 22 | stdout = buff 23 | main() 24 | out := buff.String() 25 | if out != c.out { 26 | t.Errorf("%v does not equal %v", out, c.out) 27 | } 28 | } 29 | } 30 | 31 | func BenchmarkEncryption(b *testing.B) { 32 | for i := 0; i < b.N; i++ { 33 | for _, c := range testcases { 34 | stdin = strings.NewReader(c.in) 35 | buff := new(bytes.Buffer) 36 | stdout = buff 37 | main() 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /equalize_the_array/equalize_the_array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, x, result int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | m := make(map[int]int) 17 | for i := 0; i < n; i++ { 18 | fmt.Fscanf(stdin, "%d", &x) 19 | m[x]++ 20 | } 21 | maxFreq, maxKey := 0, 0 22 | for k, v := range m { 23 | if v > maxFreq { 24 | maxFreq, maxKey = v, k 25 | } 26 | } 27 | delete(m, maxKey) 28 | for _, v := range m { 29 | result += v 30 | } 31 | fmt.Fprintln(stdout, result) 32 | } 33 | -------------------------------------------------------------------------------- /equalize_the_array/equalize_the_array_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"5 3 3 2 1 3", "2\n"}, 13 | } 14 | 15 | func TestEqualizeTheArray(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkEqualizeTheArray(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /extra_long_factorials/extra_long_factorials.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "math/big" 7 | "os" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | var stderr io.Writer = os.Stderr 13 | 14 | func main() { 15 | var N int 16 | fmt.Fscanf(stdin, "%d", &N) 17 | fmt.Fprintln(stdout, factorial(N).String()) 18 | } 19 | 20 | func factorial(n int) *big.Int { 21 | result, _ := new(big.Int).SetString("1", 10) 22 | for i := 2; i <= n; i++ { 23 | x := new(big.Int).SetInt64(int64(i)) 24 | result.Mul(result, x) 25 | } 26 | return result 27 | } 28 | -------------------------------------------------------------------------------- /extra_long_factorials/extra_long_factorials_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"25", "15511210043330985984000000\n"}, 13 | } 14 | 15 | func TestExtraLongFactorials(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkExtraLongFactorials(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /find_digits/find_digits.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var tests, n, t int64 15 | fmt.Fscanf(stdin, "%d", &tests) 16 | for t = 0; t < tests; t++ { 17 | result := 0 18 | fmt.Fscanf(stdin, "%d", &n) 19 | temp := n 20 | for temp != 0 { 21 | d := temp % 10 22 | if d != 0 && n%d == 0 { 23 | result++ 24 | } 25 | temp /= 10 26 | } 27 | fmt.Fprintln(stdout, result) 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /find_digits/find_digits_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"2 12 1012", "2\n3\n"}, 13 | } 14 | 15 | func TestFindDigits(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkFindDigits(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /forming_a_magic_square/forming_a_magic_square.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | var magic = [][]int{ 14 | {8, 1, 6, 3, 5, 7, 4, 9, 2}, 15 | {6, 1, 8, 7, 5, 3, 2, 9, 4}, 16 | {4, 9, 2, 3, 5, 7, 8, 1, 6}, 17 | {2, 9, 4, 7, 5, 3, 6, 1, 8}, 18 | {8, 3, 4, 1, 5, 9, 6, 7, 2}, 19 | {4, 3, 8, 9, 5, 1, 2, 7, 6}, 20 | {6, 7, 2, 1, 5, 9, 8, 3, 4}, 21 | {2, 7, 6, 9, 5, 1, 4, 3, 8}, 22 | } 23 | 24 | func main() { 25 | matrix := make([]int, 9) 26 | for i := range matrix { 27 | fmt.Fscanf(stdin, "%d", &matrix[i]) 28 | } 29 | result := 100 30 | for k := 0; k < len(magic); k++ { 31 | diff := 0 32 | for i := range matrix { 33 | if d := matrix[i] - magic[k][i]; d < 0 { 34 | diff += -d 35 | } else { 36 | diff += d 37 | } 38 | } 39 | if diff < result { 40 | result = diff 41 | } 42 | } 43 | fmt.Fprintln(stdout, result) 44 | } 45 | -------------------------------------------------------------------------------- /forming_a_magic_square/forming_a_magic_square_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"4 9 2 3 5 7 8 1 5", "1\n"}, 13 | } 14 | 15 | func TestFormingAMagicSquare(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkFormingAMagicSquare(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /fraudulent_activity_notifications/fraudulent_activity_notifications.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "container/heap" 5 | "fmt" 6 | "io" 7 | "os" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | 13 | type MinHeap []int 14 | 15 | func (min MinHeap) Len() int { return len(min) } 16 | func (min MinHeap) Less(i, j int) bool { return min[i] < min[j] } 17 | func (min MinHeap) Swap(i, j int) { min[i], min[j] = min[j], min[i] } 18 | 19 | func (min *MinHeap) Push(x interface{}) { 20 | *min = append(*min, x.(int)) 21 | } 22 | 23 | func (min *MinHeap) Pop() interface{} { 24 | old := *min 25 | n := len(old) 26 | x := old[n-1] 27 | *min = old[0 : n-1] 28 | return x 29 | } 30 | 31 | type MaxHeap []int 32 | 33 | func (max MaxHeap) Len() int { return len(max) } 34 | func (max MaxHeap) Less(i, j int) bool { return max[i] > max[j] } 35 | func (max MaxHeap) Swap(i, j int) { max[i], max[j] = max[j], max[i] } 36 | 37 | func (max *MaxHeap) Push(x interface{}) { 38 | *max = append(*max, x.(int)) 39 | } 40 | 41 | func (max *MaxHeap) Pop() interface{} { 42 | old := *max 43 | n := len(old) 44 | x := old[n-1] 45 | *max = old[0 : n-1] 46 | return x 47 | } 48 | 49 | func main() { 50 | var n, d int 51 | fmt.Fscanf(stdin, "%d %d", &n, &d) 52 | upper := &MinHeap{} 53 | heap.Init(upper) 54 | lower := &MaxHeap{} 55 | heap.Init(lower) 56 | previous := make([]int, 0, d) 57 | notifications := 0 58 | for i := 0; i < n; i++ { 59 | var x int 60 | fmt.Fscanf(stdin, "%d", &x) 61 | 62 | var median float64 63 | if i >= d { 64 | if lower.Len() > upper.Len() { 65 | v := (*lower)[0] 66 | median = float64(v) 67 | } else { 68 | a := (*lower)[0] 69 | b := (*upper)[0] 70 | median = float64(a+b) / 2.0 71 | } 72 | if float64(x) >= 2*median { 73 | notifications++ 74 | } 75 | toRemove := previous[0] 76 | previous = previous[1:] 77 | if toRemove <= (*lower)[0] { 78 | for i, v := range *lower { 79 | if toRemove == v { 80 | heap.Remove(lower, i) 81 | break 82 | } 83 | } 84 | } else { 85 | for i, v := range *upper { 86 | if toRemove == v { 87 | heap.Remove(upper, i) 88 | break 89 | } 90 | } 91 | } 92 | } 93 | if lower.Len() == 0 || x <= (*lower)[0] { 94 | heap.Push(lower, x) 95 | } else { 96 | heap.Push(upper, x) 97 | } 98 | for upper.Len() > lower.Len() { 99 | tmp := heap.Pop(upper) 100 | heap.Push(lower, tmp) 101 | } 102 | for lower.Len() > upper.Len()+1 { 103 | tmp := heap.Pop(lower) 104 | heap.Push(upper, tmp) 105 | } 106 | previous = append(previous, x) 107 | } 108 | fmt.Fprintln(stdout, notifications) 109 | } 110 | -------------------------------------------------------------------------------- /fraudulent_activity_notifications/fraudulent_activity_notifications_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"9 5 2 3 4 2 3 6 8 4 5", "2\n"}, 13 | {"5 4 1 2 3 4 4", "0\n"}, 14 | {"5 2 5 4 3 2 1", "0\n"}, 15 | {"10 4 10 9 8 7 1 5 4 3 2 11", "1\n"}, 16 | } 17 | 18 | func TestFraudulentActivityNotifications(t *testing.T) { 19 | t.Parallel() 20 | for _, c := range testcases { 21 | stdin = strings.NewReader(c.in) 22 | buff := new(bytes.Buffer) 23 | stdout = buff 24 | main() 25 | out := buff.String() 26 | if out != c.out { 27 | t.Errorf("%v does not equal %v", out, c.out) 28 | } 29 | } 30 | } 31 | 32 | func BenchmarkFraudulentActivityNotifications(b *testing.B) { 33 | for i := 0; i < b.N; i++ { 34 | for _, c := range testcases { 35 | stdin = strings.NewReader(c.in) 36 | buff := new(bytes.Buffer) 37 | stdout = buff 38 | main() 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /grading_students/grading_students.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var grades int 15 | fmt.Fscanf(stdin, "%d", &grades) 16 | for i := 0; i < grades; i++ { 17 | var grade int 18 | fmt.Fscanf(stdin, "%d", &grade) 19 | if grade < 38 || grade%5 < 3 { 20 | fmt.Fprintln(stdout, grade) 21 | } else { 22 | fmt.Fprintln(stdout, (grade/5+1)*5) 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /grading_students/grading_students_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"4 73 67 38 33", "75\n67\n40\n33\n"}, 13 | } 14 | 15 | func TestGradingStudents(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkGradingStudents(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /hackerland_radio_transmitters/hackerland_radio_transmitters.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "sort" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | 13 | func main() { 14 | var n, k int 15 | fmt.Fscanf(stdin, "%d %d", &n, &k) 16 | houses := make([]int, n) 17 | for i := 0; i < n; i++ { 18 | fmt.Fscanf(stdin, "%d", &houses[i]) 19 | } 20 | sort.Ints(houses) 21 | antennas := 0 22 | pos := houses[0] 23 | sum := 0 24 | for i := 1; i < n; i++ { 25 | if diff := houses[i] - pos; diff <= k { 26 | sum += diff 27 | if sum <= k { 28 | pos = houses[i] 29 | } 30 | } else { 31 | pos = houses[i] 32 | antennas++ 33 | sum = 0 34 | } 35 | } 36 | fmt.Fprintln(stdout, antennas+1) 37 | } 38 | -------------------------------------------------------------------------------- /hackerland_radio_transmitters/hackerland_radio_transmitters_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"5 1 1 2 3 4 5", "2\n"}, 13 | {"8 2 7 2 4 6 5 9 12 11", "3\n"}, 14 | {"7 2 9 5 4 2 6 15 12", "4\n"}, 15 | } 16 | 17 | func TestHackerlandRadioTransmitters(t *testing.T) { 18 | t.Parallel() 19 | for _, c := range testcases { 20 | stdin = strings.NewReader(c.in) 21 | buff := new(bytes.Buffer) 22 | stdout = buff 23 | main() 24 | out := buff.String() 25 | if out != c.out { 26 | t.Errorf("%v does not equal %v", out, c.out) 27 | } 28 | } 29 | } 30 | 31 | func BenchmarkHackerlandRadioTransmitters(b *testing.B) { 32 | for i := 0; i < b.N; i++ { 33 | for _, c := range testcases { 34 | stdin = strings.NewReader(c.in) 35 | buff := new(bytes.Buffer) 36 | stdout = buff 37 | main() 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /hackerrank_in_a_string/hackerrank_in_a_string.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | hackerrank := "hackerrank" 14 | var n int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | for i := 0; i < n; i++ { 17 | var s string 18 | fmt.Fscanf(stdin, "%s", &s) 19 | hrpos := 0 20 | for j := 0; j < len(s); j++ { 21 | if hackerrank[hrpos] == s[j] { 22 | hrpos++ 23 | } 24 | if hrpos == len(hackerrank) { 25 | fmt.Fprintln(stdout, "YES") 26 | break 27 | } 28 | } 29 | if hrpos != len(hackerrank) { 30 | fmt.Fprintln(stdout, "NO") 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /hackerrank_in_a_string/hackerrank_in_a_string_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"2 hereiamstackerrank hackerworld", "YES\nNO\n"}, 13 | } 14 | 15 | func TestHackerrankInAString(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkHackerrankInAString(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /jumping_on_the_clouds/jumping_on_the_clouds.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var clouds, result, x int 15 | fmt.Fscanf(stdin, "%d", &clouds) 16 | steps := -1 17 | for i := 0; i < clouds; i++ { 18 | fmt.Fscanf(stdin, "%d", &x) 19 | if x == 0 { 20 | steps++ 21 | } else { 22 | result += (steps / 2) + (steps % 2) + 1 23 | steps = -1 24 | } 25 | } 26 | result += (steps / 2) + (steps % 2) 27 | fmt.Fprintln(stdout, result) 28 | } 29 | -------------------------------------------------------------------------------- /jumping_on_the_clouds/jumping_on_the_clouds_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"7 0 0 1 0 0 1 0", "4\n"}, 13 | {"6 0 0 0 0 1 0", "3\n"}, 14 | {"6 0 0 0 1 0 0", "3\n"}, 15 | } 16 | 17 | func TestJumpingOnTheClouds(t *testing.T) { 18 | t.Parallel() 19 | for _, c := range testcases { 20 | stdin = strings.NewReader(c.in) 21 | buff := new(bytes.Buffer) 22 | stdout = buff 23 | main() 24 | out := buff.String() 25 | if out != c.out { 26 | t.Errorf("%v does not equal %v", out, c.out) 27 | } 28 | } 29 | } 30 | 31 | func BenchmarkJumpingOnTheClouds(b *testing.B) { 32 | for i := 0; i < b.N; i++ { 33 | for _, c := range testcases { 34 | stdin = strings.NewReader(c.in) 35 | buff := new(bytes.Buffer) 36 | stdout = buff 37 | main() 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /jumping_on_the_clouds_revisited/jumping_on_the_clouds_revisited.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, k int 15 | fmt.Fscanf(stdin, "%d %d", &n, &k) 16 | clouds := make([]int, n) 17 | for i := 0; i < n; i++ { 18 | fmt.Fscanf(stdin, "%d", &clouds[i]) 19 | } 20 | 21 | e := 100 22 | pos := 0 23 | for { 24 | pos = (pos + k) % n 25 | if clouds[pos] == 0 { 26 | e = e - 1 27 | } else { 28 | e = e - 3 29 | } 30 | if pos == 0 { 31 | break 32 | } 33 | } 34 | fmt.Fprintln(stdout, e) 35 | } 36 | -------------------------------------------------------------------------------- /jumping_on_the_clouds_revisited/jumping_on_the_clouds_revisited_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"8 2 0 0 1 0 0 1 1 0", "92\n"}, 13 | } 14 | 15 | func TestJumpingOnTheCloudsRevisited(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkJumpingOnTheCloudsRevisited(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /kangaroo/kangaroo.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var x1, v1, x2, v2 int 15 | fmt.Fscanf(stdin, "%d %d %d %d", &x1, &v1, &x2, &v2) 16 | deltaX := x2 - x1 17 | deltaV := v1 - v2 18 | if deltaV != 0 && deltaX%deltaV == 0 && deltaX/deltaV > 0 { 19 | fmt.Fprintln(stdout, "YES") 20 | } else { 21 | fmt.Fprintln(stdout, "NO") 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /kangaroo/kangaroo_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"0 3 4 2", "YES\n"}, 13 | {"0 2 5 3", "NO\n"}, 14 | } 15 | 16 | func TestKangaroo(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkKangaroo(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /library_fine/library_fine.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var am, ad, ay int 15 | fmt.Fscanf(stdin, "%d %d %d", &ad, &am, &ay) 16 | var em, ed, ey int 17 | fmt.Fscanf(stdin, "%d %d %d", &ed, &em, &ey) 18 | 19 | fine := 0 20 | if ay > ey { 21 | fine = 10000 22 | } else if ay == ey && am > em { 23 | fine = 500 * (am - em) 24 | } else if ay == ey && am == em && ad > ed { 25 | fine = 15 * (ad - ed) 26 | } 27 | fmt.Fprintln(stdout, fine) 28 | } 29 | -------------------------------------------------------------------------------- /library_fine/library_fine_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"9 6 2015 6 6 2015", "45\n"}, 13 | {"9 6 2015 6 6 2014", "10000\n"}, 14 | {"9 7 2015 6 6 2015", "500\n"}, 15 | } 16 | 17 | func TestLibraryFine(t *testing.T) { 18 | t.Parallel() 19 | for _, c := range testcases { 20 | stdin = strings.NewReader(c.in) 21 | buff := new(bytes.Buffer) 22 | stdout = buff 23 | main() 24 | out := buff.String() 25 | if out != c.out { 26 | t.Errorf("%v does not equal %v", out, c.out) 27 | } 28 | } 29 | } 30 | 31 | func BenchmarkLibraryFine(b *testing.B) { 32 | for i := 0; i < b.N; i++ { 33 | for _, c := range testcases { 34 | stdin = strings.NewReader(c.in) 35 | buff := new(bytes.Buffer) 36 | stdout = buff 37 | main() 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /marcs_cakewalk/marcs_cakewalk.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "sort" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | 13 | func main() { 14 | var n int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | a := make([]int, n) 17 | for i := 0; i < n; i++ { 18 | fmt.Fscanf(stdin, "%d", &a[i]) 19 | } 20 | sort.Sort(sort.Reverse(sort.IntSlice(a))) 21 | result := 0 22 | twos := 1 23 | for _, c := range a { 24 | result += c * twos 25 | twos *= 2 26 | } 27 | fmt.Fprintln(stdout, result) 28 | } 29 | -------------------------------------------------------------------------------- /marcs_cakewalk/marcs_cakewalk_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"3 1 3 2", "11\n"}, 13 | } 14 | 15 | func TestMarcsCakewalk(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkMarcsCakewalk(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /migratory_birds/migratory_birds.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var n int 14 | fmt.Fscanf(stdin, "%d", &n) 15 | var types [5]int 16 | for i := 0; i < n; i++ { 17 | var t int 18 | fmt.Fscanf(stdin, "%d", &t) 19 | types[t-1]++ 20 | } 21 | max := -1 22 | maxi := -1 23 | for i := 0; i < len(types); i++ { 24 | if types[i] > max { 25 | max = types[i] 26 | maxi = i 27 | } 28 | } 29 | fmt.Fprintln(stdout, maxi+1) 30 | } 31 | -------------------------------------------------------------------------------- /migratory_birds/migratory_birds_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"6 1 4 4 4 5 3", "4\n"}, 13 | } 14 | 15 | func TestMigratoryBirds(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkMigratoryBirds(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /mini_max_sum/mini_max_sum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "sort" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | var stderr io.Writer = os.Stderr 13 | 14 | func main() { 15 | a := make([]int, 5) 16 | sum := 0 17 | for i := range a { 18 | fmt.Fscanf(stdin, "%d", &a[i]) 19 | sum += a[i] 20 | } 21 | sort.Ints(a) 22 | fmt.Fprintln(stdout, sum-a[len(a)-1], sum-a[0]) 23 | } 24 | -------------------------------------------------------------------------------- /mini_max_sum/mini_max_sum_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"1 2 3 4 5", "10 14\n"}, 13 | } 14 | 15 | func TestMiniMaxSum(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkMiniMaxSum(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /minimum_absolute_difference_in_an_array/minimum_absolute_difference_in_an_array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "sort" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | 13 | func main() { 14 | var n int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | a := make([]int, n) 17 | for i := 0; i < n; i++ { 18 | fmt.Fscanf(stdin, "%d", &a[i]) 19 | } 20 | sort.Ints(a) 21 | minimum := a[1] - a[0] 22 | for i := 1; i < n; i++ { 23 | if diff := a[i] - a[i-1]; diff < minimum { 24 | minimum = diff 25 | } 26 | } 27 | fmt.Fprintln(stdout, minimum) 28 | } 29 | -------------------------------------------------------------------------------- /minimum_absolute_difference_in_an_array/minimum_absolute_difference_in_an_array_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"3 3 -7 0", "3\n"}, 13 | } 14 | 15 | func TestMinimumAbsoluteDifferenceInAnArray(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkMinimumAbsoluteDifferenceInAnArray(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /modified_kaprekar_numbers/modified_kaprekar_numbers.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var p, q, answers int 15 | fmt.Fscanf(stdin, "%d", &p) 16 | fmt.Fscanf(stdin, "%d", &q) 17 | for i := p; i <= q; i++ { 18 | x := i * i 19 | d := digits(i) 20 | l, r := split(x, d) 21 | if l+r == i { 22 | answers++ 23 | fmt.Fprintf(stdout, "%d ", i) 24 | } 25 | } 26 | if answers == 0 { 27 | fmt.Fprint(stdout, "INVALID RANGE") 28 | } 29 | fmt.Fprintln(stdout) 30 | } 31 | 32 | func digits(x int) int { 33 | result := 1 34 | for x > 0 { 35 | x /= 10 36 | result *= 10 37 | } 38 | return result 39 | } 40 | 41 | func split(x, d int) (l, r int) { 42 | l, r = 0, 0 43 | r = x % d 44 | x /= d 45 | l = x 46 | return l, r 47 | } 48 | -------------------------------------------------------------------------------- /modified_kaprekar_numbers/modified_kaprekar_numbers_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"1 100", "1 9 45 55 99 \n"}, 13 | {"56 98", "INVALID RANGE\n"}, 14 | } 15 | 16 | func TestModifiedKaprekarNumbers(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkModifiedKaprekarNumbers(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /non_divisible_subset/non_divisible_subset.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, k, x, result int 15 | fmt.Fscanf(stdin, "%d %d", &n, &k) 16 | mod := make([]int, k) 17 | for i := 0; i < n; i++ { 18 | fmt.Fscanf(stdin, "%d", &x) 19 | mod[x%k]++ // store count of remainders 20 | } 21 | for i := 0; i < k/2+1; i++ { 22 | if i == 0 || k == i*2 { 23 | if mod[i] != 0 { 24 | result++ 25 | } 26 | } else { 27 | if mod[i] > mod[k-i] { 28 | result += mod[i] 29 | } else { 30 | result += mod[k-i] 31 | } 32 | } 33 | } 34 | fmt.Fprintln(stdout, result) 35 | } 36 | -------------------------------------------------------------------------------- /non_divisible_subset/non_divisible_subset_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"4 3 1 7 2 4", "3\n"}, 13 | {"10 5 770528134 663501748 384261537 800309024 103668401 538539662 385488901 101262949 557792122 46058493", "6\n"}, 14 | {"6 9 422346306 940894801 696810740 862741861 85835055 313720373", "5\n"}, 15 | {"3 10 10 20 30", "1\n"}, 16 | {"3 10 10 20 35", "2\n"}, 17 | } 18 | 19 | func TestNonDivisibleSubset(t *testing.T) { 20 | t.Parallel() 21 | for _, c := range testcases { 22 | stdin = strings.NewReader(c.in) 23 | buff := new(bytes.Buffer) 24 | stdout = buff 25 | main() 26 | out := buff.String() 27 | if out != c.out { 28 | t.Errorf("%v does not equal %v", out, c.out) 29 | } 30 | } 31 | } 32 | 33 | func BenchmarkNonDivisibleSubset(b *testing.B) { 34 | for i := 0; i < b.N; i++ { 35 | for _, c := range testcases { 36 | stdin = strings.NewReader(c.in) 37 | buff := new(bytes.Buffer) 38 | stdout = buff 39 | main() 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /organizing_containers_of_balls/organizing_containers_of_balls.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var queries int 15 | fmt.Fscanf(stdin, "%d", &queries) 16 | for query := 0; query < queries; query++ { 17 | var n int 18 | fmt.Fscanf(stdin, "%d", &n) 19 | a, b := make([]int, n), make([]int, n) 20 | for i := 0; i < n; i++ { 21 | for j := 0; j < n; j++ { 22 | var x int 23 | fmt.Fscanf(stdin, "%d", &x) 24 | a[i] += x 25 | b[j] += x 26 | } 27 | } 28 | result := "Possible" 29 | for i := 0; i < n; i++ { 30 | j := 0 31 | for ; j < n; j++ { 32 | if a[i] == b[j] { 33 | a[i], b[j] = b[j], a[i] 34 | break 35 | } 36 | } 37 | if j == n { 38 | result = "Impossible" 39 | break 40 | } 41 | } 42 | fmt.Fprintln(stdout, result) 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /organizing_containers_of_balls/organizing_containers_of_balls_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"2 2 1 1 1 1 2 0 2 1 1", "Possible\nImpossible\n"}, 13 | } 14 | 15 | func TestOrganizingContainersOfBalls(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkOrganizingContainersOfBalls(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /picking_numbers/picking_numbers.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "sort" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | 13 | func main() { 14 | var n int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | m := map[int]int{} 17 | for i := 0; i < n; i++ { 18 | var x int 19 | fmt.Fscanf(stdin, "%d", &x) 20 | m[x]++ 21 | } 22 | type tuple struct{ freq, num int } 23 | var tuples []tuple 24 | for num, freq := range m { 25 | tuples = append(tuples, tuple{num: num, freq: freq}) 26 | } 27 | sort.Slice(tuples, func(i, j int) bool { 28 | return tuples[i].num < tuples[j].num 29 | }) 30 | max := tuples[0].freq 31 | for i := 1; i < len(tuples); i++ { 32 | if freq := tuples[i].freq; freq > max { 33 | max = freq 34 | } 35 | if diff := tuples[i-1].num - tuples[i].num; diff >= -1 && diff <= 1 { 36 | sum := tuples[i-1].freq + tuples[i].freq 37 | if sum > max { 38 | max = sum 39 | } 40 | } 41 | } 42 | fmt.Fprintln(stdout, max) 43 | } 44 | -------------------------------------------------------------------------------- /picking_numbers/picking_numbers_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"6 4 6 5 3 3 1", "3\n"}, 13 | {"6 1 2 2 3 1 2", "5\n"}, 14 | } 15 | 16 | func TestPickingNumbers(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkPickingNumbers(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /plus_minus/plus_minus.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | var positive, negative, zeros float64 17 | for i := 0; i < n; i++ { 18 | var x int 19 | fmt.Fscanf(stdin, "%d", &x) 20 | if x > 0 { 21 | positive++ 22 | } else if x == 0 { 23 | zeros++ 24 | } else { 25 | negative++ 26 | } 27 | } 28 | nf := float64(n) 29 | fmt.Fprintf(stdout, "%.6f\n%.6f\n%.6f\n", positive/nf, negative/nf, zeros/nf) 30 | } 31 | -------------------------------------------------------------------------------- /plus_minus/plus_minus_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"6 -4 3 -9 0 4 1", "0.500000\n0.333333\n0.166667\n"}, 13 | } 14 | 15 | func TestPlusMinus(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkPlusMinus(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /queens_attack2/queens_attack2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | type pos struct { 14 | r, c int 15 | } 16 | 17 | func main() { 18 | var n, k, qr, qc, r, c, result int 19 | fmt.Fscanf(stdin, "%d %d", &n, &k) 20 | fmt.Fscanf(stdin, "%d %d", &qr, &qc) 21 | obstacles := make(map[pos]struct{}) 22 | for i := 0; i < k; i++ { 23 | fmt.Fscanf(stdin, "%d %d", &r, &c) 24 | obstacles[pos{r, c}] = struct{}{} 25 | } 26 | directions := [][]int{{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {1, 1}, {-1, -1}, {1, -1}, {-1, 1}} 27 | for _, d := range directions { 28 | for r, c := qr, qc; r <= n && r > 0 && c <= n && c > 0; r, c, result = r+d[0], c+d[1], result+1 { 29 | if r == qr && c == qc { 30 | result-- 31 | } else if _, found := obstacles[pos{r, c}]; found { 32 | break 33 | } 34 | } 35 | } 36 | fmt.Fprintln(stdout, result) 37 | } 38 | -------------------------------------------------------------------------------- /queens_attack2/queens_attack2_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"4 0 4 4", "9\n"}, 13 | {"5 3 4 3 5 5 4 2 2 3", "10\n"}, 14 | } 15 | 16 | func TestQueensAttack2(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkQueensAttack2(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /recursive_digit_sum/recursive_digit_sum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var n string 14 | var k int 15 | fmt.Fscanf(stdin, "%s %d", &n, &k) 16 | sum := 0 17 | for _, r := range n { 18 | sum += int(r - '0') 19 | } 20 | fmt.Fprintln(stdout, DigitSum(fmt.Sprint(sum*k))) 21 | } 22 | 23 | func DigitSum(x string) string { 24 | if len(x) == 1 { 25 | return x 26 | } 27 | sum := 0 28 | for _, r := range x { 29 | sum += int(r - '0') 30 | } 31 | x = fmt.Sprint(sum) 32 | if len(x) > 1 { 33 | x = DigitSum(x) 34 | } 35 | return x 36 | } 37 | -------------------------------------------------------------------------------- /recursive_digit_sum/recursive_digit_sum_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"148 3", "3\n"}, 13 | {"5 1", "5\n"}, 14 | {"5 2", "1\n"}, 15 | } 16 | 17 | func TestRecursiveDigitSum(t *testing.T) { 18 | t.Parallel() 19 | for _, c := range testcases { 20 | stdin = strings.NewReader(c.in) 21 | buff := new(bytes.Buffer) 22 | stdout = buff 23 | main() 24 | out := buff.String() 25 | if out != c.out { 26 | t.Errorf("%v does not equal %v", out, c.out) 27 | } 28 | } 29 | } 30 | 31 | func BenchmarkRecursiveDigitSum(b *testing.B) { 32 | for i := 0; i < b.N; i++ { 33 | for _, c := range testcases { 34 | stdin = strings.NewReader(c.in) 35 | buff := new(bytes.Buffer) 36 | stdout = buff 37 | main() 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /repeated_string/repeated_string.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var s string 15 | var n int 16 | fmt.Fscanf(stdin, "%s", &s) 17 | fmt.Fscanf(stdin, "%d", &n) 18 | full := n / len(s) 19 | rem := n % len(s) 20 | var aCount, aPartial int 21 | for i, r := range s { 22 | if r == 'a' { 23 | aCount++ 24 | if i < rem { 25 | aPartial++ 26 | } 27 | } 28 | } 29 | result := full*aCount + aPartial 30 | fmt.Fprintln(stdout, result) 31 | } 32 | -------------------------------------------------------------------------------- /repeated_string/repeated_string_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"aba 10", "7\n"}, 13 | {"a 1000000000000", "1000000000000\n"}, 14 | } 15 | 16 | func TestRepeatedString(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkRepeatedString(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /save_the_prisoner/save_the_prisoner.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var testCases, n, m, s int 15 | fmt.Fscanf(stdin, "%d", &testCases) 16 | for test := 0; test < testCases; test++ { 17 | fmt.Fscanf(stdin, "%d %d %d", &n, &m, &s) 18 | if pos := (s - 1 + m) % n; pos == 0 { 19 | fmt.Fprintln(stdout, n) 20 | } else { 21 | fmt.Fprintln(stdout, pos) 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /save_the_prisoner/save_the_prisoner_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"2 5 2 1 5 2 2", "2\n3\n"}, 13 | {"1 3 3 1", "3\n"}, 14 | } 15 | 16 | func TestSaveThePrisoner(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkSaveThePrisoner(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /separate_the_numbers/separate_the_numbers.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "strconv" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | 13 | func main() { 14 | var q int 15 | fmt.Fscanf(stdin, "%d", &q) 16 | for i := 0; i < q; i++ { 17 | var s string 18 | fmt.Fscanf(stdin, "%s", &s) 19 | var found = false 20 | for l := 1; l <= len(s)/2; l++ { 21 | n, _ := strconv.Atoi(s[0:l]) 22 | index := l 23 | for index < len(s) { 24 | n++ 25 | x := fmt.Sprintf("%d", n) 26 | if index+len(x) > len(s) || s[index:index+len(x)] != x { 27 | break 28 | } 29 | index += len(x) 30 | } 31 | if index >= len(s) { 32 | found = true 33 | fmt.Fprintln(stdout, "YES", s[0:l]) 34 | break 35 | } 36 | } 37 | if !found { 38 | fmt.Fprintln(stdout, "NO") 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /separate_the_numbers/separate_the_numbers_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"7 1234 91011 99100 101103 010203 13 1", "YES 1\nYES 9\nYES 99\nNO\nNO\nNO\nNO\n"}, 13 | } 14 | 15 | func TestSeparateTheNumbers(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkSeparateTheNumbers(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /sequence_equation/sequence_equation.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, x int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | lookupByVal := map[int]int{} 17 | lookupByPos := map[int]int{} 18 | for i := 0; i < n; i++ { 19 | fmt.Fscanf(stdin, "%d", &x) 20 | lookupByVal[x] = i + 1 21 | lookupByPos[i+1] = x 22 | } 23 | for i := 0; i < n; i++ { 24 | pos := lookupByVal[i+1] 25 | pos2 := lookupByVal[pos] 26 | fmt.Fprintln(stdout, pos2) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /sequence_equation/sequence_equation_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"3 2 3 1", "2\n3\n1\n"}, 13 | } 14 | 15 | func TestSequenceEquation(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkSequenceEquation(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /sherlock_and_squares/sherlock_and_squares.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "math" 7 | "os" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | var stderr io.Writer = os.Stderr 13 | 14 | func main() { 15 | var tests, a, b int 16 | fmt.Fscanf(stdin, "%d", &tests) 17 | for t := 0; t < tests; t++ { 18 | fmt.Fscanf(stdin, "%d %d", &a, &b) 19 | low := int(math.Sqrt(float64(a))) 20 | count := 0 21 | for i := low; math.Pow(float64(i), float64(2)) <= float64(b); i++ { 22 | if math.Pow(float64(i), float64(2)) >= float64(a) { 23 | count++ 24 | } 25 | } 26 | fmt.Fprintln(stdout, count) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /sherlock_and_squares/sherlock_and_squares_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"2 3 9 17 24", "2\n0\n"}, 13 | } 14 | 15 | func TestSherlockAndSquares(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkSherlockAndSquares(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /simple_array_sum/simple_array_sum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var n int 14 | fmt.Fscanf(stdin, "%d", &n) 15 | sum := 0 16 | for i := 0; i < n; i++ { 17 | var x int 18 | fmt.Fscanf(stdin, "%d", &x) 19 | sum += x 20 | } 21 | fmt.Fprintln(stdout, sum) 22 | } 23 | -------------------------------------------------------------------------------- /simple_array_sum/simple_array_sum_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"6 1 2 3 4 10 11", "31\n"}, 13 | } 14 | 15 | func TestSimpleArraySum(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkSimpleArraySum(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /sock_merchant/sock_merchant.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, sock, result int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | socks := make(map[int]int) 17 | for i := 0; i < n; i++ { 18 | fmt.Fscanf(stdin, "%d", &sock) 19 | socks[sock]++ 20 | } 21 | for _, c := range socks { 22 | result += (c / 2) 23 | } 24 | fmt.Fprintln(stdout, result) 25 | } 26 | -------------------------------------------------------------------------------- /sock_merchant/sock_merchant_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"9 10 20 20 10 10 30 50 10 20", "3\n"}, 13 | } 14 | 15 | func TestSockMerchant(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkSockMerchant(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /staircase/staircase.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "strings" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | var stderr io.Writer = os.Stderr 13 | 14 | func main() { 15 | var n int 16 | fmt.Fscanf(stdin, "%d", &n) 17 | for i := 1; i <= n; i++ { 18 | fmt.Fprintf(stdout, "%s%s\n", strings.Repeat(" ", n-i), strings.Repeat("#", i)) 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /staircase/staircase_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"4", " #\n ##\n ###\n####\n"}, 13 | {"6", " #\n ##\n ###\n ####\n #####\n######\n"}, 14 | } 15 | 16 | func TestStaircase(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkStaircase(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /taum_and_bday/taum_and_bday.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var tests int 15 | fmt.Fscanf(stdin, "%d", &tests) 16 | for t := 0; t < tests; t++ { 17 | var b, w int 18 | fmt.Fscanf(stdin, "%d %d", &b, &w) 19 | var x, y, z int 20 | fmt.Fscanf(stdin, "%d %d %d", &x, &y, &z) 21 | result := 0 22 | if x+z < y { 23 | result = b*x + w*(x+z) 24 | } else if y+z < x { 25 | result = b*(y+z) + w*y 26 | } else { 27 | result = b*x + w*y 28 | } 29 | fmt.Fprintln(stdout, result) 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /taum_and_bday/taum_and_bday_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"5 10 10 1 1 1 5 9 2 3 4 3 6 9 1 1 7 7 4 2 1 3 3 1 9 2", "20\n37\n12\n35\n12\n"}, 13 | } 14 | 15 | func TestTaumAndBday(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkTaumAndBday(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /the_hurdle_race/the_hurdle_race.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, k, diff, height int 15 | fmt.Fscanf(stdin, "%d %d", &n, &k) 16 | for i := 0; i < n; i++ { 17 | fmt.Fscanf(stdin, "%d", &height) 18 | if height > k && height-k > diff { 19 | diff = height - k 20 | } 21 | } 22 | fmt.Fprintln(stdout, diff) 23 | } 24 | -------------------------------------------------------------------------------- /the_hurdle_race/the_hurdle_race_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"5 4 1 6 3 5 2", "2\n"}, 13 | {"5 7 2 5 4 5 2", "0\n"}, 14 | } 15 | 16 | func TestTheHurdleRace(t *testing.T) { 17 | t.Parallel() 18 | for _, c := range testcases { 19 | stdin = strings.NewReader(c.in) 20 | buff := new(bytes.Buffer) 21 | stdout = buff 22 | main() 23 | out := buff.String() 24 | if out != c.out { 25 | t.Errorf("%v does not equal %v", out, c.out) 26 | } 27 | } 28 | } 29 | 30 | func BenchmarkTheHurdleRace(b *testing.B) { 31 | for i := 0; i < b.N; i++ { 32 | for _, c := range testcases { 33 | stdin = strings.NewReader(c.in) 34 | buff := new(bytes.Buffer) 35 | stdout = buff 36 | main() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /the_power_sum/the_power_sum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var x int 14 | fmt.Fscanf(stdin, "%d", &x) 15 | var n int 16 | fmt.Fscanf(stdin, "%d", &n) 17 | fmt.Fprintln(stdout, PowerSum(0, 1, n, x)) 18 | } 19 | 20 | func PowerSum(sum, startWith, n, x int) int { 21 | if sum == x { 22 | return 1 23 | } 24 | count := 0 25 | for start := startWith; start < x; start++ { 26 | if newSum := sum + Power(start, n); newSum > x { 27 | break 28 | } else { 29 | count += PowerSum(newSum, start+1, n, x) 30 | } 31 | } 32 | return count 33 | } 34 | 35 | func Power(a, b int) int { 36 | result := 1 37 | for i := 0; i < b; i++ { 38 | result *= a 39 | } 40 | return result 41 | } 42 | -------------------------------------------------------------------------------- /the_power_sum/the_power_sum_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"5 2", "1\n"}, 13 | {"4 2", "1\n"}, 14 | {"6 2", "0\n"}, 15 | {"10 2", "1\n"}, 16 | {"100 2", "3\n"}, 17 | {"100 3", "1\n"}, 18 | {"1000 10", "0\n"}, 19 | } 20 | 21 | var powerTestcases = []struct { 22 | a, b, out int 23 | }{ 24 | {1, 3, 1}, 25 | {2, 2, 4}, 26 | {10, 2, 100}, 27 | } 28 | 29 | func TestThePowerSum(t *testing.T) { 30 | t.Parallel() 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | out := buff.String() 37 | if out != c.out { 38 | t.Errorf("%v does not equal %v", out, c.out) 39 | } 40 | } 41 | } 42 | 43 | func BenchmarkThePowerSum(b *testing.B) { 44 | for i := 0; i < b.N; i++ { 45 | for _, c := range testcases { 46 | stdin = strings.NewReader(c.in) 47 | buff := new(bytes.Buffer) 48 | stdout = buff 49 | main() 50 | } 51 | } 52 | } 53 | 54 | func TestPower(t *testing.T) { 55 | t.Parallel() 56 | for _, c := range powerTestcases { 57 | if out := Power(c.a, c.b); out != c.out { 58 | t.Errorf("For %d to the %d should be %d, but got %d", c.a, c.b, c.out, out) 59 | } 60 | } 61 | } 62 | 63 | func BenchmarkPower(b *testing.B) { 64 | for i := 0; i < b.N; i++ { 65 | for _, c := range powerTestcases { 66 | Power(c.a, c.b) 67 | } 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /time_conversion/time_conversion.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | "strconv" 8 | ) 9 | 10 | var stdin io.Reader = os.Stdin 11 | var stdout io.Writer = os.Stdout 12 | var stderr io.Writer = os.Stderr 13 | 14 | func main() { 15 | var line string 16 | fmt.Fscanln(stdin, &line) 17 | if meridiem := line[len(line)-2:]; meridiem == "AM" { 18 | if line[0:2] == "12" { 19 | fmt.Fprintf(stdout, "00%s\n", line[2:len(line)-2]) 20 | } else { 21 | fmt.Fprintln(stdout, line[0:len(line)-2]) 22 | } 23 | } else { 24 | if line[0:2] == "12" { 25 | fmt.Fprintf(stdout, "12%s\n", line[2:len(line)-2]) 26 | } else { 27 | h, _ := strconv.Atoi(line[0:2]) 28 | fmt.Fprintf(stdout, "%d%s\n", h+12, line[2:len(line)-2]) 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /time_conversion/time_conversion_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"12:05:45AM", "00:05:45\n"}, 13 | {"07:15:45AM", "07:15:45\n"}, 14 | {"12:05:45PM", "12:05:45\n"}, 15 | {"07:05:45PM", "19:05:45\n"}, 16 | } 17 | 18 | func TestTimeConversion(t *testing.T) { 19 | t.Parallel() 20 | for _, c := range testcases { 21 | stdin = strings.NewReader(c.in) 22 | buff := new(bytes.Buffer) 23 | stdout = buff 24 | main() 25 | out := buff.String() 26 | if out != c.out { 27 | t.Errorf("%v does not equal %v", out, c.out) 28 | } 29 | } 30 | } 31 | 32 | func BenchmarkTimeConversion(b *testing.B) { 33 | for i := 0; i < b.N; i++ { 34 | for _, c := range testcases { 35 | stdin = strings.NewReader(c.in) 36 | buff := new(bytes.Buffer) 37 | stdout = buff 38 | main() 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /utopian_tree/utopian_tree.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var tests int 15 | fmt.Fscanf(stdin, "%d", &tests) 16 | for t := 0; t < tests; t++ { 17 | height := 1 18 | var cycles int 19 | fmt.Fscanf(stdin, "%d", &cycles) 20 | for i := 0; i < cycles; i++ { 21 | if i%2 == 0 { 22 | height *= 2 23 | } else { 24 | height++ 25 | } 26 | } 27 | fmt.Fprintln(stdout, height) 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /utopian_tree/utopian_tree_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"3 0 1 4", "1\n2\n7\n"}, 13 | } 14 | 15 | func TestUtopianTree(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkUtopianTree(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /viral_advertising/viral_advertising.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | var stderr io.Writer = os.Stderr 12 | 13 | func main() { 14 | var n, result int 15 | fmt.Fscanf(stdin, "%d", &n) 16 | dayTotal := 5 17 | for i := 0; i < n; i++ { 18 | dayTotal = (dayTotal / 2) 19 | result += dayTotal 20 | dayTotal *= 3 21 | } 22 | fmt.Fprintln(stdout, result) 23 | } 24 | -------------------------------------------------------------------------------- /viral_advertising/viral_advertising_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"3", "9\n"}, 13 | } 14 | 15 | func TestViralAdvertising(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkViralAdvertising(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /weighted_uniform_strings/weighted_uniform_strings.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "os" 7 | ) 8 | 9 | var stdin io.Reader = os.Stdin 10 | var stdout io.Writer = os.Stdout 11 | 12 | func main() { 13 | var s string 14 | fmt.Fscanf(stdin, "%s", &s) 15 | u := make(map[int]struct{}) 16 | var last byte 17 | freq := 1 18 | for i := 0; i < len(s); i++ { 19 | if val := int(s[i] - 'a' + 1); s[i] != last { 20 | last = s[i] 21 | freq = 1 22 | u[val] = struct{}{} 23 | } else { 24 | freq++ 25 | u[val*freq] = struct{}{} 26 | } 27 | } 28 | var n int 29 | fmt.Fscanf(stdin, "%d", &n) 30 | for i := 0; i < n; i++ { 31 | var x int 32 | fmt.Fscanf(stdin, "%d", &x) 33 | if _, found := u[x]; found { 34 | fmt.Fprintln(stdout, "Yes") 35 | } else { 36 | fmt.Fprintln(stdout, "No") 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /weighted_uniform_strings/weighted_uniform_strings_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | var testcases = []struct { 10 | in, out string 11 | }{ 12 | {"abccddde 6 1 3 12 5 9 10", "Yes\nYes\nYes\nYes\nNo\nNo\n"}, 13 | } 14 | 15 | func TestWeightedUniformString(t *testing.T) { 16 | t.Parallel() 17 | for _, c := range testcases { 18 | stdin = strings.NewReader(c.in) 19 | buff := new(bytes.Buffer) 20 | stdout = buff 21 | main() 22 | out := buff.String() 23 | if out != c.out { 24 | t.Errorf("%v does not equal %v", out, c.out) 25 | } 26 | } 27 | } 28 | 29 | func BenchmarkWeightedUniformString(b *testing.B) { 30 | for i := 0; i < b.N; i++ { 31 | for _, c := range testcases { 32 | stdin = strings.NewReader(c.in) 33 | buff := new(bytes.Buffer) 34 | stdout = buff 35 | main() 36 | } 37 | } 38 | } 39 | --------------------------------------------------------------------------------