feat: Add bus factor solution.

Author: goloroden

README.md

@@ -7,6 +7,7 @@ codingcircle contains the examples from the YouTube Coding Cirle.
 So far, the following exercises have been covered:
 
 - [Autocomplete](./autocomplete/) – implements an autocomplete feature using a trie
+- [Busfactor](./busfactor/) – calculates the the maximum load of a bus based on events
 - [Cons, Car, Cdr & co.](./cons) – implements a cons cell and the corresponding functions
 - [Continous maximum](./continuousmax/) – calculates the maximum of a sliding window
 - [Floyd](./floyd/) – implements Floyd's cycle-finding "Tortoise and Hare" algorithm

busfactor/documentation.go

@@ -0,0 +1,2 @@
+// Package busfactor calculates the maximum load of a bus based on events.
+package busfactor

busfactor/get_maximum_load.go

@@ -0,0 +1,52 @@
+package busfactor
+
+import (
+	"errors"
+	"time"
+)
+
+type Event struct {
+	Time  time.Time
+	Type  string
+	Count int
+}
+
+type Result struct {
+	Count int
+	From  time.Time
+	Until time.Time
+}
+
+func GetMaximumLoad(events []Event) Result {
+	currentLoad := 0
+	maxLoad := 0
+	maxLoadStartTime := events[0].Time
+	maxLoadEndTime := events[0].Time
+
+	for i, event := range events {
+		switch event.Type {
+		case "joined":
+			currentLoad += event.Count
+		case "left":
+			currentLoad -= event.Count
+		default:
+			panic(errors.New("unknown event type"))
+		}
+
+		if currentLoad > maxLoad {
+			maxLoad = currentLoad
+			maxLoadStartTime = event.Time
+			if i+1 < len(events) {
+				maxLoadEndTime = events[i+1].Time
+			} else {
+				maxLoadEndTime = event.Time
+			}
+		}
+	}
+
+	return Result{
+		Count: maxLoad,
+		From:  maxLoadStartTime,
+		Until: maxLoadEndTime,
+	}
+}

busfactor/get_maximum_load_test.go

@@ -0,0 +1,40 @@
+package busfactor_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thenativeweb/codingcircle/busfactor"
+)
+
+func TestGetMaximumLoad(t *testing.T) {
+	t.Run("with a single event", func(t *testing.T) {
+		now := time.Now()
+
+		result := busfactor.GetMaximumLoad([]busfactor.Event{
+			{Time: now, Type: "joined", Count: 3},
+		})
+
+		assert.Equal(t, 3, result.Count)
+		assert.Equal(t, now, result.From)
+		assert.Equal(t, now, result.Until)
+	})
+
+	t.Run("with multiple events", func(t *testing.T) {
+		now := time.Now()
+
+		result := busfactor.GetMaximumLoad([]busfactor.Event{
+			{Time: now, Type: "joined", Count: 3},                      // 3
+			{Time: now.Add(1 * time.Second), Type: "left", Count: 1},   // 2
+			{Time: now.Add(2 * time.Second), Type: "joined", Count: 5}, // 7
+			{Time: now.Add(3 * time.Second), Type: "left", Count: 4},   // 3
+			{Time: now.Add(4 * time.Second), Type: "joined", Count: 2}, // 5
+			{Time: now.Add(5 * time.Second), Type: "left", Count: 4},   // 1
+		})
+
+		assert.Equal(t, 7, result.Count)
+		assert.Equal(t, now.Add(2*time.Second), result.From)
+		assert.Equal(t, now.Add(3*time.Second), result.Until)
+	})
+}