├── 2DArrays └── cutboard.go ├── README.md ├── UniversityCodeSprint2 ├── breakingtherecords.go └── separatethenumbers.go ├── algorithms ├── candy-replenishing-robot.go ├── graphtheory │ ├── journeytothemoon.go │ └── roads-and-libraries.go ├── greedy │ └── marks-cackewalk.go ├── implementation │ ├── apple-and-orange.go │ ├── beautiful-triplets.go │ ├── between-two-sets.go │ ├── chocolate-feast.go │ ├── designer-pdf-viewer.go │ ├── equalize-the-array.go │ ├── grading-students.go │ ├── libraryfine.go │ ├── minimaxsum.go │ ├── minimum-distances.go │ ├── modified-karpekar-numbers.go │ ├── repeated-string.go │ └── sequence-equation.go ├── melodious-password.go ├── recursion │ └── the-power-sum.go ├── search │ └── hackerank-radio-transmitters.go ├── strings │ ├── camelcase.go │ ├── game-of-thrones-1.go │ └── super-reduced-string.go └── warmup │ ├── circular-array-rotation.go │ └── kangaroo.go ├── botbuilding └── botsavesprincess.go ├── datastructures ├── arrays │ ├── dynamicarray.go │ └── left-rotation.go └── linkedlists │ └── delete-a-node.go ├── heaps └── findtherunningmedian.go ├── interview-preparation-kit └── arrays │ ├── 1.2d-array-ds.go │ ├── 2.arrays-left-rotation.go │ ├── 3.minimum-swaps-2.go │ └── 4.new-year-chaos.go ├── projecteuler └── 1multiplesof3and5.go ├── reverse-a-linked-list.go ├── weekofcode21 ├── kangaroo.go └── luckbalance.go └── weekofcode29 └── day-of-the-programmer.go /2DArrays/cutboard.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/contests/101hack53/challenges/cut-board 4 | // 2D Array 5 | // Covering 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func CutBoard(n, m, x, y int) { 12 | if (n*m-x-y)%2 == 1 { 13 | fmt.Println("NO") 14 | return 15 | } 16 | 17 | var ar [][]int 18 | ar = make([][]int, n) 19 | for i := 0; i < n; i++ { 20 | ar[i] = make([]int, m) 21 | } 22 | 23 | for i := 0; i < x; i++ { 24 | ar[0][i] = 1 25 | } 26 | 27 | for i := m - y; i < m; i++ { 28 | ar[n-1][i] = 1 29 | } 30 | 31 | for i := m - y; i < m; i++ { 32 | ar[n-1][i] = 1 33 | } 34 | 35 | var result []string 36 | result = append(result, "YES") 37 | result = append(result, fmt.Sprint((n*m-x-y)/2)) 38 | for i := 0; i < n; i++ { 39 | for j := 0; j < m; j++ { 40 | if ar[i][j] == 1 { 41 | continue 42 | } 43 | 44 | if (j != m-1 && ar[i][j+1] != 1) && 45 | !(i == n-2 && ar[i+1][j] != 1) { 46 | ar[i][j] = 1 47 | ar[i][j+1] = 1 48 | result = append(result, fmt.Sprint(i+1, j+1, i+1, j+2)) 49 | } else if ar[i+1][j] != 1 { 50 | ar[i][j] = 1 51 | ar[i+1][j] = 1 52 | result = append(result, fmt.Sprint(i+1, j+1, i+2, j+1)) 53 | } else { 54 | fmt.Println("NO") 55 | return 56 | } 57 | } 58 | } 59 | 60 | for _, r := range result { 61 | fmt.Println(r) 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # go-hackerrank 2 | My solutions for hackerrank.com 3 | 4 | My page there: https://www.hackerrank.com/irlndts 5 | 6 | # Interview Preparation Kit 7 | 8 | | Num | Folder | Name | Level | Solution | 9 | |------|-------|-------|-------|-----| 10 | | 1 | Arrays | [2D Array - DS](https://www.hackerrank.com/challenges/2d-array/) | Easy | [✓](interview-preparation-kit/arrays/1.2d-array-ds.go) | 11 | | 2 | Arrays | [Arrays: Left Rotation](https://www.hackerrank.com/challenges/ctci-array-left-rotation/) | Easy | [✓](interview-preparation-kit/arrays/2.arrays-left-rotation.go) | 12 | | 3 | Arrays | [Minimum Swaps 2](https://www.hackerrank.com/challenges/minimum-swaps-2/) | Medium | [✓](interview-preparation-kit/arrays/3.minimum-swaps-2.go) | 13 | | 4 | Arrays | [New Year Chaos](https://www.hackerrank.com/challenges/new-year-chaos/) | Medium | [✓](interview-preparation-kit/arrays/4.new-year-chaos.go) | 14 | | 5 | Arrays | [Array Manipulation](www.hackerrank.com/challenges/crush/) | Hard | TODO | 15 | |6|...|||| 16 | 17 | 11 out of 65 are solved. 18 | -------------------------------------------------------------------------------- /UniversityCodeSprint2/breakingtherecords.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | /* 6 | func main() { 7 | fmt.Println(BreakingTheRecords()) 8 | } 9 | */ 10 | 11 | func BreakingTheRecords() (int, int) { 12 | // init input data 13 | var N int 14 | fmt.Scan(&N) 15 | 16 | ar := make([]int, N) 17 | for i := 0; i < N; i++ { 18 | fmt.Scan(&ar[i]) 19 | } 20 | 21 | //logic 22 | best, worst := 0, 0 23 | cbest, cworst := ar[0], ar[0] 24 | for i := 1; i < N; i++ { 25 | switch { 26 | case ar[i] > cbest: 27 | best++ 28 | cbest = ar[i] 29 | case ar[i] < cworst: 30 | worst++ 31 | cworst = ar[i] 32 | } 33 | } 34 | 35 | return best, worst 36 | } 37 | -------------------------------------------------------------------------------- /UniversityCodeSprint2/separatethenumbers.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //https://www.hackerrank.com/contests/university-codesprint-2/challenges/separate-the-numbers 4 | 5 | import ( 6 | "fmt" 7 | "strconv" 8 | ) 9 | 10 | func main() { 11 | SeparateTheNumbers() 12 | } 13 | 14 | func SeparateTheNumbers() { 15 | var N int 16 | fmt.Scan(&N) 17 | 18 | var str string 19 | for i := 0; i < N; i++ { 20 | fmt.Scan(&str) 21 | fmt.Println(Line(str)) 22 | } 23 | } 24 | 25 | func Line(str string) (string, string) { 26 | if len(str) == 1 { 27 | return "NO", "" 28 | } 29 | 30 | for j := 1; j <= len(str)/2; j++ { 31 | result, val := SeparateLine(j, str) 32 | if result { 33 | return "YES", strconv.Itoa(val) 34 | } 35 | } 36 | return "NO", "" 37 | } 38 | 39 | func SeparateLine(step int, str string) (bool, int) { 40 | begin := true 41 | var tmp, first int 42 | nines := "" 43 | for i := 0; i < step; i++ { 44 | nines = nines + "9" 45 | } 46 | for from := 0; from < len(str); from = from + step { 47 | to := from + step 48 | if len(str) < to { 49 | return false, first 50 | } 51 | 52 | d, _ := strconv.Atoi(str[from:to]) 53 | if len(str[from:to]) != len(strconv.Itoa(d)) { 54 | return false, first 55 | } 56 | 57 | if str[from:to] == nines { 58 | // next decimal 59 | step++ 60 | from-- 61 | } 62 | 63 | if begin { 64 | begin = false 65 | first = d 66 | tmp = d 67 | continue 68 | } 69 | if d != (tmp + 1) { 70 | return false, first 71 | } 72 | tmp = d 73 | } 74 | 75 | return true, first 76 | } 77 | -------------------------------------------------------------------------------- /algorithms/candy-replenishing-robot.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /* 4 | func main() { 5 | var N, T int 6 | fmt.Scanf("%v %v", &N, &T) 7 | 8 | buf := N 9 | 10 | var result int 11 | for i := 0; i < (T - 1); i++ { 12 | var c int 13 | fmt.Scan(&c) 14 | 15 | buf = buf - c 16 | if buf < 5 { 17 | result += N - buf 18 | buf = N 19 | } 20 | } 21 | fmt.Println(result) 22 | } 23 | */ 24 | -------------------------------------------------------------------------------- /algorithms/graphtheory/journeytothemoon.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | /* 6 | func main() { 7 | var N, A int 8 | fmt.Scanf("%v %v", &A, &N) 9 | 10 | astronauts := make(map[int][]int) 11 | 12 | for i := 0; i < N; i++ { 13 | var self, friend int 14 | fmt.Scanf("%v %v", &self, &friend) 15 | astronauts[self] = append(astronauts[self], friend) 16 | astronauts[friend] = append(astronauts[friend], self) 17 | } 18 | 19 | fmt.Printf("%+v\n", astronauts) 20 | result := 0 21 | for _, v := range astronauts { 22 | result += A - len(v) - 1 23 | } 24 | fmt.Println(result / 2) 25 | } 26 | */ 27 | -------------------------------------------------------------------------------- /algorithms/graphtheory/roads-and-libraries.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Node struct { 6 | edges []int 7 | 8 | counter int 9 | cost int 10 | checked bool 11 | } 12 | 13 | /* 14 | func main() { 15 | var Q int 16 | fmt.Scan(&Q) 17 | for i := 0; i < Q; i++ { 18 | fmt.Println(RoadsAndLibraries()) 19 | } 20 | } 21 | */ 22 | 23 | func DFS(nodes []Node, j, i, c int) []Node { 24 | if !nodes[i].checked { 25 | 26 | if !nodes[i].checked { 27 | nodes[j].cost++ 28 | } 29 | 30 | nodes[i].checked = true 31 | nodes[i].counter = c 32 | 33 | for _, v := range nodes[i].edges { 34 | nodes = DFS(nodes, j, v, nodes[i].counter+1) 35 | } 36 | } 37 | return nodes 38 | } 39 | 40 | func RoadsAndLibraries() int { 41 | var N, M, clib, croad int 42 | fmt.Scanf("%d %d %d %d", &N, &M, &clib, &croad) 43 | 44 | nodes := make([]Node, N) 45 | for i := 0; i < M; i++ { 46 | var a, b int 47 | fmt.Scanf("%v %v", &a, &b) 48 | 49 | // fix the indexes 50 | a-- 51 | b-- 52 | 53 | nodes[a].edges = append(nodes[a].edges, b) 54 | nodes[b].edges = append(nodes[b].edges, a) 55 | } 56 | 57 | if clib <= croad { 58 | return clib * N 59 | } 60 | 61 | for i := 0; i < N; i++ { 62 | if !nodes[i].checked { 63 | nodes = DFS(nodes, i, i, 0) 64 | } 65 | } 66 | 67 | result := 0 68 | for i := 0; i < N; i++ { 69 | if nodes[i].cost != 0 { 70 | result += clib + (nodes[i].cost-1)*croad 71 | } 72 | } 73 | 74 | return result 75 | } 76 | -------------------------------------------------------------------------------- /algorithms/greedy/marks-cackewalk.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/marcs-cakewalk 4 | // 10 min 5 | 6 | import ( 7 | "fmt" 8 | "math" 9 | "sort" 10 | ) 11 | 12 | func main() { 13 | var N int 14 | fmt.Scan(&N) 15 | 16 | ar := make([]int, N) 17 | for i := 0; i < N; i++ { 18 | fmt.Scan(&ar[i]) 19 | } 20 | sort.Sort(sort.Reverse(sort.IntSlice(ar))) 21 | 22 | result := float64(0) 23 | for i := 0; i < N; i++ { 24 | result += float64(ar[i]) * math.Pow(2, float64(i)) 25 | } 26 | 27 | fmt.Printf("%0.f", result) 28 | 29 | } 30 | -------------------------------------------------------------------------------- /algorithms/implementation/apple-and-orange.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/apple-and-orange 4 | 5 | import "fmt" 6 | 7 | func main() { 8 | a, b := AppleAndOrange() 9 | fmt.Printf("%d\n%d", a, b) 10 | } 11 | 12 | func AppleAndOrange() (apples int, oranges int) { 13 | var s, t, a, b, m, n int 14 | fmt.Scanf("%v %v", &s, &t) 15 | fmt.Scanf("%v %v", &a, &b) 16 | fmt.Scanf("%v %v", &m, &n) 17 | 18 | apples = Distance(a, s, t, m) 19 | oranges = Distance(b, s, t, n) 20 | 21 | return 22 | } 23 | 24 | func Distance(f, s, t, m int) (fruits int) { 25 | for i := 0; i < m; i++ { 26 | var fruit int 27 | fmt.Scan(&fruit) 28 | if (f+fruit) >= s && (f+fruit) <= t { 29 | fruits++ 30 | } 31 | } 32 | return 33 | } 34 | -------------------------------------------------------------------------------- /algorithms/implementation/beautiful-triplets.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/beautiful-triplets/problem 4 | 5 | func beautifulTriplets(d int32, arr []int32) int32 { 6 | result := int32(0) 7 | for i := 0; i < len(arr)-2; i++ { 8 | for j := i + 1; j < len(arr)-1; j++ { 9 | if arr[j]-arr[i] != d { 10 | continue 11 | } 12 | for k := j + 1; k < len(arr); k++ { 13 | if arr[k]-arr[j] == d { 14 | result++ 15 | } 16 | } 17 | } 18 | } 19 | return result 20 | } 21 | -------------------------------------------------------------------------------- /algorithms/implementation/between-two-sets.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var N, M int 7 | fmt.Scanf("%v %v", &N, &M) 8 | 9 | a := make([]int, N) 10 | b := make([]int, M) 11 | 12 | for i := 0; i < N; i++ { 13 | fmt.Scan(&a[i]) 14 | } 15 | for i := 0; i < M; i++ { 16 | fmt.Scan(&b[i]) 17 | } 18 | 19 | result := 0 20 | for i := a[len(a)-1]; i <= b[0]; i++ { 21 | if A(i, a) && B(i, b) { 22 | result++ 23 | } 24 | } 25 | fmt.Println(result) 26 | } 27 | 28 | func A(a int, ar []int) bool { 29 | for _, v := range ar { 30 | if a%v != 0 { 31 | return false 32 | } 33 | } 34 | return true 35 | } 36 | 37 | func B(b int, ar []int) bool { 38 | for _, v := range ar { 39 | if v%b != 0 { 40 | return false 41 | } 42 | 43 | } 44 | return true 45 | } 46 | -------------------------------------------------------------------------------- /algorithms/implementation/chocolate-feast.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/chocolate-feast/problem 4 | 5 | // Complete the chocolateFeast function below. 6 | func chocolateFeast(n int32, c int32, m int32) int32 { 7 | result := int(n / c) 8 | wrappers := result 9 | 10 | for { 11 | if wrappers < int(m) { 12 | return int32(result) 13 | } 14 | chocolates := int(wrappers / int(m)) 15 | result += chocolates 16 | wrappers = chocolates + (wrappers - chocolates*int(m)) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /algorithms/implementation/designer-pdf-viewer.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/designer-pdf-viewer 4 | 5 | import "fmt" 6 | 7 | /* 8 | func main() { 9 | fmt.Println(DesignerPDFViewer()) 10 | } 11 | */ 12 | 13 | func DesignerPDFViewer() int { 14 | ar := make([]int, 26) 15 | 16 | for i := 0; i < len(ar); i++ { 17 | fmt.Scan(&ar[i]) 18 | } 19 | 20 | var w string 21 | fmt.Scan(&w) 22 | 23 | var result int 24 | for _, l := range w { 25 | result = Max(result, ar[l-97]) 26 | } 27 | 28 | return result * len(w) 29 | } 30 | 31 | func Max(a, b int) int { 32 | if a > b { 33 | return a 34 | } 35 | return b 36 | } 37 | -------------------------------------------------------------------------------- /algorithms/implementation/equalize-the-array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // https://www.hackerrank.com/challenges/equality-in-a-array/problem 6 | 7 | func equalizeArray(arr []int32) int32 { 8 | m := make(map[int]int) 9 | for _, s := range arr { 10 | m[int(s)]++ 11 | } 12 | 13 | values := make([]int, 0, len(m)) 14 | for _, s := range m { 15 | values = append(values, s) 16 | } 17 | 18 | result := 0 19 | sort.Ints(values) 20 | for i := 0; i < len(values)-1; i++ { 21 | result += values[i] 22 | } 23 | return int32(result) 24 | } 25 | -------------------------------------------------------------------------------- /algorithms/implementation/grading-students.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/grading 4 | 5 | import "fmt" 6 | 7 | /* 8 | func main(){ 9 | grading() 10 | } 11 | */ 12 | 13 | func grading() { 14 | var N int 15 | fmt.Scan(&N) 16 | for i := 0; i < N; i++ { 17 | var v int 18 | fmt.Scan(&v) 19 | switch { 20 | case v < 38: 21 | fmt.Println(v) 22 | case v%5 == 0: 23 | fmt.Println(v) 24 | case (v+1)%5 == 0: 25 | fmt.Println(v + 1) 26 | case (v+2)%5 == 0: 27 | fmt.Println(v + 2) 28 | default: 29 | fmt.Println(v) 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /algorithms/implementation/libraryfine.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // https://www.hackerrank.com/challenges/library-fine 6 | 7 | func main() { 8 | fmt.Println(Check()) 9 | } 10 | 11 | func Check() int { 12 | var d, m, y int 13 | var D, M, Y int 14 | fmt.Scanf("%v %v %v", &d, &m, &y) 15 | fmt.Scanf("%v %v %v", &D, &M, &Y) 16 | 17 | switch { 18 | case y < Y: 19 | return 0 20 | case y > Y: 21 | return 10000 22 | } 23 | 24 | switch { 25 | case m < M: 26 | return 0 27 | case m > M: 28 | return (m - M) * 500 29 | } 30 | 31 | switch { 32 | case d < D: 33 | return 0 34 | case d > D: 35 | return (d - D) * 15 36 | } 37 | 38 | return 0 39 | } 40 | -------------------------------------------------------------------------------- /algorithms/implementation/minimaxsum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "sort" 6 | ) 7 | 8 | // https://www.hackerrank.com/challenges/mini-max-sum 9 | 10 | /* 11 | func main() { 12 | fmt.Println(MiniMaxSum()) 13 | } 14 | */ 15 | 16 | func MiniMaxSum() (int, int) { 17 | ar := make([]int, 5) 18 | for i := 0; i < len(ar); i++ { 19 | fmt.Scan(&ar[i]) 20 | } 21 | 22 | sort.Ints(ar) 23 | 24 | min := 0 25 | for i := 0; i < len(ar)-1; i++ { 26 | min += ar[i] 27 | } 28 | 29 | max := 0 30 | for i := 1; i < len(ar); i++ { 31 | max += ar[i] 32 | } 33 | 34 | return min, max 35 | } 36 | -------------------------------------------------------------------------------- /algorithms/implementation/minimum-distances.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/minimum-distances/problem 4 | 5 | func minimumDistances(a []int32) int32 { 6 | result := -1 7 | m := make(map[int32]int) 8 | 9 | for i := 0; i < len(a); i++ { 10 | pos, ok := m[a[i]] 11 | if ok { 12 | distance := i - pos 13 | if result == -1 || distance < result { 14 | result = distance 15 | } 16 | } 17 | m[a[i]] = i 18 | } 19 | 20 | return int32(result) 21 | } 22 | -------------------------------------------------------------------------------- /algorithms/implementation/modified-karpekar-numbers.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strconv" 6 | ) 7 | 8 | // https://www.hackerrank.com/challenges/kaprekar-numbers/problem 9 | 10 | // Complete the kaprekarNumbers function below. 11 | func kaprekarNumbers(p int32, q int32) { 12 | var result []int 13 | for i := int(p); i <= int(q); i++ { 14 | l := len(strconv.Itoa(i)) 15 | sq := strconv.Itoa(i * i) 16 | left, _ := strconv.Atoi(sq[:len(sq)-l]) 17 | right, _ := strconv.Atoi(sq[len(sq)-l:]) 18 | if left+right == i { 19 | result = append(result, i) 20 | } 21 | } 22 | if len(result) == 0 { 23 | fmt.Printf("INVALID RANGE") 24 | return 25 | } 26 | 27 | for _, v := range result { 28 | fmt.Printf("%v ", v) 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /algorithms/implementation/repeated-string.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/repeated-string/problem 4 | 5 | // Complete the repeatedString function below. 6 | func repeatedString(s string, n int64) int64 { 7 | var result int 8 | for i, l := range s { 9 | if int64(i) == n { 10 | break 11 | } 12 | if string(l) == "a" { 13 | result++ 14 | } 15 | } 16 | 17 | repeats := int(int(n) / len(s)) 18 | result *= repeats 19 | 20 | rest := int(n) - len(s)*repeats 21 | for i := 0; i < rest; i++ { 22 | if string(s[i]) == "a" { 23 | result++ 24 | } 25 | } 26 | 27 | return int64(result) 28 | } 29 | -------------------------------------------------------------------------------- /algorithms/implementation/sequence-equation.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/permutation-equation/problem 4 | 5 | // Complete the permutationEquation function below. 6 | func permutationEquation(p []int32) []int32 { 7 | sorted := make([]int, len(p)) 8 | for i, v := range p { 9 | sorted[v-1] = i 10 | } 11 | 12 | result := make([]int32, 0, len(p)) 13 | for i := 0; i < len(p); i++ { 14 | result = append(result, int32(sorted[sorted[i]])+1) 15 | } 16 | return result 17 | } 18 | -------------------------------------------------------------------------------- /algorithms/melodious-password.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | ) 7 | 8 | const ( 9 | vowels = "aeiou" 10 | consonant = "bcdfghjklmnpqrstvwxz" 11 | alphabet = "abcdefghijklmnopqurstvwxz" 12 | ) 13 | 14 | // Melodious password 15 | // https://www.hackerrank.com/contests/w30/challenges/melodious-password 16 | 17 | /* 18 | func main() { 19 | var N int 20 | fmt.Scan(&N) 21 | 22 | Melodious(N, "") 23 | } 24 | */ 25 | 26 | func Melodious(N int, str string) { 27 | for i := 0; i < len(alphabet); i++ { 28 | if len(str) < N { 29 | if len(str) != 0 && 30 | ((strings.Contains(vowels, string(str[len(str)-1])) && strings.Contains(vowels, string(alphabet[i]))) || 31 | (strings.Contains(consonant, string(str[len(str)-1])) && strings.Contains(consonant, string(alphabet[i])))) { 32 | // skip... 33 | } else { 34 | buf := str + string(alphabet[i]) 35 | fmt.Println(buf) 36 | Melodious(N, buf) 37 | } 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /algorithms/recursion/the-power-sum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/the-power-sum 4 | // 20 mins 5 | 6 | import ( 7 | "fmt" 8 | "math" 9 | ) 10 | 11 | var ( 12 | result = 0 13 | N = float64(0) 14 | X = float64(0) 15 | ) 16 | 17 | func main() { 18 | fmt.Scan(&X) 19 | fmt.Scan(&N) 20 | for i := float64(1); i <= math.Sqrt(X); i++ { 21 | solve(i, 0) 22 | } 23 | fmt.Println(result) 24 | } 25 | 26 | func solve(i, c float64) { 27 | tmp := math.Pow(i, N) 28 | current := tmp + c 29 | 30 | if current == X { 31 | result++ 32 | } else if current < X { 33 | for j := i + 1; j <= math.Sqrt(X); j++ { 34 | solve(j, current) 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /algorithms/search/hackerank-radio-transmitters.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/hackerland-radio-transmitters 4 | 5 | import ( 6 | "fmt" 7 | "sort" 8 | ) 9 | 10 | func main() { 11 | var N, K int 12 | fmt.Scanf("%v %v", &N, &K) 13 | 14 | m := make(map[int]bool) 15 | for i := 0; i < N; i++ { 16 | var buf int 17 | fmt.Scan(&buf) 18 | m[buf] = false 19 | } 20 | 21 | var keys []int 22 | 23 | for k := range m { 24 | keys = append(keys, k) 25 | } 26 | sort.Ints(keys) 27 | 28 | result := 0 29 | for i := keys[0]; i <= keys[len(keys)-1]; i++ { 30 | _, ok := m[i] 31 | if ok && !m[i] { 32 | 33 | for j := i + K; j >= i; j-- { 34 | _, ok := m[j] 35 | if ok { 36 | result++ 37 | m[j] = true 38 | 39 | for l := j; l <= j+K; l++ { 40 | _, ok := m[l] 41 | if ok { 42 | m[l] = true 43 | } 44 | } 45 | 46 | for l := j; l >= j-K; l-- { 47 | _, ok := m[l] 48 | if ok { 49 | m[l] = true 50 | } 51 | } 52 | 53 | break 54 | } 55 | } 56 | } 57 | } 58 | fmt.Println(result) 59 | } 60 | -------------------------------------------------------------------------------- /algorithms/strings/camelcase.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/camelcase 4 | // 3 min 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | var s string 10 | fmt.Scan(&s) 11 | 12 | result := 1 13 | for i := 0; i < len(s); i++ { 14 | if s[i] >= 65 && s[i] <= 90 { 15 | result++ 16 | } 17 | } 18 | fmt.Println(result) 19 | } 20 | -------------------------------------------------------------------------------- /algorithms/strings/game-of-thrones-1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/game-of-thrones/problem 4 | 5 | // gameOfThrones function below. 6 | func gameOfThrones(s string) string { 7 | m := make(map[rune]int) 8 | for _, s := range s { 9 | m[s]++ 10 | } 11 | 12 | stop := false 13 | for _, v := range m { 14 | if v%2 != 0 { 15 | if stop { 16 | return "NO" 17 | } 18 | stop = true 19 | } 20 | } 21 | return "YES" 22 | } 23 | -------------------------------------------------------------------------------- /algorithms/strings/super-reduced-string.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/challenges/reduced-string 4 | // 13 min 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | var s string 10 | fmt.Scan(&s) 11 | 12 | N := len(s) 13 | 14 | for i := 0; i < N-1; { 15 | i++ 16 | if s[i] == s[i-1] { 17 | s = s[:i-1] + s[i+1:] 18 | i = 0 19 | N = N - 2 20 | } 21 | } 22 | 23 | if len(s) != 0 { 24 | fmt.Println(s) 25 | } else { 26 | fmt.Println("Empty String") 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /algorithms/warmup/circular-array-rotation.go: -------------------------------------------------------------------------------- 1 | package main 2 | import "fmt" 3 | 4 | // the original task is here https://www.hackerrank.com/challenges/circular-array-rotation 5 | 6 | func main() { 7 | var N, K, Q int 8 | // read the input 9 | fmt.Scanf("%v %v %v", &N, &K, &Q) 10 | ar := make([]int, N, N) 11 | for i := 0; i < N; i++ { 12 | fmt.Scan(&ar[i]) 13 | } 14 | 15 | if K > N { 16 | K = K - N * int(K/N) 17 | } 18 | 19 | ar = append(ar[N-K:],ar[:N-K]...) 20 | 21 | for i := 0; i < Q; i++{ 22 | var j int 23 | fmt.Scan(&j) 24 | fmt.Println(ar[j]) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /algorithms/warmup/kangaroo.go: -------------------------------------------------------------------------------- 1 | package main 2 | import "fmt" 3 | 4 | func main() { 5 | var k1, s1, k2, s2 int 6 | fmt.Scanf("%v %v %v %v", &k1, &s1, &k2, &s2) 7 | 8 | fmt.Println(solve(k1,k2,s1,s2)) 9 | } 10 | 11 | func solve(k1,k2,s1,s2 int) string { 12 | for k1 != k2 { 13 | k1 += s1 14 | k2 += s2 15 | if k1 > k2 && s1 >= s2 { 16 | return "NO" 17 | } 18 | if k2 > k1 && s2 >= s1{ 19 | return "NO" 20 | } 21 | } 22 | return "YES" 23 | } 24 | -------------------------------------------------------------------------------- /botbuilding/botsavesprincess.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Bot saves princess 4 | // https://www.hackerrank.com/challenges/saveprincess/problem 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | 10 | var N int 11 | fmt.Scan(&N) 12 | 13 | var buf string 14 | var startX, startY int 15 | var finishX, finishY int 16 | for i := 0; i < N; i++ { 17 | fmt.Scan(&buf) 18 | for j := 0; j < N; j++ { 19 | switch string(buf[j]) { 20 | case "m": 21 | startX, startY = j, i 22 | case "p": 23 | finishX, finishY = j, i 24 | default: 25 | } 26 | } 27 | } 28 | 29 | switch MinMax(startY, finishY) { 30 | case 1: 31 | for i := startY; i > finishY; i-- { 32 | fmt.Println("UP") 33 | } 34 | case -1: 35 | for i := startY; i < finishY; i++ { 36 | fmt.Println("DOWN") 37 | } 38 | } 39 | 40 | // fmt.Println(startX, startY) 41 | // fmt.Println(finishX, finishY) 42 | 43 | switch MinMax(startX, finishX) { 44 | case 1: 45 | for i := startX; i > finishX; i-- { 46 | fmt.Println("LEFT") 47 | } 48 | case -1: 49 | for i := startX; i < finishX; i++ { 50 | fmt.Println("RIGHT") 51 | } 52 | } 53 | 54 | } 55 | 56 | func MinMax(a, b int) int { 57 | if a > b { 58 | return 1 59 | } else if a < b { 60 | return -1 61 | } 62 | return 0 63 | } 64 | -------------------------------------------------------------------------------- /datastructures/arrays/dynamicarray.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Solution for https://www.hackerrank.com/challenges/dynamic-array 4 | 5 | /* 6 | import "fmt" 7 | 8 | func main() { 9 | var N, Q int 10 | fmt.Scanf("%v %v", &N, &Q) 11 | 12 | var lastAns = 0 13 | var seqList [][]int 14 | seqList = make([][]int, N) 15 | for i := 0; i < N; i++ { 16 | seqList[i] = make([]int, 0) 17 | } 18 | 19 | for i := 0; i < Q; i++ { 20 | var key, x, y int 21 | fmt.Scanf("%v %v %v", &key, &x, &y) 22 | seq := (x ^ lastAns) % N 23 | if key == 1 { 24 | seqList[seq] = append(seqList[seq], y) 25 | } else { 26 | lastAns = seqList[seq][y%len(seqList[seq])] 27 | fmt.Println(lastAns) 28 | } 29 | } 30 | } 31 | */ 32 | -------------------------------------------------------------------------------- /datastructures/arrays/left-rotation.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | //https://www.hackerrank.com/challenges/array-left-rotation 6 | 7 | func main() { 8 | LeftRotation() 9 | } 10 | 11 | func LeftRotation() { 12 | var N, d int 13 | fmt.Scan(&N) 14 | fmt.Scan(&d) 15 | 16 | ar := make([]int, N) 17 | for i := 0; i < N; i++ { 18 | fmt.Scan(&ar[i]) 19 | } 20 | 21 | mid := d % N 22 | 23 | result := make([]int, N) 24 | result = append(ar[mid:], ar[:mid]...) 25 | for _, v := range result { 26 | fmt.Printf("%v ", v) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /datastructures/linkedlists/delete-a-node.go: -------------------------------------------------------------------------------- 1 | package linkedlist 2 | 3 | // https://www.hackerrank.com/challenges/delete-a-node-from-a-linked-list/problem 4 | 5 | type SinglyLinkedListNode struct { 6 | data int32 7 | next *SinglyLinkedListNode 8 | } 9 | 10 | func deleteNode(head *SinglyLinkedListNode, position int32) *SinglyLinkedListNode { 11 | if position == 0 { 12 | return head.next 13 | } 14 | 15 | start := head 16 | 17 | i := int32(0) 18 | for head.next != nil { 19 | if i+1 == position { 20 | head.next = head.next.next 21 | break 22 | } 23 | 24 | i++ 25 | head = head.next 26 | } 27 | 28 | return start 29 | } 30 | -------------------------------------------------------------------------------- /heaps/findtherunningmedian.go: -------------------------------------------------------------------------------- 1 | package heaps 2 | 3 | import "container/heap" 4 | 5 | // Find The Running Median 6 | // https://www.hackerrank.com/challenges/find-the-running-median/problem 7 | // Heaps 8 | 9 | // AddDelay adds a delay to the slice 10 | func (m *Median) AddDelay(delay int) { 11 | heap.Push(m.MaxHeap, delay) 12 | heap.Push(m.MinHeap, m.MaxHeap.Top()) 13 | heap.Pop(m.MaxHeap) 14 | 15 | if m.MaxHeap.Len() < m.MinHeap.Len() { 16 | heap.Push(m.MaxHeap, m.MinHeap.Top()) 17 | heap.Pop(m.MinHeap) 18 | } 19 | } 20 | 21 | // GetMedian returns a median value of the slice 22 | func (m Median) GetMedian() float64 { 23 | if m.MinHeap.Len() < m.MaxHeap.Len() { 24 | return float64(m.MaxHeap.Top()) 25 | } 26 | 27 | return float64(m.MaxHeap.Top()+m.MinHeap.Top()) * 0.5 28 | } 29 | 30 | type Median struct { 31 | MaxHeap *MaxHeap 32 | MinHeap *MinHeap 33 | Size int 34 | } 35 | 36 | func InitMedianQueue(size int) *Median { 37 | return &Median{ 38 | Size: size, 39 | MaxHeap: NewMaxHeap(), 40 | MinHeap: NewMinHeap(), 41 | } 42 | } 43 | 44 | // MEDIAN interfaces realizations 45 | // MaxHeap is a max heap of ints. 46 | type MaxHeap []int 47 | 48 | func (h MaxHeap) Len() int { return len(h) } 49 | func (h MaxHeap) Less(i, j int) bool { return h[i] < h[j] } 50 | func (h MaxHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } 51 | 52 | func (h *MaxHeap) Push(x interface{}) { 53 | *h = append(*h, x.(int)) 54 | } 55 | 56 | func (h *MaxHeap) Pop() interface{} { 57 | old := *h 58 | n := len(old) 59 | x := old[n-1] 60 | *h = old[0 : n-1] 61 | return x 62 | } 63 | 64 | func (h *MaxHeap) Top() int { 65 | a := *h 66 | if len(a) != 0 { 67 | return int(a[0]) 68 | } 69 | return 0 70 | } 71 | 72 | func NewMaxHeap() *MaxHeap { 73 | pq := &MaxHeap{} 74 | heap.Init(pq) 75 | return pq 76 | } 77 | 78 | // MinHeap is a min heap of ints. 79 | type MinHeap []int 80 | 81 | func (h MinHeap) Len() int { return len(h) } 82 | func (h MinHeap) Less(i, j int) bool { return h[i] > h[j] } 83 | func (h MinHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } 84 | 85 | func (h *MinHeap) Push(x interface{}) { 86 | *h = append(*h, x.(int)) 87 | } 88 | 89 | func (h *MinHeap) Pop() interface{} { 90 | old := *h 91 | n := len(old) 92 | x := old[n-1] 93 | *h = old[0 : n-1] 94 | return x 95 | } 96 | 97 | func (h *MinHeap) Top() int { 98 | a := *h 99 | if len(a) != 0 { 100 | return int(a[0]) 101 | } 102 | return 0 103 | } 104 | 105 | func NewMinHeap() *MinHeap { 106 | pq := &MinHeap{} 107 | heap.Init(pq) 108 | return pq 109 | } 110 | -------------------------------------------------------------------------------- /interview-preparation-kit/arrays/1.2d-array-ds.go: -------------------------------------------------------------------------------- 1 | package arrays 2 | 3 | // https://www.hackerrank.com/challenges/2d-array 4 | 5 | func sum(arr []int32) int32 { 6 | var result int32 7 | for _, v := range arr { 8 | result += v 9 | } 10 | 11 | return result 12 | } 13 | 14 | func minValue(arr [][]int32) int32 { 15 | var min int32 16 | for i := 0; i < len(arr); i++ { 17 | for j := 0; j < len(arr[0]); j++ { 18 | if arr[i][j] < min { 19 | min = arr[i][j] 20 | } 21 | } 22 | } 23 | if min < 0 { 24 | return min * 7 25 | } 26 | return 0 27 | } 28 | 29 | // Complete the hourglassSum function below. 30 | func hourglassSum(arr [][]int32) int32 { 31 | result := minValue(arr) 32 | for i := 0; i <= len(arr)-3; i++ { 33 | for j := 0; j <= len(arr[0])-3; j++ { 34 | buf := sum(arr[i][j:j+3]) + arr[i+1][j+1] + sum(arr[i+2][j:j+3]) 35 | if buf > result { 36 | result = buf 37 | } 38 | } 39 | } 40 | return result 41 | } 42 | -------------------------------------------------------------------------------- /interview-preparation-kit/arrays/2.arrays-left-rotation.go: -------------------------------------------------------------------------------- 1 | package arrays 2 | 3 | // https://www.hackerrank.com/challenges/ctci-array-left-rotation/ 4 | 5 | // Complete the rotLeft function below. 6 | func rotLeft(a []int32, d int32) []int32 { 7 | return append(a[d:], a[:d]...) 8 | } 9 | -------------------------------------------------------------------------------- /interview-preparation-kit/arrays/3.minimum-swaps-2.go: -------------------------------------------------------------------------------- 1 | package arrays 2 | 3 | import ( 4 | "sort" 5 | ) 6 | 7 | // https://www.hackerrank.com/challenges/minimum-swaps-2/ 8 | 9 | // Arr ... 10 | type Arr struct { 11 | value int32 12 | index int 13 | } 14 | 15 | // ByValue ... 16 | type ByValue []Arr 17 | 18 | func (a ByValue) Len() int { return len(a) } 19 | func (a ByValue) Swap(i, j int) { a[i], a[j] = a[j], a[i] } 20 | func (a ByValue) Less(i, j int) bool { return a[i].value < a[j].value } 21 | 22 | func minimumSwaps(input []int32) int32 { 23 | arr := make([]Arr, 0, len(input)) 24 | 25 | // step 1. Generate an array of sorted indexes 26 | for i, v := range input { 27 | arr = append(arr, Arr{v, i}) 28 | } 29 | 30 | sort.Sort(ByValue(arr)) 31 | 32 | idx := make([]int, 0, len(input)) 33 | for _, ar := range arr { 34 | idx = append(idx, ar.index) 35 | } 36 | 37 | // step 2. Sort the array by sorted indexes 38 | var result int32 39 | for i := 0; i < len(input); i++ { 40 | if i == idx[i] { 41 | continue 42 | } 43 | 44 | input[i], input[idx[i]] = input[idx[i]], input[i] 45 | idx[i], idx[input[idx[i]]-1] = i, idx[i] 46 | result++ 47 | } 48 | return result 49 | } 50 | -------------------------------------------------------------------------------- /interview-preparation-kit/arrays/4.new-year-chaos.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // https://www.hackerrank.com/challenges/new-year-chaos/problem 6 | 7 | func minimumBribes(q []int32) { 8 | result := int32(0) 9 | for i := int32(len(q)) - 1; i >= 0; i-- { 10 | if q[i]-(i+1) > 2 { 11 | fmt.Println("Too chaotic") 12 | return 13 | } 14 | for j := max(0, q[i]-2); j < i; j++ { 15 | if q[j] > q[i] { 16 | result++ 17 | } 18 | } 19 | } 20 | fmt.Println(result) 21 | } 22 | 23 | func max(a, b int32) int32 { 24 | if a > b { 25 | return a 26 | } 27 | return b 28 | } 29 | -------------------------------------------------------------------------------- /projecteuler/1multiplesof3and5.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //https://www.hackerrank.com/contests/projecteuler/challenges/euler001 4 | 5 | import "fmt" 6 | 7 | func main() { 8 | var T int 9 | fmt.Scan(&T) 10 | for i := 0; i < T; i++ { 11 | var N int 12 | fmt.Scan(&N) 13 | fmt.Println(Result(N)) 14 | } 15 | } 16 | 17 | func Result(N int) int { 18 | // sum all for 3 19 | a := int(N / 3) 20 | if N%3 == 0 { 21 | a-- 22 | } 23 | result := (a * (a + 1) / 2) * 3 24 | 25 | // sum all for 5 26 | b := int(N / 5) 27 | if N%5 == 0 { 28 | b-- 29 | } 30 | result += (b * (b + 1) / 2) * 5 31 | 32 | // minus all for 15 33 | c := int(N / 15) 34 | if N%15 == 0 { 35 | c-- 36 | } 37 | result -= (c * (c + 1) / 2) * 15 38 | 39 | return result 40 | } 41 | -------------------------------------------------------------------------------- /reverse-a-linked-list.go: -------------------------------------------------------------------------------- 1 | package hackerrank 2 | 3 | // https://www.hackerrank.com/challenges/reverse-a-linked-list/problem 4 | 5 | // SinglyLinkedListNode ... 6 | type SinglyLinkedListNode struct { 7 | data int32 8 | next *SinglyLinkedListNode 9 | } 10 | 11 | func reverse(head *SinglyLinkedListNode) *SinglyLinkedListNode { 12 | var node, next *SinglyLinkedListNode 13 | for { 14 | next = head.next 15 | 16 | if node != nil { 17 | head.next = node 18 | } else { 19 | head.next = nil 20 | } 21 | 22 | if next == nil { 23 | break 24 | } 25 | 26 | node = head 27 | head = next 28 | } 29 | return head 30 | } 31 | -------------------------------------------------------------------------------- /weekofcode21/kangaroo.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //https://www.hackerrank.com/contests/w21/challenges/kangaroo 4 | 5 | import "fmt" 6 | 7 | func main() { 8 | var x1, v1, x2, v2 int 9 | fmt.Scanf("%v %v %v %v", &x1, &v1, &x2, &v2) 10 | if x2 < x1 { 11 | x1, v1, x2, v2 = x2, v2, x1, v1 12 | } 13 | fmt.Println(Kangaroo(x1, v1, x2, v2)) 14 | } 15 | 16 | func Kangaroo(x1, v1, x2, v2 int) string { 17 | if x1 == x2 { 18 | return "YES" 19 | } 20 | if v2 >= v1 { 21 | return "NO" 22 | } 23 | 24 | for x1 <= x2 { 25 | if x1 == x2 { 26 | return "YES" 27 | } 28 | x1 += v1 29 | x2 += v2 30 | } 31 | return "NO" 32 | } 33 | -------------------------------------------------------------------------------- /weekofcode21/luckbalance.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://www.hackerrank.com/contests/w21/challenges/luck-balance 4 | 5 | import ( 6 | "fmt" 7 | "sort" 8 | ) 9 | 10 | func main() { 11 | var N, K int 12 | var result int 13 | fmt.Scanf("%v %v", &N, &K) 14 | var ar []int 15 | for i := 0; i < N; i++ { 16 | var L, T int 17 | fmt.Scanf("%v %v", &L, &T) 18 | if T == 1 { 19 | ar = append(ar, L) 20 | } else { 21 | result += L 22 | } 23 | } 24 | sort.Sort(sort.Reverse(sort.IntSlice(ar))) 25 | for i := 0; i < K; i++ { 26 | result += ar[i] 27 | } 28 | for i := K; i < len(ar); i++ { 29 | result -= ar[i] 30 | } 31 | fmt.Println(result) 32 | } 33 | -------------------------------------------------------------------------------- /weekofcode29/day-of-the-programmer.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var Y int 7 | fmt.Scan(&Y) 8 | 9 | switch { 10 | case Y < 1918: 11 | if Y%4 == 0 { 12 | fmt.Printf("12.09.%d", Y) 13 | } else { 14 | fmt.Printf("13.09.%d", Y) 15 | } 16 | case Y == 1918: 17 | fmt.Println("26.09.1918") 18 | case Y > 1918: 19 | if Y%4 == 0 && (Y%100 != 0 || Y%400 == 0) { 20 | fmt.Printf("12.09.%d", Y) 21 | } else { 22 | fmt.Printf("13.09.%d", Y) 23 | } 24 | } 25 | } 26 | --------------------------------------------------------------------------------