Skip to content

Commit 1dd16fc

Browse files
MagicienDeCodeMagicienDeCode
committed
add kotlin solutions
1 parent 14b6041 commit 1dd16fc

File tree

10 files changed

+620
-0
lines changed

10 files changed

+620
-0
lines changed

Diff for: ‎June-LeetCoding-Challenge/21-Dungeon-Game/Dungeon-Game.kt

+59
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,59 @@
1+
package dynamic_programming
2+
3+
class DungeonGameKotlin174 {
4+
fun calculateMinimumHP(dungeon: Array<IntArray>): Int {
5+
val dynamicProgramming = IntArray(dungeon[0].size + 1) { Int.MAX_VALUE }
6+
dynamicProgramming[dynamicProgramming.size - 1] = 1
7+
for (i in dungeon.size - 1 downTo 0) {
8+
if (dynamicProgramming[dynamicProgramming.size - 1] == 1 && i != dungeon.size - 1) {
9+
dynamicProgramming[dynamicProgramming.size - 1] = Int.MAX_VALUE
10+
}
11+
for (j in dungeon[0].size - 1 downTo 0) {
12+
dynamicProgramming[j] =
13+
maxOf(1, minOf(dynamicProgramming[j], dynamicProgramming[j + 1]) - dungeon[i][j])
14+
}
15+
}
16+
return dynamicProgramming[0]
17+
}
18+
/*
19+
fun calculateMinimumHP(dungeon: Array<IntArray>): Int {
20+
val dynamicProgramming = Array(dungeon.size + 1) { IntArray(dungeon[0].size + 1) { Int.MAX_VALUE } }
21+
dynamicProgramming[dynamicProgramming.size - 1][dynamicProgramming[0].size - 2] = 1
22+
dynamicProgramming[dynamicProgramming.size - 2][dynamicProgramming[0].size - 1] = 1
23+
for (i in dungeon.size - 1 downTo 0) {
24+
for (j in dungeon[0].size - 1 downTo 0) {
25+
dynamicProgramming[i][j] =
26+
maxOf(1, minOf(dynamicProgramming[i + 1][j], dynamicProgramming[i][j + 1]) - dungeon[i][j])
27+
}
28+
}
29+
return dynamicProgramming[0][0]
30+
}
31+
*/
32+
}
33+
34+
fun main() {
35+
val solution = DungeonGameKotlin174()
36+
println(
37+
solution.calculateMinimumHP(
38+
arrayOf(
39+
intArrayOf(-2, -3, 3),
40+
intArrayOf(-5, -10, 1),
41+
intArrayOf(10, 30, -5)
42+
)
43+
)
44+
)
45+
println(
46+
solution.calculateMinimumHP(
47+
arrayOf(
48+
intArrayOf(0, -3)
49+
)
50+
)
51+
)
52+
println(
53+
solution.calculateMinimumHP(
54+
arrayOf(
55+
intArrayOf(100)
56+
)
57+
)
58+
)
59+
}

Diff for: ‎June-LeetCoding-Challenge/22-Single-Number-II/Single-Number-II.kt

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
package string_integer
2+
3+
class SingleNumberIIKotlin137 {
4+
fun singleNumber(nums: IntArray): Int {
5+
var one = 0
6+
var two = 0
7+
nums.forEach {
8+
one = one.xor(it).and(two.inv())
9+
two = two.xor(it).and(one.inv())
10+
}
11+
return one
12+
}
13+
}

Diff for: ‎June-LeetCoding-Challenge/23-Count-Complete-Tree-Nodes/Count-Complete-Tree-Nodes.kt

