2023 day 09

2023/09/part1/part1.go

@@ -0,0 +1,85 @@
+
+package part1
+
+import (
+	"bufio"
+	"strings"
+	"strconv"
+	"os"
+	"errors"
+	"fmt"
+)
+
+func main() {
+	reader := bufio.NewReader(os.Stdin);
+	total := 0;
+	for {
+		line, err := reader.ReadString('\n');
+		if (err != nil) {
+			break
+		}
+		values, err := LineConv(line)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		next, err := Next(values)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		total += next;
+		fmt.Printf("%v => %v\n", values, next)
+	}
+	println(total)
+	return
+}
+
+func Next(src []int) (int, error) {
+	if len(src) < 2 {
+		return 0, errors.New("not enough data!")
+	}
+	if  IsZero(src) {
+		return 0, nil
+	}
+	deriv := Deriv(src)
+	nextDelta, err := Next(deriv)
+	if (err != nil) {
+		return 0, err 
+	}
+	return src[len(src)-1] + nextDelta, nil
+}
+
+func Deriv(src []int) (deriv []int) {
+	for i := range src {
+		if i == len(src)-1 {
+			break
+		}
+		deriv = append(deriv, src[i+1] - src[i])
+	}
+	return
+}
+
+func IsZero(src []int) bool {
+	res := true
+	for _,v := range src {
+		if v != 0 {
+			res = false
+		}
+	}
+	return res
+}
+
+func LineConv(line string) ( []int, error ) {
+	strs := strings.Split(strings.Trim(line, "\n"), " ")
+	values := []int{};
+	for _, str := range strs {
+		value, err := strconv.Atoi(str)
+		if (err != nil) {
+			return []int{}, err
+		}
+		values = append(values, value)
+	}
+	return values, nil;
+}
+

2023/09/part1/part1_test.go

@@ -0,0 +1,70 @@
+
+package part1
+
+import (
+	"testing"
+	"reflect"
+)
+
+func TestNextConst(t *testing.T) {
+	next, err := Next([]int{1, 1, 1})
+	equal(t, err, nil)
+	equal(t, next, 1)
+	next, err = Next([]int{2, 2, 2})
+	equal(t, err, nil)
+	equal(t, next, 2)
+}
+
+func TestNextLinear(t *testing.T) {
+	next, err := Next([]int{0, 1, 2, 3})
+	equal(t, err, nil)
+	equal(t, next, 4)
+}
+
+func TestNextQuad(t *testing.T) {
+	next, err := Next([]int{0, 1, 4, 9, 16})
+	equal(t, err, nil)
+	equal(t, next, 25)
+}
+
+func TestNextBadList(t *testing.T) {
+	v, err := Next([]int{0, 5, 2})
+	if err == nil {
+		t.Errorf("expected error, got %v", v)
+	}
+}
+
+func TestDerivConst(t *testing.T) {
+	equal(t, Deriv([]int{1,1,1}), []int{0,0})
+	equal(t, Deriv([]int{2,2,2}), []int{0,0})
+}
+
+func TestDerivLinear(t *testing.T) {
+	equal(t, Deriv([]int{0,1,2}), []int{1,1})
+	equal(t, Deriv([]int{0,2,4}), []int{2,2})
+}
+
+func TestDerivQuad(t *testing.T) {
+	equal(t, Deriv([]int{0,1,4,9,16}), []int{1,3,5,7})
+}
+
+func TestIsZero(t *testing.T) {
+	equal(t, IsZero([]int{0}), true)
+	equal(t, IsZero([]int{0, 0}), true)
+	equal(t, IsZero([]int{1}), false)
+	equal(t, IsZero([]int{1, 1}), false)
+	equal(t, IsZero([]int{1, 0}), false)
+}
+
+func TestLineConv(t *testing.T) {
+	r, err := LineConv("0 1 2 3")
+	equal(t, err, nil)
+	equal(t, r, []int{0, 1, 2, 3})
+}
+
+func equal(t *testing.T, actual any, target any) {
+	if !reflect.DeepEqual(actual, target) {
+		t.Errorf("expected %v, got %v", target, actual)
+	}
+}
+