move unit64 back to int

[adventofcode.git] / 2023 / go / day05 / day05.go

diff --git a/2023/go/day05/day05.go b/2023/go/day05/day05.go
index ec4698abe7ecd8811057c571d71a5133543b20e3..39450e310d325914a4c4a8f945e6923a2063af8b 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        uint64
-       src_range_start         uint64
-       range_len                       uint64
+       dest_range_start        int
+       src_range_start         int
+       range_len                       int
 }
 
 type Almanac struct {
@@ -28,16 +28,16 @@ type Almanac struct {
 }
 
 type SeedMap struct {
-       seed uint64
-       range_len uint64
+       seed int
+       range_len int
 }
 
-func Part1(input string) uint64 {
+func Part1(input string) int {
        seeds, almanac, _ := parseInput1(input)
        fmt.Println(seeds)
        fmt.Println(almanac)
 
-       minLoc := uint64(utils.MaxInt)
+       minLoc := int(utils.MaxInt)
        for _, seed := range seeds {
                soil := lookup_dest(seed, almanac.seed2soil)
                fert := lookup_dest(soil, almanac.soil2fert)
@@ -58,42 +58,25 @@ func Part1(input string) uint64 {
 func Part2(input string) int {
        seedsmap, almanac, _ := parseInput2(input)
 
-
-       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
+       for i:=0;i<utils.MaxInt;i++{
+               humid := lookup_src(int(i), almanac.humid2loc)
+               temp := lookup_src(humid, almanac.temp2humid)
+               light := lookup_src(temp, almanac.light2temp)
+               water := lookup_src(light, almanac.water2light)
+               fert := lookup_src(water, almanac.fert2water)
+               soil := lookup_src(fert, almanac.soil2fert)
+               seed := lookup_src(soil, almanac.seed2soil)
+
+               for _, seedmap := range seedsmap {
+                       if seed >= seedmap.seed && seed < seedmap.seed+seedmap.range_len {
+                               return i
                        }
                }
-               fmt.Println(minLoc)
        }
-//     
-//     fmt.Println(minSeedMap)
-//     minLoc = utils.MaxInt
-//     for i:=minSeedMap.seed;i<minSeedMap.seed+minSeedMap.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
-//             }
-//     }       
-       return int(minLoc)
+       return -1
 }
 
-func lookup_dest(entity uint64, data []Map) uint64 {
+func lookup_dest(entity int, data []Map) int {
        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
@@ -102,7 +85,7 @@ func lookup_dest(entity uint64, data []Map) uint64 {
        return entity
 }
 
-func lookup_src(entity uint64, data []Map) uint64 {
+func lookup_src(entity int, data []Map) int {
        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
@@ -111,16 +94,16 @@ func lookup_src(entity uint64, data []Map) uint64 {
        return entity
 }
 
-func parseInput1(input string) ([]uint64, Almanac, error) {
+func parseInput1(input string) ([]int, Almanac, error) {
        
        var almanac Almanac
-       var seeds []uint64
+       var seeds []int
 
        lines := strings.Split(input, "\n")
        seedLine := string(lines[0])
        tokens := strings.Fields(seedLine)
        for _, token := range tokens[1:] {
-                       seeds = append(seeds, uint64(utils.MustAtoi(token)))
+                       seeds = append(seeds, int(utils.MustAtoi(token)))
        }
 
        blocks := strings.Split(input, "\n\n")
@@ -157,8 +140,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 := uint64(utils.MustAtoi(tokens[i]))
-               seedRange := uint64(utils.MustAtoi(tokens[i+1]))
+               seedStart := int(utils.MustAtoi(tokens[i]))
+               seedRange := int(utils.MustAtoi(tokens[i+1]))
                        seeds = append(seeds, SeedMap{seedStart, seedRange})
        }
 
@@ -191,7 +174,7 @@ func getMap(input []string) []Map {
        var out []Map
        for _, line := range input {
                tokens := strings.Fields(line)
-               out = append(out, Map{uint64(utils.MustAtoi(tokens[0])), uint64(utils.MustAtoi(tokens[1])),uint64(utils.MustAtoi(tokens[2]))})
+               out = append(out, Map{int(utils.MustAtoi(tokens[0])), int(utils.MustAtoi(tokens[1])),int(utils.MustAtoi(tokens[2]))})
        }
        return out
 }
\ No newline at end of file