codility

Author: kimi0230

Codility/Lesson/0001.Iterations/Binary-Gap/README.md

@@ -27,4 +27,49 @@ Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized cop
 先找出bit 1的位子, 再開始算中間最長的長度
 
 ## 來源
-* https://app.codility.com/programmers/lessons/1-iterations/binary_gap/
+* https://app.codility.com/programmers/lessons/1-iterations/binary_gap/
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Codility/Lesson/0001.Iterations/Binary-Gap/Binary-Gap.go
+
+
+```go
+package binarygap
+
+// O(log n)
+func Solution(N int) int {
+	maxLen, curLen := 0, 0
+	findOne := false
+	for N > 0 {
+		curBit := N & 1
+		if curBit == 1 {
+			curLen = 0
+			findOne = true
+		} else if curBit == 0 && findOne {
+			curLen++
+		}
+
+		if curLen > maxLen {
+			maxLen = curLen
+		}
+		N = N >> 1
+	}
+	return maxLen
+}
+
+// https://wandbox.org/permlink/totZwDAbL1wCgsqt
+func evil(x int) int {
+	if x&(x+1) > 0 {
+		return evil(x|(x>>1)) + 1
+	} else {
+		return 0
+	}
+}
+
+func SolutionRecur(N int) int {
+	for (N & 1) == 0 {
+		N = N >> 1
+	}
+	return evil(N)
+}
+```

Codility/Lesson/0002.Array/CyclicRotation/README.md

@@ -44,4 +44,31 @@ Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized cop
 ## 解題思路
 
 ## 來源
-* https://app.codility.com/programmers/lessons/2-arrays/cyclic_rotation/
+* https://app.codility.com/programmers/lessons/2-arrays/cyclic_rotation/
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Codility/Lesson/0002.Array/CyclicRotation/CyclicRotation.go
+
+
+```go
+package cyclicrotation
+
+func Solution(A []int, K int) []int {
+	if K == 0 || len(A) <= 1 {
+		return A
+	}
+
+	K = K % len(A)
+	return append(A[len(A)-K:], A[:len(A)-K]...)
+}
+
+func Solution2(A []int, K int) []int {
+	if K == 0 || len(A) <= 1 {
+		return A
+	}
+	if K > len(A) {
+		K = K % len(A)
+	}
+	return append(A[len(A)-K:], A[:len(A)-K]...)
+}
+```

Codility/Lesson/0002.Array/OddOccurrencesInArray/README.md

@@ -39,4 +39,37 @@ Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized cop
 2. 方法二: 所有的整數XOR起來, 若是兩個整數相同XOR得到0, 最後剩下基數次的數字
 
 ## 來源
-* https://app.codility.com/programmers/lessons/2-arrays/odd_occurrences_in_array/
+* https://app.codility.com/programmers/lessons/2-arrays/odd_occurrences_in_array/
+
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Codility/Lesson/0002.Array/OddOccurrencesInArray/OddOccurrencesInArray.go
+
+
+```go
+package oddoccurrencesinarray
+
+func Solution(A []int) int {
+	intMap := make(map[int]int)
+	for i := 0; i < len(A); i++ {
+		intMap[A[i]] += 1
+	}
+
+	for k, v := range intMap {
+		if v%2 != 0 {
+			return k
+		}
+	}
+	return -1
+}
+
+// 所有的整數XOR起來, 若是兩個整數相同XOR得到0, 最後剩下基數次的數字
+// 前提只能有一個基數數字
+func Solution2(A []int) int {
+	result := 0
+	for i := 0; i < len(A); i++ {
+		result ^= A[i]
+	}
+	return result
+}
+```

Codility/Lesson/0003.Time-Complexity/FrogJmp/README.md

@@ -31,4 +31,24 @@ Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized cop
 ## 解題思路
 
 ## 來源
-* https://app.codility.com/programmers/lessons/3-time_complexity/frog_jmp/
+* https://app.codility.com/programmers/lessons/3-time_complexity/frog_jmp/
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Codility/Lesson/0003.Time-Complexity/FrogJmp/FrogJmp.go
+
+
+```go
+package frogjump
+
+import (
+	"math"
+)
+
+func Solution(X int, Y int, D int) int {
+	if Y < X {
+		return 0
+	}
+	remainDist := Y - X
+	return int(math.Ceil(float64(remainDist) / float64(D)))
+}
+```

Codility/Lesson/0003.Time-Complexity/PermMissingElem/README.md

@@ -31,3 +31,26 @@ Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized cop
 
 ## 來源
 * https://app.codility.com/programmers/lessons/3-time_complexity/perm_missing_elem/
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Codility/Lesson/0003.Time-Complexity/PermMissingElem/PermMissingElem.go
+
+
+```go
+package permmissingelem
+
+func Solution(A []int) int {
+	if len(A) < 1 {
+		return 1
+	}
+
+	n := len(A) + 1
+	predictSume := (n + 1) * n / 2
+
+	var sum int
+	for _, v := range A {
+		sum += v
+	}
+	return predictSume - sum
+}
+```

Codility/Lesson/0003.Time-Complexity/TapeEquilibrium/README.md

