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
+}

2021/day2/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

2021/day2/.idea/day2.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="Go" enabled="true" />
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

2021/day2/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/day2.iml" filepath="$PROJECT_DIR$/.idea/day2.iml" />
+    </modules>
+  </component>
+</project>

2021/day2/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+  </component>
+</project>

2021/day2/go.mod

@@ -0,0 +1,3 @@
+module day2
+
+go 1.21

2021/day2/main.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func NewData(s string) Data {
+	f := strings.Fields(s)
+	a, err := strconv.Atoi(f[1])
+	if err != nil {
+		return Data{}
+	}
+	return Data{
+		Direction: f[0],
+		Amount:    a,
+	}
+}
+func GetData(s string) []Data {
+	var data []Data
+	r, err := os.Open(s)
+	if err != nil {
+		return data
+	}
+	fileScanner := bufio.NewScanner(r)
+	fileScanner.Split(bufio.ScanLines)
+	for fileScanner.Scan() {
+		data = append(data, NewData(fileScanner.Text()))
+	}
+	return data
+}
+
+type Data struct {
+	Direction string
+	Amount    int
+}
+
+func main() {
+	data := GetData("./data")
+	result := Part1(data)
+	fmt.Printf("Result part 1: %d\n", result)
+	result = Part2(data)
+	fmt.Printf("Result part 1: %d\n", result)
+}
+
+type Point struct {
+	X   int
+	Y   int
+	Aim int
+}
+
+func (p Point) Multiply() int {
+	return p.Y * p.X
+}
+
+func Part1(data []Data) int {
+	var point Point
+	for _, d := range data {
+		switch d.Direction {
+		case "forward":
+			point.X += d.Amount
+		case "down":
+			point.Y += d.Amount
+		case "up":
+			point.Y -= d.Amount
+		}
+	}
+	return point.Multiply()
+}
+
+func Part2(data []Data) int {
+	var point Point
+	for _, d := range data {
+		switch d.Direction {
+		case "forward":
+			point.X += d.Amount
+			point.Y += point.Aim * d.Amount
+		case "down":
+			point.Aim += d.Amount
+		case "up":
+			point.Aim -= d.Amount
+		}
+	}
+	return point.Multiply()
+}

2021/day2/main_test.go

@@ -0,0 +1,20 @@
+package main
+
+import "testing"
+
+func TestPart1(t *testing.T) {
+	const expected = 150
+	data := GetData("./test-data")
+	result := Part1(data)
+	if result != expected {
+		t.Fatalf("Return: %d Expects: %d", result, expected)
+	}
+}
+func TestPart2(t *testing.T) {
+	const expected = 900
+	data := GetData("./test-data")
+	result := Part2(data)
+	if result != expected {
+		t.Fatalf("Return: %d Expects: %d", result, expected)
+	}
+}

2021/day2/task.txt

@@ -0,0 +1,66 @@
+--- Day 2: Dive! ---
+
+Now, you need to figure out how to pilot this thing.
+
+It seems like the submarine can take a series of commands like forward 1, down 2, or up 3:
+
+    forward X increases the horizontal position by X units.
+    down X increases the depth by X units.
+    up X decreases the depth by X units.
+
+Note that since you're on a submarine, down and up affect your depth, and so they have the opposite result of what you might expect.
+
+The submarine seems to already have a planned course (your puzzle input). You should probably figure out where it's going. For example:
+
+forward 5
+down 5
+forward 8
+up 3
+down 8
+forward 2
+
+Your horizontal position and depth both start at 0. The steps above would then modify them as follows:
+
+    forward 5 adds 5 to your horizontal position, a total of 5.
+    down 5 adds 5 to your depth, resulting in a value of 5.
+    forward 8 adds 8 to your horizontal position, a total of 13.
+    up 3 decreases your depth by 3, resulting in a value of 2.
+    down 8 adds 8 to your depth, resulting in a value of 10.
+    forward 2 adds 2 to your horizontal position, a total of 15.
+
+After following these instructions, you would have a horizontal position of 15 and a depth of 10. (Multiplying these together produces 150.)
+
+Calculate the horizontal position and depth you would have after following the planned course. What do you get if you multiply your final horizontal position by your final depth?
+
+To begin, get your puzzle input.
+
+Answer: 2091984
+
+--- Part Two ---
+
+Based on your calculations, the planned course doesn't seem to make any sense. You find the submarine manual and discover that the process is actually slightly more complicated.
+
+In addition to horizontal position and depth, you'll also need to track a third value, aim, which also starts at 0. The commands also mean something entirely different than you first thought:
+
+    down X increases your aim by X units.
+    up X decreases your aim by X units.
+    forward X does two things:
+        It increases your horizontal position by X units.
+        It increases your depth by your aim multiplied by X.
+
+Again note that since you're on a submarine, down and up do the opposite of what you might expect: "down" means aiming in the positive direction.
+
+Now, the above example does something different:
+
+    forward 5 adds 5 to your horizontal position, a total of 5. Because your aim is 0, your depth does not change.
+    down 5 adds 5 to your aim, resulting in a value of 5.
+    forward 8 adds 8 to your horizontal position, a total of 13. Because your aim is 5, your depth increases by 8*5=40.
+    up 3 decreases your aim by 3, resulting in a value of 2.
+    down 8 adds 8 to your aim, resulting in a value of 10.
+    forward 2 adds 2 to your horizontal position, a total of 15. Because your aim is 10, your depth increases by 2*10=20 to a total of 60.
+
+After following these new instructions, you would have a horizontal position of 15 and a depth of 60. (Multiplying these produces 900.)
+
+Using this new interpretation of the commands, calculate the horizontal position and depth you would have after following the planned course. What do you get if you multiply your final horizontal position by your final depth?
+
+Answer:

