day06

diff --git a/2023/go/day05/__debug_bin1342718261 b/2023/go/day05/__debug_bin1342718261
deleted file mode 100755 (executable)
index ea895ae..0000000
Binary files a/2023/go/day05/__debug_bin1342718261 and /dev/null differ

diff --git a/2023/go/day05/day05.go b/2023/go/day05/day05.go
index 902eb4367f2017e001af679b4674660cb673c398..ec4698abe7ecd8811057c571d71a5133543b20e3 100644 (file)
--- a/2023/go/day05/day05.go
+++ b/2023/go/day05/day05.go
@@ -12,9 +12,9 @@ import (
 )
 
 type Map struct {
-       dest_range_start        int
-       src_range_start         int
-       range_len                       int
+       dest_range_start        uint64
+       src_range_start         uint64
+       range_len                       uint64
 }
 
 type Almanac struct {
@@ -28,16 +28,16 @@ type Almanac struct {
 }
 
 type SeedMap struct {
-       seed int
-       range_len int
+       seed uint64
+       range_len uint64
 }
 
-func Part1(input string) int {
+func Part1(input string) uint64 {
        seeds, almanac, _ := parseInput1(input)
        fmt.Println(seeds)
        fmt.Println(almanac)
 
-       minLoc := utils.MaxInt
+       minLoc := uint64(utils.MaxInt)
        for _, seed := range seeds {
                soil := lookup_dest(seed, almanac.seed2soil)
                fert := lookup_dest(soil, almanac.soil2fert)
@@ -57,38 +57,24 @@ func Part1(input string) int {
 
 func Part2(input string) int {
        seedsmap, almanac, _ := parseInput2(input)
-       fmt.Println(seedsmap)
-       fmt.Println(almanac)
-       minLocMap := Map{dest_range_start: utils.MaxInt}
-       for _, x := range almanac.humid2loc {
-               if x.dest_range_start< minLocMap.dest_range_start {
-                       minLocMap = x
-               }
-       }
-       fmt.Println(minLocMap.dest_range_start)
 
-       for i:=minLocMap.src_range_start;i<minLocMap.src_range_start+minLocMap.range_len;i++ {
-               temp := lookup_src(i, almanac.temp2humid)
-               fmt.Println(temp)
-       }
 
-//     minSeedMap := SeedMap{}
-//     minLoc := utils.MaxInt
-//     for _, seedmap := range seedsmap {
-//             for _, i := range []int{seedmap.seed, seedmap.seed+seedmap.range_len} {
-//                     soil := lookup_dest(i, almanac.seed2soil)
-//                     fert := lookup_dest(soil, almanac.soil2fert)
-//                     water := lookup_dest(fert, almanac.fert2water)
-//                     light := lookup_dest(water, almanac.water2light)
-//                     temp := lookup_dest(light, almanac.light2temp)
-//                     humid := lookup_dest(temp, almanac.temp2humid)
-//                     loc := lookup_dest(humid, almanac.humid2loc)
-//                     if loc < minLoc {
-//                             minSeedMap = seedmap
-//                             minLoc = loc
-//                     }
-//             }
-//     }
+       minLoc := uint64(utils.MaxInt)
+       for _, seedmap := range seedsmap {
+               for i := seedmap.seed;i<seedmap.seed+seedmap.range_len;i++ {
+                       soil := lookup_dest(i, almanac.seed2soil)
+                       fert := lookup_dest(soil, almanac.soil2fert)
+                       water := lookup_dest(fert, almanac.fert2water)
+                       light := lookup_dest(water, almanac.water2light)
+                       temp := lookup_dest(light, almanac.light2temp)
+                       humid := lookup_dest(temp, almanac.temp2humid)
+                       loc := lookup_dest(humid, almanac.humid2loc)
+                       if loc < minLoc {
+                               minLoc = loc
+                       }
+               }
+               fmt.Println(minLoc)
+       }
 //     
 //     fmt.Println(minSeedMap)
 //     minLoc = utils.MaxInt
@@ -104,10 +90,10 @@ func Part2(input string) int {
 //                     minLoc = loc
 //             }
 //     }       
-       return -1
+       return int(minLoc)
 }
 
-func lookup_dest(entity int, data []Map) int {
+func lookup_dest(entity uint64, data []Map) uint64 {
        for _, dataMap := range data {
                if entity >= dataMap.src_range_start && entity <= dataMap.src_range_start + dataMap.range_len {
                        return dataMap.dest_range_start + entity - dataMap.src_range_start
@@ -116,7 +102,7 @@ func lookup_dest(entity int, data []Map) int {
        return entity
 }
 
-func lookup_src(entity int, data []Map) int {
+func lookup_src(entity uint64, data []Map) uint64 {
        for _, dataMap := range data {
                if entity >= dataMap.dest_range_start && entity <= dataMap.dest_range_start + dataMap.range_len {
                        return dataMap.src_range_start + entity - dataMap.dest_range_start
@@ -125,16 +111,16 @@ func lookup_src(entity int, data []Map) int {
        return entity
 }
 
-func parseInput1(input string) ([]int, Almanac, error) {
+func parseInput1(input string) ([]uint64, Almanac, error) {
        
        var almanac Almanac
-       var seeds []int
+       var seeds []uint64
 
        lines := strings.Split(input, "\n")
        seedLine := string(lines[0])
        tokens := strings.Fields(seedLine)
        for _, token := range tokens[1:] {
-                       seeds = append(seeds, utils.MustAtoi(token))
+                       seeds = append(seeds, uint64(utils.MustAtoi(token)))
        }
 
        blocks := strings.Split(input, "\n\n")
@@ -171,8 +157,8 @@ func parseInput2(input string) ([]SeedMap, Almanac, error) {
        seedLine := string(lines[0])
        tokens := strings.Fields(seedLine)
        for i:=1;i<len(tokens);i=i+2 {
-               seedStart := utils.MustAtoi(tokens[i])
-               seedRange := utils.MustAtoi(tokens[i+1])
+               seedStart := uint64(utils.MustAtoi(tokens[i]))
+               seedRange := uint64(utils.MustAtoi(tokens[i+1]))
                        seeds = append(seeds, SeedMap{seedStart, seedRange})
        }
 
@@ -205,7 +191,7 @@ func getMap(input []string) []Map {
        var out []Map
        for _, line := range input {
                tokens := strings.Fields(line)
-               out = append(out, Map{utils.MustAtoi(tokens[0]), utils.MustAtoi(tokens[1]),utils.MustAtoi(tokens[2])})
+               out = append(out, Map{uint64(utils.MustAtoi(tokens[0])), uint64(utils.MustAtoi(tokens[1])),uint64(utils.MustAtoi(tokens[2]))})
        }
        return out
 }
\ No newline at end of file

diff --git a/2023/go/day06/day06.go b/2023/go/day06/day06.go
new file mode 100644 (file)
index 0000000..6c8ce21
--- /dev/null
+++ b/2023/go/day06/day06.go
@@ -0,0 +1,71 @@
+package day06
+
+import (
+       "fmt"
+       "math"
+)
+
+type Input struct {
+       Time uint64
+       Distance uint64
+}
+func Part1(input string) int {
+       answer := 1.0
+       ins := parseInput1(input)
+       for _, in := range ins {
+               t1, t2, _ := solveQuadratic(1, float64(in.Time) * -1, float64(in.Distance))
+               fmt.Printf("t1: %v t2: %v ans: %v\n", t1, t2, (t1 - t2 + 1))
+               answer *= (t1 - t2 + 1)
+
+       }
+       return int(answer)
+}
+
+func Part2(input string) int {
+       answer := 1.0
+       ins := parseInput2(input)
+       for _, in := range ins {
+               t1, t2, _ := solveQuadratic(1, float64(in.Time) * -1, float64(in.Distance))
+               fmt.Printf("t1: %v t2: %v ans: %v\n", t1, t2, (t1 - t2 + 1))
+               answer *= (t1 - t2 + 1)
+
+       }
+       return int(answer)}
+
+func parseInput1(input string) []Input {
+       var in []Input
+       in = append(in, Input{46, 214})
+       in = append(in, Input{80, 1177})
+       in = append(in, Input{78, 1402})
+       in = append(in, Input{66, 1024})
+       return in
+}
+
+func parseInput2(input string) []Input {
+       var in []Input
+       in = append(in, Input{46807866, 214117714021024})
+       return in
+}
+
+func solveQuadratic(a, b, c float64) (float64, float64, error) {
+       // Calculate the discriminant
+       discriminant := b*b - 4*a*c
+
+       // Check if the discriminant is non-negative
+       if discriminant < 0 {
+               return 0, 0, fmt.Errorf("no real roots, discriminant is negative")
+       }
+
+       // Calculate the roots
+       root1 := (-b + math.Sqrt(discriminant)) / (2 * a)
+       root2 := (-b - math.Sqrt(discriminant)) / (2 * a)
+
+       if isWholeNumber(root1) { root1 = root1 - 1.0 }
+       if isWholeNumber(root2) { root2 = root2 + 1.0 }
+       return math.Floor(root1), math.Ceil(root2), nil
+}
+
+func isWholeNumber(x float64) bool {
+       rounded := math.Round(x)
+       return x == rounded
+}
\ No newline at end of file

diff --git a/2023/go/day06/day06_test.go b/2023/go/day06/day06_test.go
new file mode 100644 (file)
index 0000000..19463cd
--- /dev/null
+++ b/2023/go/day06/day06_test.go
@@ -0,0 +1,17 @@
+package day06
+
+import (
+       "testing"
+
+       "github.com/stretchr/testify/require"
+)
+
+func TestPart1(t *testing.T) {
+       r := Part1("")
+       require.Equal(t, 512295, r)
+}
+
+func TestPart2(t *testing.T) {
+       r := Part2("")
+       require.Equal(t, 36530883, r)
+}

diff --git a/2023/go/day06/input.txt b/2023/go/day06/input.txt
new file mode 100644 (file)
index 0000000..e5ef7bb
--- /dev/null
+++ b/2023/go/day06/input.txt
@@ -0,0 +1,2 @@
+Time:        46     80     78     66
+Distance:   214   1177   1402   1024