problem 24, 26

Author: TipsyPixie

README.md

@@ -40,3 +40,4 @@ Number | Difficulty | Asked By
 [#21](problem021) | EASY | Snapchat
 [#22](problem022) | MEDIUM | Microsoft
 [#23](problem023) | EASY | Google
+[#24](problem024) | EASY | Google

problem024/README.md

@@ -0,0 +1,16 @@
+## Daily Coding Problem: Problem #24 [Medium]
+Good morning! Here's your coding interview problem for today.
+
+This problem was asked by Google.
+
+Implement locking in a binary tree. A binary tree node can be locked or unlocked only if all of its descendants or ancestors are not locked.
+
+Design a binary tree node class with the following methods:
+
+---
+* `is_locked`, which returns whether the node is locked
+* `lock`, which attempts to lock the node. If it cannot be locked, then it should return false. Otherwise, it should lock it and return true.
+* `unlock`, which unlocks the node. If it cannot be unlocked, then it should return false. Otherwise, it should unlock it and return true.
+---
+
+You may augment the node to add parent pointers or any other property you would like. You may assume the class is used in a single-threaded program, so there is no need for actual locks or mutexes. Each method should run in O(h), where h is the height of the tree.

problem024/problem024.go

@@ -0,0 +1,66 @@
+package problem024
+
+type binaryTree struct {
+	lockedDescendantsCount int
+	locked                 bool
+	parent                 *binaryTree
+	left                   *binaryTree
+	right                  *binaryTree
+}
+
+func NewBinaryTree(left *binaryTree, right *binaryTree) *binaryTree {
+	node := binaryTree{
+		parent:                 nil,
+		lockedDescendantsCount: 0,
+		locked:                 false,
+		left:                   left,
+		right:                  right,
+	}
+	if right != nil {
+		right.parent = &node
+	}
+	if left != nil {
+		left.parent = &node
+	}
+	return &node
+}
+
+func (node *binaryTree) IsLocked() bool {
+	return node.locked
+}
+
+func (node *binaryTree) Lock() bool {
+	if node.lockedDescendantsCount > 0 {
+		return false
+	}
+	ascendants := make([]*binaryTree, 0, 64)
+	for cursor := node.parent; cursor != nil; cursor = cursor.parent {
+		if cursor.locked {
+			return false
+		}
+		ascendants = append(ascendants, cursor)
+	}
+	for _, ascendant := range ascendants {
+		ascendant.lockedDescendantsCount++
+	}
+	node.locked = true
+	return true
+}
+
+func (node *binaryTree) Unlock() bool {
+	if node.lockedDescendantsCount > 0 {
+		return false
+	}
+	ascendants := make([]*binaryTree, 0, 64)
+	for cursor := node.parent; cursor != nil; cursor = cursor.parent {
+		if cursor.locked {
+			return false
+		}
+		ascendants = append(ascendants, cursor)
+	}
+	for _, ascendant := range ascendants {
+		ascendant.lockedDescendantsCount--
+	}
+	node.locked = false
+	return true
+}

problem024/problem024_test.go

@@ -0,0 +1,45 @@
+package problem024
+
+import (
+	"os"
+	"testing"
+)
+
+var tree *binaryTree
+
+func TestMain(m *testing.M) {
+	tree = NewBinaryTree(
+		NewBinaryTree(nil, nil),
+		NewBinaryTree(
+			NewBinaryTree(nil, nil),
+			NewBinaryTree(nil, nil),
+		),
+	)
+	os.Exit(m.Run())
+}
+
+func TestBinaryTree_Lock(t *testing.T) {
+	if tree.right.IsLocked() {
+		t.Log("right node already locked")
+		t.FailNow()
+	}
+	if !tree.right.Lock() || !tree.right.IsLocked() || tree.lockedDescendantsCount != 1 {
+		t.Log("failed to lock right node")
+		t.FailNow()
+	}
+	if tree.Lock() || tree.right.right.Lock() {
+		t.Log("invalid lock")
+		t.FailNow()
+	}
+}
+
+func TestBinaryTree_Unlock(t *testing.T) {
+	if tree.Unlock() || tree.right.right.Unlock() {
+		t.Log("invalid lock")
+		t.FailNow()
+	}
+	if !tree.right.Unlock() {
+		t.Log("failed to unlock right node")
+		t.FailNow()
+	}
+}

problem026/README.md

@@ -0,0 +1,13 @@
+## Daily Coding Problem: Problem #26 [Medium]
+
+Good morning! Here's your coding interview problem for today.
+
+This problem was asked by Google.
+
+Given a singly linked list and an integer `k`, remove the `k`th last element from the list. `k` is guaranteed to be smaller than the length of the list.
+
+The list is very long, so making more than one pass is prohibitively expensive.
+
+Do this in constant space and in one pass.
+
+

problem026/problem026.go

@@ -0,0 +1,17 @@
+package problem026
+
+type linkedList struct {
+	value int
+	next *linkedList
+}
+
+func (node *linkedList) FromLast(reverseIndex int) *linkedList {
+	formerCursor, latterCursor := node, node
+	for i := 0; i < reverseIndex; i++ {
+		latterCursor = latterCursor.next
+	}
+	for latterCursor.next != nil {
+		formerCursor, latterCursor = formerCursor.next, latterCursor.next
+	}
+	return formerCursor
+}

problem026/problem026_test.go

@@ -0,0 +1,27 @@
+package problem026
+
+import "testing"
+
+func TestLinkedList_FromLast(t *testing.T) {
+	node := &linkedList{
+		value: 3,
+		next: &linkedList{
+			value: 2,
+			next: &linkedList{
+				value: 1,
+				next: &linkedList{
+					value: 0,
+					next:  nil,
+				},
+			},
+		},
+	}
+	if node.FromLast(0).value != 0 {
+		t.Log(node.FromLast(0))
+		t.FailNow()
+	}
+	if node.FromLast(2).value != 2 {
+		t.Log(node.FromLast(2))
+		t.FailNow()
+	}
+}