@@ -52,3 +52,39 @@ Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized cop
 
 ## 來源
 * https://app.codility.com/programmers/lessons/3-time_complexity/tape_equilibrium/
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Codility/Lesson/0003.Time-Complexity/TapeEquilibrium/TapeEquilibrium.go
+
+
+```go
+package TapeEquilibrium
+
+import "math"
+
+func Solution(A []int) int {
+
+	totalSum := 0
+	for _, v := range A {
+		totalSum += v
+	}
+
+	leftSum := A[0]
+	rightSum := totalSum - leftSum
+	result := math.MaxInt32
+	for i := 1; i < len(A); i++ {
+		tmpDiff := int(math.Abs(float64(rightSum) - float64(leftSum)))
+		if tmpDiff < result {
+			result = tmpDiff
+		}
+		rightSum -= A[i]
+		leftSum += A[i]
+	}
+
+	if result == math.MaxInt32 {
+		result = 0
+	}
+
+	return result
+}
+```

Codility/Lesson/0004.Counting-Elements/FrogRiverOne/README.md

@@ -53,3 +53,22 @@ Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized cop
 
 ## 來源
 * https://app.codility.com/programmers/lessons/4-counting_elements/frog_river_one/
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Codility/Lesson/0004.Counting-Elements/FrogRiverOne/FrogRiverOne.go
+
+
+```go
+package FrogRiverOne
+
+func Solution(X int, A []int) int {
+	intMap := make(map[int]bool)
+	for i := 0; i < len(A); i++ {
+		intMap[A[i]] = true
+		if len(intMap) == X {
+			return i
+		}
+	}
+	return -1
+}
+```

Codility/Lesson/0004.Counting-Elements/MaxCounters/README.md

@@ -59,4 +59,48 @@ Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized cop
 ## 解題思路
 
 ## 來源
-https://app.codility.com/programmers/lessons/4-counting_elements/
+https://app.codility.com/programmers/lessons/4-counting_elements/
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Codility/Lesson/0004.Counting-Elements/MaxCounters/MaxCounters.go
+
+
+```go
+package MaxCounters
+
+func Max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+// 時間 O(N+M) , 空間 O(N)
+func Solution(N int, A []int) []int {
+	result := make([]int, N)
+	maxNum := 0
+	nowMaxNum := 0
+	for i := 0; i < len(A); i++ {
+		if A[i] > N {
+			// 如果A[i] 大於 N 則將計數器中所有的數更新為計數器當前的最大數值
+			maxNum = nowMaxNum
+		} else {
+			// 如果A[i] 小於 N 則將計數器中對應位置的數+1,
+			if result[A[i]-1] < maxNum {
+				result[A[i]-1] = maxNum
+			}
+			result[A[i]-1]++
+
+			if nowMaxNum < result[A[i]-1] {
+				nowMaxNum = result[A[i]-1]
+			}
+		}
+	}
+	for i := 0; i < N; i++ {
+		if result[i] < maxNum {
+			result[i] = maxNum
+		}
+	}
+	return result
+}
+```

Codility/Lesson/0004.Counting-Elements/MissingInteger/README.md

@@ -29,4 +29,34 @@ Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized cop
 先講出現的數字記錄起來, 再依序從1開始往後找出最小的整數且沒出現過
 
 ## 來源
-https://app.codility.com/programmers/lessons/4-counting_elements/missing_integer/
+https://app.codility.com/programmers/lessons/4-counting_elements/missing_integer/
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Codility/Lesson/0004.Counting-Elements/MissingInteger/MissingInteger.go
+
+
+```go
+package MissingInteger
+
+func Solution(A []int) int {
+	smallNum := 1
+	intMap := make(map[int]bool)
+
+	// 將出現的數字塞入map
+	for _, v := range A {
+		if v > 0 && !intMap[v] {
+			intMap[v] = true
+		}
+	}
+
+	for i := 1; i <= len(intMap); i++ {
+		if !intMap[i] {
+			// 此正整數沒在map找到
+			return i
+		}
+		smallNum = i + 1
+	}
+
+	return smallNum
+}
+```

Codility/Lesson/0004.Counting-Elements/PermCheck/README.md

@@ -55,4 +55,51 @@ Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized cop
 最後檢查總時對不對
 
 ## 來源
-https://app.codility.com/programmers/lessons/4-counting_elements/perm_check/
+https://app.codility.com/programmers/lessons/4-counting_elements/perm_check/
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Codility/Lesson/0004.Counting-Elements/PermCheck/PermCheck.go
+
+
+```go
+package PermCheck
+
+func Solution(A []int) int {
+	intMap := make(map[int]bool)
+
+	for _, v := range A {
+		if !intMap[v] {
+			intMap[v] = true
+		} else {
+			// 重複出現
+			return 0
+		}
+	}
+
+	for i := 1; i <= len(A); i++ {
+		if !intMap[i] {
+			return 0
+		}
+	}
+	return 1
+}
+
+func Solution2(A []int) int {
+	intMap := make(map[int]bool)
+	sum := 0
+	for _, v := range A {
+		if !intMap[v] {
+			intMap[v] = true
+			sum += v
+		} else {
+			// 重複出現
+			return 0
+		}
+	}
+
+	if sum == (len(A)+1)*len(A)/2 {
+		return 1
+	}
+	return 0
+}
+```