Add golang solution for 008, 009, 010

Author: Shivam010

001-050/008/go/code.go

@@ -6,7 +6,57 @@
 // TestSolution for test cases
 package _008
 
-// Solution for 008
-func Solution() interface{} {
-	return nil
+// Node implements binary tree
+type Node struct {
+	value    int  // value of Node
+	isUnival bool // is unival tree (having universal value)
+
+	left, right *Node // left and right children
+
+	count int // no. of unival subtrees in the node (including itself)
+}
+
+func NewNode(value int) *Node {
+	return &Node{value: value}
+}
+
+func (n *Node) GetValue() int {
+	return n.value
+}
+
+func (n *Node) AddChild(ch *Node) *Node {
+	if n == nil {
+		panic("nil node")
+	}
+	if n.left == nil {
+		n.left = ch
+		return ch
+	}
+	if n.right == nil {
+		n.right = ch
+		return ch
+	}
+	panic("binary tree node can only have two nodes")
+}
+
+// CountUnivals is solution for 008
+func (n *Node) CountUnivals() int {
+	if n == nil {
+		return 0
+	}
+	if n.left == nil && n.right == nil {
+		// leaf Node is unival
+		n.isUnival = true
+		return 1
+	}
+	n.count += n.left.CountUnivals()
+	n.count += n.right.CountUnivals()
+	if n.left != nil && n.right != nil &&
+		n.left.isUnival && n.right.isUnival &&
+		n.left.value == n.right.value && n.value == n.left.value {
+		// n.value is universal value
+		n.isUnival = true
+		n.count++
+	}
+	return n.count
 }

001-050/008/go/code_test.go

@@ -6,25 +6,66 @@ package _008
 
 import (
 	"reflect"
+	"strconv"
 	"testing"
 )
 
-func TestSolution(t *testing.T) {
-	type args struct {
+func buildTree(values []int, edges map[int][]int) *Node {
+	if len(values) < 1 {
+		panic("root => 1")
 	}
-	type want struct {
+	root := NewNode(values[1])
+
+	nodeMp := map[int]*Node{1: root}
+	newNode := func(val int) *Node {
+		kn, ok := nodeMp[val]
+		if !ok {
+			kn = NewNode(values[val])
+			nodeMp[val] = kn
+		}
+		return kn
+	}
+
+	for key, list := range edges {
+		kn := newNode(key)
+		if len(list) >= 1 {
+			kn.AddChild(newNode(list[0]))
+		}
+		if len(list) >= 2 {
+			kn.AddChild(newNode(list[1]))
+		}
 	}
+	return root
+}
+
+func TestOne(t *testing.T) {
 	tests := []struct {
-		name string
-		args args
-		want want
+		values      []int
+		edges       map[int][]int
+		noOfUnivals int
 	}{
-		// TODO: Add test cases.
+		{
+			values: []int{-1, 0, 1, 0, 1, 0, 1, 1},
+			edges: map[int][]int{
+				1: {2, 3},
+				3: {4, 5},
+				4: {6, 7},
+			},
+			noOfUnivals: 5,
+		},
+		{
+			values: []int{-1, 0, 1},
+			edges: map[int][]int{
+				1: {2},
+			},
+			noOfUnivals: 1,
+		},
 	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := Solution(); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("Solution() = %v, want %v", got, tt.want)
+	for i, tt := range tests {
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			tree := buildTree(tt.values, tt.edges)
+			if got := tree.CountUnivals(); !reflect.DeepEqual(got, tt.noOfUnivals) {
+				t.Errorf("tree.CountUnivals() = %v, want %v", got, tt.noOfUnivals)
 			}
 		})
 	}

001-050/009/c++/code.cpp

@@ -57,6 +57,7 @@ void second() {
         cin >> cur;
         if (i == 0) {
             b = max(a, cur);
+            ans = b;
             continue;
         }
         ans = max(b, max(cur, a + cur));

001-050/009/c++/in.txt

@@ -1,4 +1,4 @@
-7
+10
 5
 2 4 6 2 5
 4
@@ -13,3 +13,9 @@
 -2 -4 -6 -1 -5
 5
 -2 -4 -6 -1 5
+1
+1
+2
+1 2
+1
+-1

001-050/009/c++/out.txt

@@ -5,3 +5,6 @@
 0
 0
 5
+1
+2
+0

001-050/009/go/code.go

@@ -7,6 +7,22 @@
 package _009
 
 // Solution for 009
-func Solution() interface{} {
-	return nil
+func Solution(in []int) int {
+	n := len(in)
+	if n == 0 {
+		return 0
+	}
+	max := func(a, b int) int {
+		if a > b {
+			return a
+		}
+		return b
+	}
+	// answers: current, till last index, till last second index
+	ans, lastAns, lastSecAns := 0, 0, 0
+	for _, cur := range in {
+		ans = max(max(lastAns, lastSecAns), max(cur, lastSecAns+cur))
+		lastAns, lastSecAns = ans, lastAns
+	}
+	return ans
 }

001-050/009/go/code_test.go

@@ -6,24 +6,59 @@ package _009
 
 import (
 	"reflect"
+	"strconv"
 	"testing"
 )
 
 func TestSolution(t *testing.T) {
-	type args struct {
-	}
-	type want struct {
-	}
 	tests := []struct {
-		name string
-		args args
-		want want
+		args []int
+		want int
 	}{
-		// TODO: Add test cases.
+		{
+			args: []int{2, 4, 6, 2, 5},
+			want: 13,
+		},
+		{
+			args: []int{5, 1, 1, 5},
+			want: 10,
+		},
+		{
+			args: []int{-5, -1, -1, -5},
+			want: 0,
+		},
+		{
+			args: []int{5, 5, 10, 100, 10, 5, 5, 5, 10, 100, 10, 5, 5, 5, 10, 100, 10, 5, 5, 5, 10, 100, 10, 5, 5, 5, 10, 100, 10, 5, 5, 5, 10, 100, 10, 5, 5, 5, 10, 100, 10, 5, 5, 5, 10, 100, 10, 5, 5, 5, 10, 100, 10, 5, 5, 5, 10, 100, 10, 5},
+			want: 1100,
+		},
+		{
+			args: []int{-2, -4, -6, -2, -5},
+			want: 0,
+		},
+		{
+			args: []int{-2, -4, -6, -1, -5},
+			want: 0,
+		},
+		{
+			args: []int{-2, -4, -6, -1, 5},
+			want: 5,
+		},
+		{
+			args: []int{1},
+			want: 1,
+		},
+		{
+			args: []int{1, 2},
+			want: 2,
+		},
+		{
+			args: []int{-1},
+			want: 0,
+		},
 	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := Solution(); !reflect.DeepEqual(got, tt.want) {
+	for i, tt := range tests {
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			if got := Solution(tt.args); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("Solution() = %v, want %v", got, tt.want)
 			}
 		})

001-050/010/go/code.go

@@ -6,7 +6,87 @@
 // TestSolution for test cases
 package _010
 
-// Solution for 010
-func Solution() interface{} {
-	return nil
+import (
+	"errors"
+	"sync"
+	"time"
+)
+
+var ErrSchedulerStopped = errors.New("scheduler has been stopped")
+
+type Scheduler interface {
+	// Schedule schedules fn after dur time with returned id until
+	// it is not stopped using StopScheduling
+	Schedule(fn func(), dur time.Duration) (int, error)
+	// StopScheduling: stops Scheduler from scheduling any more, using
+	// Schedule after StopScheduling() will return ErrSchedulerStopped
+	StopScheduling()
+	// Ack: helps acknowledge that the Schedule function is finished
+	// using the int::id provided at time of Schedule()
+	Ack() <-chan int
+}
+
+// NewScheduler creates a new scheduler
+func NewScheduler() Scheduler {
+	return newRunner()
+}
+
+type runner struct {
+	wg   sync.WaitGroup
+	list chan *job
+	ack  chan int
+	size int // if -1 means closed
+}
+
+func (r *runner) Schedule(fn func(), dur time.Duration) (int, error) {
+	if r.size == -1 {
+		return 0, ErrSchedulerStopped
+	}
+	r.size++
+	r.list <- &job{dur: dur, fn: fn, id: r.size}
+	return r.size, nil
+}
+
+func (r *runner) StopScheduling() {
+	defer close(r.ack)
+	r.size = -1
+	close(r.list)
+	r.wg.Done() // self runner goroutine
+	r.wg.Wait()
+}
+
+func (r *runner) Ack() <-chan int {
+	return r.ack
+}
+
+func newRunner() *runner {
+	rn := &runner{
+		wg:   sync.WaitGroup{},
+		list: make(chan *job),
+		ack:  make(chan int),
+	}
+	rn.run()
+	return rn
+}
+
+func (r *runner) run() {
+	r.wg.Add(1)
+	go func() {
+		for job := range r.list {
+			job := job
+			r.wg.Add(1)
+			go func() {
+				defer r.wg.Done()
+				time.Sleep(job.dur)
+				job.fn()
+				r.ack <- job.id
+			}()
+		}
+	}()
+}
+
+type job struct {
+	id  int
+	fn  func()
+	dur time.Duration
 }

001-050/010/go/code_test.go

@@ -5,27 +5,57 @@
 package _010
 
 import (
-	"reflect"
 	"testing"
+	"time"
 )
 
-func TestSolution(t *testing.T) {
-	type args struct {
+func nilError(t *testing.T, err error) {
+	t.Helper()
+	if err != nil {
+		t.Error(err, "error should be nil")
 	}
-	type want struct {
+}
+
+func TestScheduler(t *testing.T) {
+	fn := func(d time.Duration) (func(), time.Duration) {
+		return func() { t.Log("ran after", d) }, d
 	}
-	tests := []struct {
-		name string
-		args args
-		want want
-	}{
-		// TODO: Add test cases.
+
+	mp, cnt := map[int]struct{}{}, 0
+	check := func(id int, err error) {
+		cnt++
+		nilError(t, err)
+		if _, ok := mp[id]; ok {
+			t.Error("scheduled fn id must be unique")
+		}
+		mp[id] = struct{}{}
 	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := Solution(); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("Solution() = %v, want %v", got, tt.want)
+
+	// scheduler
+	sch := NewScheduler()
+
+	// acknowledgement
+	done := make(chan struct{})
+	go func() {
+		for id := range sch.Ack() {
+			if id > cnt || id < 0 {
+				t.Error("acknowledged id must be among the ids of scheduler", "id", id)
 			}
-		})
+		}
+		done <- struct{}{}
+	}()
+
+	check(sch.Schedule(fn(time.Second)))
+	check(sch.Schedule(fn(time.Millisecond)))
+	check(sch.Schedule(fn(100 * time.Nanosecond)))
+
+	// stop scheduling
+	sch.StopScheduling()
+
+	// try adding again
+	if _, err := sch.Schedule(fn(time.Second)); err != ErrSchedulerStopped {
+		t.Error("ErrSchedulerStopped error should be returned")
 	}
+
+	<-done
 }