Merge remote-tracking branch 'origin/master'

Author: kkarpyshev

src/medium/138. Copy List with Random Pointer .kt

@@ -22,7 +22,7 @@ import LinkedListTopic
  * Your code will only be given the head of the original linked list.
  */
 
-class Medium138: HashTableTopic, LinkedListTopic {
+class Medium138 : HashTableTopic, LinkedListTopic {
 
     fun copyRandomList(head: Node?): Node? {
         head ?: return null

src/medium/71. Simplify Path .kt

@@ -0,0 +1,53 @@
+package medium
+
+import StackTopic
+import StringTopic
+import java.util.*
+
+/**
+ * 71. Simplify Path
+ * https://leetcode.com/problems/simplify-path/
+ *
+Given a string path, which is an absolute path (starting with a slash '/') to a file or directory in a Unix-style file system, convert it to the simplified canonical path.
+
+In a Unix-style file system, a period '.' refers to the current directory, a double period '..' refers to the directory up a level, and any multiple consecutive slashes (i.e. '//') are treated as a single slash '/'. For this problem, any other format of periods such as '...' are treated as file/directory names.
+
+The canonical path should have the following format:
+
+The path starts with a single slash '/'.
+Any two directories are separated by a single slash '/'.
+The path does not end with a trailing '/'.
+The path only contains the directories on the path from the root directory to the target file or directory (i.e., no period '.' or double period '..')
+Return the simplified canonical path.
+ */
+
+class Medium71 : StringTopic, StackTopic {
+
+    fun simplifyPath(path: String): String {
+        val stack = Stack<String>()
+        var start = -1
+        for (i in 0..path.length) {
+            if (i == path.length || path[i] == '/') {
+                if (start > 0) {
+                    when (val dir = path.substring(start, i)) {
+                        "." -> Unit
+                        ".." -> if (stack.isNotEmpty()) stack.pop()
+                        else -> stack.add(dir)
+                    }
+                    start = -1
+                }
+            } else {
+                if (start < 0) start = i
+            }
+        }
+        return stack.joinToString("/", "/")
+    }
+}
+
+fun main() {
+    println(Medium71().simplifyPath("/home/")) // /home
+    println(Medium71().simplifyPath("/../")) // /
+    println(Medium71().simplifyPath("/home//foo/")) // /home/foo
+    println(Medium71().simplifyPath("/a/./b/../../c/")) // /c
+    println(Medium71().simplifyPath("/...")) // /
+}

src/medium/856. Score of Parentheses .kt

@@ -0,0 +1,43 @@
+package medium
+
+import StackTopic
+import StringTopic
+import java.util.*
+
+
+/**
+ * 856. Score of Parentheses
+ * https://leetcode.com/problems/score-of-parentheses/
+ *
+Given a balanced parentheses string s, return the score of the string.
+The score of a balanced parentheses string is based on the following rule:
+"()" has score 1.
+AB has score A + B, where A and B are balanced parentheses strings.
+(A) has score 2 * A, where A is a balanced parentheses string.
+ BULLSHIT
+ */
+
+class Medium856 : StringTopic, StackTopic {
+
+    fun scoreOfParentheses(s: String): Int {
+        val stack = Stack<Int>()
+        stack.push(0)
+        for (i in s.indices) {
+            if (s[i] == '(') {
+                stack.push(0)
+            } else {
+                val v = stack.pop()
+                val w = stack.pop()
+                stack.push(w + maxOf(2 * v, 1))
+            }
+        }
+        return stack.pop()
+    }
+}
+
+fun main() {
+    println(Medium856().scoreOfParentheses("()"))
+    println(Medium856().scoreOfParentheses("(())"))
+    println(Medium856().scoreOfParentheses("()()"))
+    println(Medium856().scoreOfParentheses("(()(()))"))
+}

src/medium/946. Validate Stack Sequences .kt

@@ -0,0 +1,49 @@
+package medium
+
+import ArraysTopic
+import StackTopic
+import java.util.*
+
+/**
+ * 946. Validate Stack Sequences
+ * https://leetcode.com/problems/validate-stack-sequences/
+ *
+Given two integer arrays pushed and popped each with distinct values,
+return true if this could have been the result of a sequence of push and pop operations on an initially empty stack, or false otherwise.
+ */
+
+class Medium946 : ArraysTopic, StackTopic {
+
+    fun validateStackSequences(pushed: IntArray, popped: IntArray): Boolean {
+        val stack = Stack<Int>()
+        var i = 0
+        var j = 0
+        while (i < pushed.size || j < popped.size) {
+            if (stack.isEmpty()) {
+                if (i < pushed.size) {
+                    stack.push(pushed[i])
+                    i++
+                } else return false
+            } else {
+                if (j < popped.size) {
+                    if (popped[j] == stack.peek()) {
+                        stack.pop()
+                        j++
+                    } else {
+                        if (i < pushed.size) {
+                            stack.push(pushed[i])
+                            i++
+                        } else return false
+                    }
+                } else return false
+            }
+        }
+        return true
+    }
+}
+
+fun main() {
+    println(Medium946().validateStackSequences(intArrayOf(1, 2, 3, 4, 5), intArrayOf(4, 5, 3, 2, 1)))
+    println(Medium946().validateStackSequences(intArrayOf(1, 2, 3, 4, 5), intArrayOf(4, 3, 5, 1, 2)))
+
+}