2021/day2/test-data

@@ -0,0 +1,6 @@
+forward 5
+down 5
+forward 8
+up 3
+down 8
+forward 2

2021/day3/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

2021/day3/.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+  </state>
+</component>

2021/day3/.idea/day3.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="Go" enabled="true" />
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

2021/day3/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/day3.iml" filepath="$PROJECT_DIR$/.idea/day3.iml" />
+    </modules>
+  </component>
+</project>

2021/day3/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+  </component>
+</project>

2021/day3/go.mod

@@ -0,0 +1,3 @@
+module day3
+
+go 1.21

2021/day3/main.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("GoFast!")
+}
+
+func Part1() int {
+	return 0
+}

2021/day3/main_test.go

@@ -0,0 +1,11 @@
+package main
+
+import "testing"
+
+func TestPart1(t *testing.T) {
+	const expected = 198
+	result := Part1()
+	if result != expected {
+		t.Fatalf("Expected: %d Result: %d", expected, result)
+	}
+}

2021/day3/task.txt

@@ -0,0 +1,38 @@
+--- Day 3: Binary Diagnostic ---
+
+The submarine has been making some odd creaking noises, so you ask it to produce a diagnostic report just in case.
+
+The diagnostic report (your puzzle input) consists of a list of binary numbers which, when decoded properly, can tell you many useful things about the conditions of the submarine. The first parameter to check is the power consumption.
+
+You need to use the binary numbers in the diagnostic report to generate two new binary numbers (called the gamma rate and the epsilon rate). The power consumption can then be found by multiplying the gamma rate by the epsilon rate.
+
+Each bit in the gamma rate can be determined by finding the most common bit in the corresponding position of all numbers in the diagnostic report. For example, given the following diagnostic report:
+
+00100
+11110
+10110
+10111
+10101
+01111
+00111
+11100
+10000
+11001
+00010
+01010
+
+Considering only the first bit of each number, there are five 0 bits and seven 1 bits. Since the most common bit is 1, the first bit of the gamma rate is 1.
+
+The most common second bit of the numbers in the diagnostic report is 0, so the second bit of the gamma rate is 0.
+
+The most common value of the third, fourth, and fifth bits are 1, 1, and 0, respectively, and so the final three bits of the gamma rate are 110.
+
+So, the gamma rate is the binary number 10110, or 22 in decimal.
+
+The epsilon rate is calculated in a similar way; rather than use the most common bit, the least common bit from each position is used. So, the epsilon rate is 01001, or 9 in decimal. Multiplying the gamma rate (22) by the epsilon rate (9) produces the power consumption, 198.
+
+Use the binary numbers in your diagnostic report to calculate the gamma rate and epsilon rate, then multiply them together. What is the power consumption of the submarine? (Be sure to represent your answer in decimal, not binary.)
+
+To begin, get your puzzle input.
+
+Answer:

2021/day3/test-data

@@ -0,0 +1,12 @@
+00100
+11110
+10110
+10111
+10101
+01111
+00111
+11100
+10000
+11001
+00010
+01010