+120
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,120 @@
1+
package binary_search
2+
3+
class CountCompleteTreeNodesKotlin222 {
4+
class TreeNode(var `val`: Int) {
5+
var left: TreeNode? = null
6+
var right: TreeNode? = null
7+
}
8+
9+
fun countNodes(root: TreeNode?): Int {
10+
if (root == null) {
11+
return 0
12+
}
13+
return 1 + countNodes(root?.left) + countNodes(root?.right)
14+
}
15+
/*
16+
fun countNodes(root: TreeNode?): Int {
17+
if (root == null) {
18+
return 0
19+
}
20+
var level = 0
21+
var current = root
22+
while (current!!.left != null) {
23+
level++
24+
current = current.left
25+
}
26+
return search(root, level)
27+
}
28+
29+
private fun search(root: TreeNode, level: Int): Int {
30+
var left = 1.shl(level)
31+
var right = 1.shl(level + 1) - 1
32+
while (left + 1 < right) {
33+
val mid = left + (right - left) / 2
34+
when {
35+
isNotNull(root, mid, level) -> left = mid
36+
else -> right = mid
37+
}
38+
}
39+
return when {
40+
isNotNull(root, right, level) -> right
41+
isNotNull(root, left, level) -> left
42+
else -> -1
43+
}
44+
}
45+
46+
private fun isNotNull(root: TreeNode, target: Int, level: Int): Boolean {
47+
var result: TreeNode? = root
48+
var start = 1.shl(level)
49+
var end = 1.shl(level + 1) - 1
50+
var currentLevel = level
51+
while (currentLevel > 0) {
52+
val mid = start + (end - start).shr(1)
53+
if (target > mid) {
54+
result = result?.right
55+
start = mid
56+
} else {
57+
result = result?.left
58+
end = mid
59+
}
60+
currentLevel--
61+
}
62+
return result != null
63+
}
64+
65+
/*
66+
private fun isNotNull(root: TreeNode, target: Int): Boolean {
67+
var current = target
68+
val stack = Stack<Int>()
69+
while (current != 1) {
70+
stack.push(current % 2)
71+
current = current.shr(1)
72+
}
73+
var result: TreeNode? = root
74+
while (stack.size != 0) {
75+
when (stack.pop()) {
76+
1 -> result = result?.right
77+
0 -> result = result?.left
78+
}
79+
}
80+
return result != null
81+
}
82+
*/
83+
}
84+
85+
86+
fun main() {
87+
val solution = CountCompleteTreeNodesKotlin222()
88+
89+
val test = TreeNode(1)
90+
val test2 = TreeNode(2)
91+
test.left = test2
92+
println(solution.countNodes(test))
93+
94+
val root = TreeNode(1)
95+
val node2 = TreeNode(2)
96+
val node3 = TreeNode(3)
97+
val node4 = TreeNode(4)
98+
val node5 = TreeNode(5)
99+
val node6 = TreeNode(6)
100+
val node7 = TreeNode(7)
101+
val node8 = TreeNode(8)
102+
val node9 = TreeNode(9)
103+
val node10 = TreeNode(10)
104+
val node11 = TreeNode(11)
105+
val node12 = TreeNode(12)
106+
root.left = node2
107+
root.right = node3
108+
node2.left = node4
109+
node2.right = node5
110+
node3.left = node6
111+
node3.right = node7
112+
node4.left = node8
113+
node4.right = node9
114+
node5.left = node10
115+
node5.right = node11
116+
node6.left = node12
117+
118+
println(solution.countNodes(root))
119+
}
120+
*/

Diff for: ‎June-LeetCoding-Challenge/24-Unique-Binary-Search-Trees/Unique-Binary-Search-Trees.kt

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
package depth_first_search
2+
3+
class UniqueBinarySearchTreesKotlin96 {
4+
// https://zh.wikipedia.org/wiki/%E5%8D%A1%E5%A1%94%E5%85%B0%E6%95%B0
5+
// https://en.wikipedia.org/wiki/Catalan_number
6+
fun numTrees(n: Int): Int {
7+
var result = 1L
8+
for (index in n + 1..n * 2) {
9+
result = result * index / (index - n)
10+
}
11+
return (result / (n + 1)).toInt()
12+
}
13+
}

Diff for: ‎June-LeetCoding-Challenge/25-Find-the-Duplicate-Number/Find-the-Duplicate-Number.kt

