day1 and 2 done & setup for day3

2021/day1/main.go

@@ -1,7 +1,58 @@
 package main
 
-import "fmt"
+import (
+	"fmt"
+)
 
 func main() {
-	fmt.Println("hallo")
+	data := LoadData("./data")
+	c := CountIncreases(&data)
+	fmt.Println(c)
+	data = MutateDataPart2(data)
+	c = CountIncreases(&data)
+	fmt.Println(c)
+}
+
+func MutateDataPart2(data []DataEntry) []DataEntry {
+	var result []DataEntry
+	lastInt := 0
+	for i := range data {
+		if i >= len(data)-2 {
+			continue
+		}
+		value := data[i].Value + data[i+1].Value + data[i+2].Value
+		var status Status
+		switch {
+		case lastInt == 0:
+			status = Nothing
+		case lastInt < value:
+			status = Increased
+		case lastInt > value:
+			status = Decreased
+		case lastInt == value:
+			status = Equal
+		}
+		lastInt = value
+		result = append(result, DataEntry{
+			Value:  value,
+			Status: status,
+		})
+	}
+	return result
+}
+
+func CountIncreases(d *[]DataEntry) int {
+	var count int
+	for _, d := range *d {
+		if d.Status == Increased {
+			count++
+		}
+	}
+	return count
+}
+
+func checkErr(err error) {
+	if err != nil {
+		fmt.Println(err)
+	}
 }

2021/day1/main_test.go

@@ -0,0 +1,20 @@
+package main
+
+import "testing"
+
+func TestCountIncreasesTestData(t *testing.T) {
+	data := LoadData("./test-data")
+	count := 7
+	if c := CountIncreases(&data); c != count {
+		t.Fatalf("Testnumber: %d Result: %d", count, c)
+	}
+}
+
+func TestMutateDataPart2(t *testing.T) {
+	data := LoadData("./test-data")
+	data = MutateDataPart2(data)
+	count := 5
+	if c := CountIncreases(&data); c != count {
+		t.Fatalf("Testnumber: %d Result: %d", count, c)
+	}
+}

2021/day1/task.txt

@@ -44,4 +44,44 @@ In this example, there are 7 measurements that are larger than the previous meas
 
 How many measurements are larger than the previous measurement?
 
+Answer: 1195
+
+
+--- Part Two ---
+
+Considering every single measurement isn't as useful as you expected: there's just too much noise in the data.
+
+Instead, consider sums of a three-measurement sliding window. Again considering the above example:
+
+199  A
+200  A B
+208  A B C
+210    B C D
+200  E   C D
+207  E F   D
+240  E F G
+269    F G H
+260      G H
+263        H
+
+Start by comparing the first and second three-measurement windows. The measurements in the first window are marked A (199, 200, 208); their sum is 199 + 200 + 208 = 607. The second window is marked B (200, 208, 210); its sum is 618. The sum of measurements in the second window is larger than the sum of the first, so this first comparison increased.
+
+Your goal now is to count the number of times the sum of measurements in this sliding window increases from the previous sum. So, compare A with B, then compare B with C, then C with D, and so on. Stop when there aren't enough measurements left to create a new three-measurement sum.
+
+In the above example, the sum of each three-measurement window is as follows:
+
+A: 607 (N/A - no previous sum)
+B: 618 (increased)
+C: 618 (no change)
+D: 617 (decreased)
+E: 647 (increased)
+F: 716 (increased)
+G: 769 (increased)
+H: 792 (increased)
+
+In this example, there are 5 sums that are larger than the previous sum.
+
+Consider sums of a three-measurement sliding window.
+How many sums are larger than the previous sum?
+
 Answer:

2021/day1/test-data

@@ -0,0 +1,10 @@
+199
+200
+208
+210
+200
+207
+240
+269
+260
+263

2021/day1/util.go

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"bufio"
+	"os"
+	"strconv"
+)
+
+func LoadData(path string) []DataEntry {
+	readFile, err := os.Open(path)
+	checkErr(err)
+	fileScanner := bufio.NewScanner(readFile)
+	fileScanner.Split(bufio.ScanLines)
+	var fileLines []string
+	for fileScanner.Scan() {
+		fileLines = append(fileLines, fileScanner.Text())
+	}
+	err = readFile.Close()
+	checkErr(err)
+	var data []DataEntry
+	lastData := 0
+	for _, line := range fileLines {
+		toInt, err := strconv.Atoi(line)
+		status := Nothing
+		checkErr(err)
+		switch {
+		case lastData == 0:
+			status = Nothing
+		case lastData < toInt:
+			status = Increased
+		case lastData > toInt:
+			status = Decreased
+		case lastData == toInt:
+			status = Equal
+		}
+		lastData = toInt
+		data = append(data, DataEntry{
+			Value:  toInt,
+			Status: status,
+		})
+	}
+	return data
+}
+
+type Status int
+
+const (
+	Nothing Status = iota
+	Decreased
+	Increased
+	Equal
+)
+
+func (s Status) String() string {
+	switch s {
+	case Nothing:
+		return "N/A - no previous measurement"
+	case Increased:
+		return "increased"
+	case Decreased:
+		return "decreased"
+	case Equal:
+		return "equal"
+	default:
+		return ""
+	}
+}
+
+type DataEntry struct {
+	Value  int
+	Status Status
+}