+50
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
package binary_search
2+
3+
class FindtheDuplicateNumberKotlin287 {
4+
fun findDuplicate(nums: IntArray): Int {
5+
var fast = 0
6+
var slow = 0
7+
while (true) {
8+
fast = nums[nums[fast]]
9+
slow = nums[slow]
10+
if (fast == slow) {
11+
break
12+
}
13+
}
14+
fast = 0
15+
while (true) {
16+
fast = nums[fast]
17+
slow = nums[slow]
18+
if (fast == slow) {
19+
break
20+
}
21+
}
22+
return fast
23+
}
24+
/*
25+
fun findDuplicate(nums: IntArray): Int {
26+
var left = 0
27+
var right = nums.size - 1
28+
while (left + 1 < right) {
29+
val mid = left + (right - left) / 2
30+
when {
31+
nums.count { it <= mid } <= mid -> left = mid
32+
else -> right = mid
33+
}
34+
}
35+
return right
36+
}
37+
*/
38+
/*
39+
fun findDuplicate(nums: IntArray): Int {
40+
nums.forEachIndexed { index, i ->
41+
nums.forEachIndexed { index2, i2 ->
42+
if (i == i2 && index != index2) {
43+
return i
44+
}
45+
}
46+
}
47+
return -1
48+
}
49+
*/
50+
}

Diff for: ‎June-LeetCoding-Challenge/26-Sum-Root-to-Leaf-Numbers/Sum-Root-to-Leaf-Numbers.kt

+69
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,69 @@
1+
package breadth_first_search
2+
3+
class SumRoottoLeafNumbersKotlin129 {
4+
fun sumNumbers(root: TreeNode?): Int {
5+
root ?: return 0
6+
return dfs(root, "")
7+
}
8+
9+
private fun dfs(node: TreeNode, string: String): Int {
10+
val currentString = string + node.`val`.toString()
11+
val leftNode = node.left
12+
val rightNode = node.right
13+
14+
if (leftNode == null && rightNode == null) {
15+
return currentString.toInt()
16+
}
17+
val leftVal = if (leftNode == null) 0 else dfs(leftNode, currentString)
18+
val rightVal = if (rightNode == null) 0 else dfs(rightNode, currentString)
19+
return leftVal + rightVal
20+
}
21+
/*
22+
fun sumNumbers(root: TreeNode?): Int {
23+
if (root == null) {
24+
return 0
25+
}
26+
val queue: Queue<Pair<TreeNode, String>> = LinkedList()
27+
queue.offer(Pair(root, ""))
28+
var sum = 0
29+
while (queue.isNotEmpty()) {
30+
val currentPair = queue.poll()
31+
val currentNode = currentPair.first
32+
val currentString = currentPair.second + currentNode.`val`.toString()
33+
val leftNode = currentNode.left
34+
val rightNode = currentNode.right
35+
36+
if (leftNode == null && rightNode == null) {
37+
sum += currentString.toInt()
38+
}
39+
if (leftNode != null) {
40+
queue.offer(Pair(leftNode, currentString))
41+
}
42+
if (rightNode != null) {
43+
queue.offer(Pair(rightNode, currentString))
44+
}
45+
46+
}
47+
return sum
48+
}
49+
*/
50+
51+
class TreeNode(var `val`: Int) {
52+
var left: TreeNode? = null
53+
var right: TreeNode? = null
54+
}
55+
}
56+
57+
fun main() {
58+
val solution = SumRoottoLeafNumbersKotlin129()
59+
val t0 = SumRoottoLeafNumbersKotlin129.TreeNode(0)
60+
val t4 = SumRoottoLeafNumbersKotlin129.TreeNode(4)
61+
val t9 = SumRoottoLeafNumbersKotlin129.TreeNode(9)
62+
val t5 = SumRoottoLeafNumbersKotlin129.TreeNode(5)
63+
val t1 = SumRoottoLeafNumbersKotlin129.TreeNode(1)
64+
t4.left = t9
65+
t4.right = t0
66+
t9.left = t5
67+
t9.right = t1
68+
println(solution.sumNumbers(t4))
69+
}

0 commit comments

Comments
 (0)